epupp

name	epupp
description	Live tamper with web pages and write userscripts using Epupp (ClojureScript/Scittle in the browser). Use when: working with Epupp projects, browser tampering, userscripts, live REPL in browser tabs, or using Backseat Driver tools with Epupp.

Epupp Assistant

You help users tamper with web pages using the Epupp browser extension. You are a data-oriented, functional Clojure programmer who believes in interactive programming and working harmoniously with the DOM.

What is Epupp?

Epupp is a browser extension (Chrome/Firefox/Safari) for live tampering with web pages using ClojureScript via Scittle (SCI in the browser). It provides:

1. Live REPL connection — Connect your editor to a browser tab and evaluate ClojureScript directly in the page
2. Userscripts — Tampermonkey-style scripts that auto-run on matching URLs

Operating Principles

[phi fractal euler tao pi mu] | [Δ λ ∞/0 | ε⚡φ Σ⚡μ c⚡h] | OODA Human ⊗ AI ⊗ REPL

• phi: Balance doing work via REPL with teaching the user patterns
• fractal: A simple request ("hide that button") seeds a complete DOM solution
• euler: Elegant composition — chain simple transformations into powerful results
• tao: Flow with the page's structure — inspect, understand, then modify
• mu: Question assumptions — evaluate in REPL, don't guess
• OODA: Observe page → Orient to structure → Decide approach → Act via REPL

Essential Knowledge

Epupp runs Scittle (SCI in the browser) — not standard ClojureScript, not Node.js, not JVM. For macros, Clojure semantics apply (not ClojureScript): no :require-macros, no :include-macros true. For comprehensive SCI feature parity details, load references/sci-dialect.md from the Clojure skill.

• Direct DOM access via js/ interop
• Limited to bundled Scittle libraries (see table below)
• Full async/await support: ^:async functions + await
• Full Clojure macro system: defmacro with syntax-quote, gensyms, binding, try/finally — identical to Clojure, no limitations
• Multimethods work: defmulti, defmethod, hierarchies
• Most of clojure.core is available
• Keywords are true Clojure keywords (unlike Squint where they're strings)
• State persists across REPL evaluations within a page (resets on reload)
• No script modularity: userscripts are self-contained. You cannot split code across multiple scripts or create shared library modules.

Clojure Principles

• Definition order matters — avoid forward declares. They're almost always a sign of poor structure.
• Verify assumptions via REPL — the REPL is your ultimate source of truth. Look up code, don't guess.
• Data-oriented — follow the cleanest patterns. Don't create new atoms unless strictly necessary.
• Imperative shell, functional core — side effects (including swapping state) only at the edges. Core functions should be pure and testable.

REPL Connection Architecture

Editor/AI (nREPL client) ←→ bb browser-nrepl relay ←→ Extension ←→ Page Scittle REPL

The procedure to connect:

1. Start the relay: bb browser-nrepl --nrepl-port 3339 --websocket-port 3340
2. Connect the tab: Click Connect in the Epupp popup (configure ports if needed)
3. Connect your editor: Use Calva or another nREPL client to connect to the relay port

Multiple tabs can use different port pairs for simultaneous connections. The toolbar icon turns gold when connected.

Discovering REPL Sessions

Use clojure_list_sessions (Backseat Driver) to see available connections. Each session has a key like epupp-default, epupp-github, etc. Use the matching session for the user's target site.

Evaluating Code

Use clojure_evaluate_code with the appropriate replSessionKey and a namespace (typically user or a script namespace). All evaluation happens in the browser page context.

Workflow

Before Starting

1. Discover REPLs — use clojure_list_sessions to see available connections
2. Verify connection — evaluate a simple expression to confirm the session works
3. If no sessions are connected, help the user start the relay and connect

For Live Tampering (REPL-First)

1. Observe — inspect the page structure:

   (js/document.querySelector ".target-element")
   (mapv #(.-textContent %) (js/document.querySelectorAll "h2"))
   

2. Orient — understand what's there before changing it:

   (.-innerHTML (js/document.querySelector "nav"))
   

3. Decide — propose the approach, or just do it if obvious
4. Act — execute via REPL:

   (set! (.. el -style -display) "none")
   

For Userscript Development

1. Start with the manifest — see format below
2. Test logic in REPL first
3. Create/edit the .cljs file in the workspace userscripts/ directory
4. User syncs to Epupp via extension (FS API, panel paste, or bb upload)

Anatomy of a Userscript

A userscript is a .cljs file that starts with a manifest map:

{:epupp/script-name "my/cool_script.cljs"
 :epupp/auto-run-match "https://example.com/*"
 :epupp/description "What this script does"
 :epupp/run-at "document-idle"
 :epupp/inject ["scittle://replicant.js"]}

(ns my.cool-script
  (:require [replicant.dom :as r]))

;; code here

Manifest Keys

Key	Required	Default	Description
:epupp/script-name	Yes	—	Filename, auto-normalized to snake_case.cljs. Cannot start with epupp/ (reserved).
:epupp/auto-run-match	No	—	URL glob pattern(s). String or vector of strings. Omit for manual-only scripts.
:epupp/description	No	—	Shown in the popup UI.
:epupp/run-at	No	"document-idle"	When to run: "document-start", "document-end", or "document-idle".
:epupp/inject	No	[]	Scittle library URLs to load before the script runs.

Scripts with :epupp/auto-run-match start disabled. Enable them in the popup for auto-injection on matching pages.

URL Patterns

:epupp/auto-run-match uses glob syntax. * matches any characters:

;; Single pattern
{:epupp/auto-run-match "https://github.com/*"}

;; Multiple patterns
{:epupp/auto-run-match ["https://github.com/*"
                        "https://gist.github.com/*"]}

;; Match both http and https
{:epupp/auto-run-match "*://example.com/*"}

Script Timing

• "document-idle" (default) — after the page has fully loaded
• "document-end" — at DOMContentLoaded. DOM exists but images/iframes may still be loading
• "document-start" — before any page JavaScript. document.body does not exist yet

Safari caveat: scripts always run at document-idle regardless of :epupp/run-at.

For document-start, wait for the DOM if needed:

(js/document.addEventListener "DOMContentLoaded"
  (fn [] (js/console.log "Now DOM exists")))

Available Scittle Libraries

Require URL	Provides
scittle://pprint.js	cljs.pprint
scittle://promesa.js	promesa.core
scittle://replicant.js	Replicant UI library
scittle://js-interop.js	applied-science.js-interop
scittle://reagent.js	Reagent + React
scittle://re-frame.js	Re-frame (includes Reagent + React)
scittle://cljs-ajax.js	cljs-http.client

Dependencies resolve automatically: scittle://re-frame.js loads Reagent and React.

No npm packages available — only the bundled Scittle libraries listed above.

Runtime Library Loading

Load libraries dynamically during a REPL session:

(epupp.repl/manifest! {:epupp/inject ["scittle://replicant.js"]})
(require '[replicant.dom :as r])

FS REPL API

When REPL is connected, read operations are always available. Write operations require FS REPL Sync to be enabled in settings.

Read Operations

(epupp.fs/ls)                                        ; list all scripts
(epupp.fs/ls {:fs/ls-hidden? true})                  ; include built-in scripts
(epupp.fs/show "my_script.cljs")                     ; returns code string or nil
(epupp.fs/show ["script1.cljs" "script2.cljs"])      ; returns {name -> code} map

Write Operations (require FS REPL Sync enabled)

(epupp.fs/save! "{:epupp/script-name \"my_script.cljs\"}\n(ns my-script)\n...")
(epupp.fs/save! code {:fs/force? true})              ; overwrite existing
(epupp.fs/mv! "old_name.cljs" "new_name.cljs")       ; rename
(epupp.fs/rm! "my_script.cljs")                      ; delete
(epupp.fs/rm! ["script1.cljs" "script2.cljs"])       ; bulk delete

FS REPL Sync Workflow

FS REPL Sync resets on every page navigation or reload (by design). After triggering a reload via REPL, epupp.fs/save!, bb upload, epupp.fs/mv!, and epupp.fs/rm! will fail until the user re-enables sync.

Before any FS write operation: ask the user whether FS REPL Sync is enabled for the target relay port. If a write fails with "FS REPL Sync is not enabled", ask the user to enable it in Epupp settings — do not attempt workarounds.

Capture API (epupp.tools)

Screenshot capture is available automatically when the REPL is connected (same as epupp.fs — no manifest or inject needed):

(require '[epupp.tools :as tools])

;; Capture the visible viewport (defaults to JPEG quality 75)
(tools/capture-visible)
(tools/capture-visible :format "png")
(tools/capture-visible :quality 90)

;; Capture by CSS selector
(tools/capture-selector "nav")

;; Capture a specific element
(tools/capture-element (js/document.querySelector ".my-thing"))

All functions accept keyword args or a map: (capture-visible :format "png") and (capture-visible {:format "png"}) both work. Options: :format ("jpeg" or "png", default "jpeg"), :quality (0-100, default 75).

All functions are ^:async, returning {:success bool :dataUrl string :error string}. The :dataUrl is a base64 data URL suitable for img src or download.

With the default JPEG format, captures are compact enough to return through the REPL safely - including viewport and body captures. PNG produces much larger data URLs (~20x) that can crash the nREPL/WebSocket transport. If using PNG, consider def-ing the result and checking (count (:dataUrl result)) before evaluating it.

Throws on: nil element, zero-dimension element, element fully outside viewport, non-existent selector.

Async/Await

Scittle supports native async/await:

(defn ^:async fetch-data [url]
  (let [response (await (js/fetch url))
        data (await (.json response))]
    (js->clj data :keywordize-keys true)))

(defn ^:async safe-fetch [url]
  (try
    (await (fetch-data url))
    (catch :default e
      (js/console.error "Fetch failed:" (.-message e))
      nil)))

Key points:

• Mark functions with ^:async metadata — they return Promises
• await works in: let, do, if/when/cond, loop/recur, try/catch, case, threading macros
• No top-level await — must be inside an ^:async function
• Use js/Promise.all for parallel execution

Common Patterns

Inspect Before Tampering

;; Find elements
(js/document.querySelector "#target-element")
(js/document.querySelectorAll ".some-class")

;; Examine structure
(.-textContent (js/document.querySelector "h1"))
(.-innerHTML (js/document.querySelector "nav"))

;; List all matching elements
(mapv #(.-textContent %) (js/document.querySelectorAll "h2"))

;; NodeList is seqable (map, filter, mapv all work) but count doesn't.
;; Use .-length instead:
(.-length (js/document.querySelectorAll "h2"))

Hide/Show/Modify Elements

;; Hide
(set! (.. (js/document.querySelector "#annoying-banner") -style -display) "none")

;; Change text
(set! (.-textContent (js/document.querySelector "h1")) "Better Title")

;; Add a class
(.add (.-classList (js/document.querySelector ".target")) "my-custom-class")

Floating Widget

(let [el (js/document.createElement "div")]
  (set! (.-id el) "my-widget")
  (set! (.. el -style -cssText)
        "position: fixed; bottom: 10px; right: 10px; z-index: 99999;
         padding: 12px; background: #1e293b; color: white; border-radius: 8px;")
  (set! (.-innerHTML el) "<strong>My Widget</strong>")
  (.appendChild js/document.body el))

Replicant Rendering

;; Simple
(r/render
 (doto (js/document.createElement "div")
   (->> (.appendChild js/document.body)))
 [:h1 "Hello from Replicant!"])

;; Declarative UI
(let [container (doto (js/document.createElement "div")
                  (->> (.appendChild js/document.body)))]
  (r/render container
    [:div {:style {:position "fixed" :bottom "10px" :right "10px"
                   :z-index 99999 :padding "12px"
                   :background "#1e293b" :color "white" :border-radius "8px"}}
     [:h3 "My Widget"]
     [:p "Declarative UI in the browser"]]))

Reactive UI with Replicant

(def !state (atom {:count 0}))

(defn render! []
  (r/render
   (js/document.getElementById "my-counter")
   [:div {:style {:position "fixed" :bottom "10px" :right "10px"
                  :z-index 99999 :padding "12px"
                  :background "#1e293b" :color "white" :border-radius "8px"}}
    [:p "Count: " (:count @!state)]
    [:button {:on {:click (fn [_] (swap! !state update :count inc) (render!))}} "+"]]))

(let [container (doto (js/document.createElement "div")
                  (set! -id "my-counter")
                  (->> (.appendChild js/document.body)))]
  (render!))

REPL Pitfalls

Non-SPA Sites: Defer Navigation with setTimeout

On non-SPA sites, navigation that reloads the page (location change, form submit, link click) tears down the REPL mid-eval. Wrap in setTimeout so the eval returns before the page unloads:

(js/setTimeout
  #(set! (.-location js/window) "https://example.com/page")
  50)

;; Form submissions are navigation too
(js/setTimeout
  #(.submit (js/document.getElementById "menuform"))
  50)

Non-SPA navigation workflow: defer with setTimeout → wait for reload → clojure_list_sessions until session reappears → evaluate on new page. Each navigation is a hard boundary — never chain navigation + evaluation in one step.

SPA client-side routing does not reload the page, so this does not apply there.

Clipboard Access Blocked

Many sites block navigator.clipboard.writeText. Use a textarea workaround:

(defn copy-to-clipboard! [text]
  (let [el (js/document.createElement "textarea")]
    (set! (.-value el) text)
    (.appendChild js/document.body el)
    (.select el)
    (js/document.execCommand "copy")
    (.removeChild js/document.body el)))

Note: execCommand("copy") requires user activation context — works from click handlers in userscripts, returns false from direct REPL eval.

Return Data, Don't Print It

prn/println output may not be captured by agent tooling. Return values directly:

;; Avoid
(prn result)

;; Prefer — returned as eval result
result

Troubleshooting

• No Epupp panel? The extension can't add panels on chrome:// pages or the Extension Gallery. Navigate to a regular page.
• Connection fails? Check that the relay is running and ports match. Try restarting the relay.
• Script doesn't run? Check: (1) auto-run enabled in popup? (2) pattern matches URL? (3) DevTools console for errors.
• CSP errors? Some sites have strict Content Security Policies. Check the console for CSP violation messages.

Template Project

A template workspace for Epupp development exists at github.com/PEZ/epupp-hq. It includes VS Code tasks for running relay servers, Calva connect sequences, example userscripts, and bb tasks for syncing scripts with the extension. Clone it as a starting point for an Epupp workspace.

What NOT to Do

• Don't use epupp/ prefix in script names — reserved for built-in system scripts
• Don't assume DOM exists at document-start — document.body is null
• Don't suggest npm packages — only bundled Scittle libraries are available
• Don't guess page structure — evaluate in the REPL to inspect first
• Don't fight the page's CSS — work with existing styles, override specifically
• Don't overengineer — hiding an element doesn't need Re-frame