opencode-browser-annotation-plugin 0.6.2 → 0.8.0

package/README.md

@@ -177,8 +177,21 @@ The plugin source is `src/plugin.ts`; the extension is plain MV3 in `extension/`
 ## Limits
 
 - Text + element metadata only; no screenshot is sent or seen by the model.
-- The plugin injects into the most recently active session (tracked via the
-  `chat.message` hook). Send a message first so a session is active.
+- The picker lists every recent session across all projects and all running
+  OpenCode processes, with sessions you've touched this run floating to the top.
+  Pick any by id; without a `sessionID` the plugin targets the most recently
+  active one.
+- Cross-process aggregation: each OpenCode process only serves its own sessions
+  through its in-process API, so every plugin instance also runs a small peer
+  server on an ephemeral port and registers `{pid, port, directory}` under
+  `$XDG_DATA_HOME/opencode/annotation-peers/`. The instance that wins the shared
+  endpoint (default `39517`) fans `/status` and `/annotations` out to all live
+  peers, merges the session lists, and routes each annotation to the process that
+  owns the target session. Dead instances' registry files are reaped
+  automatically (pid liveness + staleness), and the extension's contract
+  (`/status`, `POST /annotations`) is unchanged.
+- Send a message first so a session is active if you rely on the no-`sessionID`
+  fallback.
 
 ## License
 

package/dist/plugin.js

@@ -1,4 +1,7 @@
 import { createServer } from "node:http";
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
 /**
  * opencode-browser-annotation-plugin
  *
@@ -15,6 +18,29 @@ import { createServer } from "node:http";
  */
 const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_PORT = 39_517;
+/**
+ * Each OpenCode process runs its own in-process API server, and a plugin's
+ * `client` can only see the sessions of ITS OWN process. To list/target sessions
+ * across every running OpenCode (different projects and processes), each plugin
+ * instance also starts a tiny "peer" HTTP server on an ephemeral port and drops
+ * a registry file naming it. Whichever instance wins the shared endpoint port
+ * (DEFAULT_PORT) fans /status and /annotations out to every registered peer and
+ * merges the results, so the browser extension sees one unified session list and
+ * an annotation reaches whichever process owns the target session.
+ */
+function registryDir() {
+    const base = process.env.XDG_DATA_HOME?.trim() || join(homedir(), ".local", "share");
+    const dir = join(base, "opencode", "annotation-peers");
+    try {
+        mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    catch {
+        const fallback = join(tmpdir(), "opencode-annotation-peers");
+        mkdirSync(fallback, { recursive: true });
+        return fallback;
+    }
+}
 function envHost() {
     return process.env.OPENCODE_ANNOTATION_HOST?.trim() || DEFAULT_HOST;
 }
@@ -143,57 +169,48 @@ export const BrowserAnnotationPlugin = async ({ client, directory }) => {
     const host = envHost();
     const port = envPort();
     let activeSessionID = null;
-    let server = null;
-    // Sessions that showed activity in THIS OpenCode run (created, messaged, or
-    // status/idle events). OpenCode has no open/closed flag, so this approximates
-    // "sessions you're currently working in". Deleted sessions are removed.
+    let server = null; // the shared endpoint (DEFAULT_PORT), if we won it
+    let peerServer = null; // this instance's own peer server
+    let peerPort = 0;
+    let peerFile = null;
+    let registryTimer = null;
+    const PEER_STALE_MS = 30 * 1000; // a peer file older than this is treated as dead
+    const REGISTRY_REFRESH_MS = 10 * 1000;
+    // Sessions this run has touched (created / messaged / status / idle). Used
+    // only to bias the picker ordering — NOT to filter — so sessions from other
+    // OpenCode processes and other project directories still appear.
     const activeIDs = new Set();
-    const RECENT_FALLBACK_MS = 2 * 60 * 60 * 1000; // 2h
-    const RECENT_FALLBACK_MAX = 8;
+    // The picker shows every recent session merged across all instances.
+    const RECENT_MAX = 25;
     const log = (level, message, extra) => {
         void client.app
             .log({ body: { service: "browser-annotation", level, message, extra } })
             .catch(() => { });
     };
-    async function allSessions() {
+    /** Sessions owned by THIS OpenCode process (its own in-process server). */
+    async function localSessions() {
         try {
-            const res = (await client.session.list({ query: { directory } }));
+            const res = (await client.session.list({}));
             const rows = Array.isArray(res) ? res : Array.isArray(res?.data) ? res.data : [];
             return rows
                 .filter((s) => s && typeof s.id === "string" && !s.parentID)
-                .map((s) => ({ id: s.id, title: typeof s.title === "string" ? s.title : s.id, updated: s.time?.updated ?? 0 }));
+                .map((s) => ({
+                id: s.id,
+                title: typeof s.title === "string" ? s.title : s.id,
+                updated: s.time?.updated ?? 0,
+                directory,
+            }));
         }
         catch (error) {
             log("warn", `session.list failed: ${error instanceof Error ? error.message : "unknown"}`);
             return [];
         }
     }
-    /**
-     * The picker list: sessions active in this run (newest first). If none have
-     * been observed yet (e.g. right after a restart), fall back to the most
-     * recently updated few so the picker is not empty. All live in this one
-     * process, so any can be targeted over the single port.
-     */
-    async function listSessions() {
-        const all = await allSessions();
-        const byRecent = [...all].sort((a, b) => b.updated - a.updated);
-        // Prune ids that no longer exist.
-        const existing = new Set(all.map((s) => s.id));
-        for (const id of activeIDs)
-            if (!existing.has(id))
-                activeIDs.delete(id);
-        if (activeIDs.size > 0) {
-            return byRecent.filter((s) => activeIDs.has(s.id));
-        }
-        const now = Date.now();
-        const recent = byRecent.filter((s) => now - s.updated < RECENT_FALLBACK_MS).slice(0, RECENT_FALLBACK_MAX);
-        return recent.length ? recent : byRecent.slice(0, RECENT_FALLBACK_MAX);
-    }
-    async function injectPrompt(sessionID, annotations) {
+    /** Inject into a session THIS process owns. */
+    async function localInject(sessionID, annotations) {
         try {
             await client.session.promptAsync({
                 path: { id: sessionID },
-                query: { directory },
                 body: { parts: [{ type: "text", text: buildPrompt(annotations) }] },
             });
             return { ok: true };
@@ -202,15 +219,109 @@ export const BrowserAnnotationPlugin = async ({ client, directory }) => {
             return { ok: false, error: error instanceof Error ? error.message : "session.prompt failed" };
         }
     }
-    async function handleSubmit(annotations, requestedSessionID) {
-        // Prefer the explicitly targeted session; fall back to the last active one.
-        let targetID = requestedSessionID || activeSessionID;
-        if (requestedSessionID) {
-            const sessions = await listSessions();
-            if (!sessions.some((s) => s.id === requestedSessionID)) {
-                return { ok: false, error: "Target session no longer exists.", injected: 0 };
+    // ——— Peer registry: discover other OpenCode processes' plugin instances ———
+    function readPeers() {
+        const dir = registryDir();
+        const now = Date.now();
+        const out = [];
+        let files = [];
+        try {
+            files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+        }
+        catch {
+            return out;
+        }
+        for (const f of files) {
+            const full = join(dir, f);
+            try {
+                const rec = JSON.parse(readFileSync(full, "utf8"));
+                const alive = typeof rec.pid === "number" && isAlive(rec.pid);
+                const fresh = typeof rec.updated === "number" && now - rec.updated < PEER_STALE_MS;
+                if (rec.port && alive && fresh)
+                    out.push(rec);
+                else if (!alive)
+                    rmSync(full, { force: true }); // reap dead instance's file
+            }
+            catch {
+                rmSync(full, { force: true });
+            }
+        }
+        return out;
+    }
+    function isAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async function peerFetch(port, path, body) {
+        try {
+            const res = await fetch(`http://${host}:${port}${path}`, {
+                method: body ? "POST" : "GET",
+                headers: body ? { "content-type": "application/json" } : undefined,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: AbortSignal.timeout(4000),
+            });
+            return await res.json();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Merged picker list: this process's own sessions plus every live peer's,
+     * de-duplicated, touched-this-run first, then newest. Only the endpoint owner
+     * fans out; a plain peer just returns its own via /local.
+     */
+    async function mergedSessions() {
+        const mine = await localSessions();
+        const peers = readPeers().filter((p) => p.port !== peerPort);
+        const peerLists = await Promise.all(peers.map(async (p) => {
+            const data = await peerFetch(p.port, "/local");
+            const rows = data && Array.isArray(data.sessions) ? data.sessions : [];
+            return rows;
+        }));
+        const byId = new Map();
+        for (const s of [...mine, ...peerLists.flat()]) {
+            const prev = byId.get(s.id);
+            if (!prev || s.updated > prev.updated)
+                byId.set(s.id, s);
+        }
+        const all = [...byId.values()];
+        const existing = new Set(all.map((s) => s.id));
+        for (const id of activeIDs)
+            if (!existing.has(id))
+                activeIDs.delete(id);
+        const byRecent = all.sort((a, b) => b.updated - a.updated);
+        const touched = byRecent.filter((s) => activeIDs.has(s.id));
+        const rest = byRecent.filter((s) => !activeIDs.has(s.id));
+        return [...touched, ...rest].slice(0, RECENT_MAX);
+    }
+    /** Route an inject to whichever instance owns the target session. */
+    async function routeInject(sessionID, annotations) {
+        const mineIds = new Set((await localSessions()).map((s) => s.id));
+        if (mineIds.has(sessionID))
+            return localInject(sessionID, annotations);
+        for (const p of readPeers()) {
+            if (p.port === peerPort)
+                continue;
+            const data = await peerFetch(p.port, "/local");
+            const ids = data && Array.isArray(data.sessions) ? data.sessions.map((s) => s.id) : [];
+            if (ids.includes(sessionID)) {
+                const r = await peerFetch(p.port, "/inject", { sessionID, annotations });
+                if (r && r.ok)
+                    return { ok: true };
+                return { ok: false, error: (r && r.error) || "peer inject failed" };
             }
         }
+        // Not found on any peer; last-ditch try locally (id may have just moved).
+        return localInject(sessionID, annotations);
+    }
+    async function handleSubmit(annotations, requestedSessionID) {
+        const targetID = requestedSessionID || activeSessionID;
         if (!targetID) {
             return {
                 ok: false,
@@ -218,18 +329,90 @@ export const BrowserAnnotationPlugin = async ({ client, directory }) => {
                 injected: 0,
             };
         }
-        const result = await injectPrompt(targetID, annotations);
+        if (requestedSessionID) {
+            const sessions = await mergedSessions();
+            if (!sessions.some((s) => s.id === requestedSessionID)) {
+                return { ok: false, error: "Target session no longer exists.", injected: 0 };
+            }
+        }
+        const result = await routeInject(targetID, annotations);
         if (!result.ok)
             return { ok: false, error: result.error, injected: 0, sessionID: targetID };
         return { ok: true, injected: annotations.length, sessionID: targetID };
     }
+    // ——— Peer server: this instance's own endpoint for the fan-out owner ———
+    function peerHandle(req, res) {
+        if (req.method === "GET" && req.url === "/local") {
+            void localSessions().then((sessions) => sendJson(res, 200, { ok: true, sessions }));
+            return;
+        }
+        if (req.method === "POST" && req.url === "/inject") {
+            readJsonBody(req)
+                .then(async (parsed) => {
+                const p = (parsed ?? {});
+                const annotations = Array.isArray(p.annotations) ? p.annotations : [];
+                if (!p.sessionID || annotations.length === 0) {
+                    sendJson(res, 400, { ok: false, error: "sessionID and annotations required." });
+                    return;
+                }
+                const r = await localInject(p.sessionID, annotations);
+                sendJson(res, r.ok ? 200 : 409, r);
+            })
+                .catch((error) => sendJson(res, 400, { ok: false, error: error instanceof Error ? error.message : "bad request" }));
+            return;
+        }
+        sendJson(res, 404, { ok: false, error: "Not found" });
+    }
+    function writePeerFile() {
+        if (!peerPort)
+            return;
+        try {
+            const dir = registryDir();
+            peerFile = join(dir, `${process.pid}.json`);
+            const rec = { pid: process.pid, port: peerPort, directory, updated: Date.now() };
+            writeFileSync(peerFile, JSON.stringify(rec));
+        }
+        catch {
+            /* registry unavailable — this instance simply won't be discoverable */
+        }
+    }
+    function startPeerServer() {
+        const s = createServer(peerHandle);
+        s.on("error", () => {
+            /* ephemeral port clash is unlikely; if it happens, stay undiscoverable */
+        });
+        s.listen(0, host, () => {
+            const addr = s.address();
+            peerPort = typeof addr === "object" && addr ? addr.port : 0;
+            peerServer = s;
+            writePeerFile();
+            registryTimer = setInterval(writePeerFile, REGISTRY_REFRESH_MS);
+            log("info", `Annotation peer server on http://${host}:${peerPort} (pid ${process.pid})`);
+        });
+    }
+    function cleanupPeer() {
+        if (registryTimer)
+            clearInterval(registryTimer);
+        registryTimer = null;
+        if (peerFile) {
+            try {
+                rmSync(peerFile, { force: true });
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        peerServer?.close();
+        peerServer = null;
+    }
+    // ——— Shared endpoint (the port the extension talks to) ———
     function handle(req, res) {
         if (req.method === "OPTIONS") {
             sendJson(res, 204, {});
             return;
         }
         if (req.method === "GET" && req.url === "/status") {
-            void listSessions().then((sessions) => {
+            void mergedSessions().then((sessions) => {
                 const active = sessions.find((s) => s.id === activeSessionID);
                 sendJson(res, 200, {
                     ok: true,
@@ -276,8 +459,8 @@ export const BrowserAnnotationPlugin = async ({ client, directory }) => {
         const s = createServer(handle);
         server = s; // claim synchronously so a re-entrant start() is a no-op
         s.on("error", (error) => {
-            // Another instance already owns the port. Drop this half-open server so we
-            // don't leave a listener that resets connections without responding.
+            // Another instance already owns the endpoint. Drop this half-open server;
+            // we still serve our sessions to the owner via the peer server.
             server = null;
             s.close();
             if (error.code !== "EADDRINUSE") {
@@ -288,7 +471,15 @@ export const BrowserAnnotationPlugin = async ({ client, directory }) => {
             log("info", `Browser annotation server listening on http://${host}:${port}`);
         });
     }
+    // Always start the peer server (every instance is discoverable); then try to
+    // win the shared endpoint. Whoever wins fans out to all peers.
+    startPeerServer();
     start();
+    // Best-effort registry cleanup so a gone instance stops being advertised.
+    // (readPeers also reaps files whose pid is dead, as a backstop.)
+    for (const sig of ["exit", "SIGINT", "SIGTERM"]) {
+        process.once(sig, cleanupPeer);
+    }
     return {
         "chat.message": async (input) => {
             if (input?.sessionID) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-browser-annotation-plugin",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "description": "Select an element in your browser, type an instruction, and send it to your OpenCode agent over a loopback + SSH tunnel. Text and element metadata only (no screenshots).",
   "keywords": [
     "opencode",