jarvis-hq 0.0.3

package/dist/jarvis.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jarvisDir = jarvisDir;
+exports.projectsDir = projectsDir;
+exports.ensureJarvisDir = ensureJarvisDir;
+exports.slugify = slugify;
+exports.projectFile = projectFile;
+exports.listProjects = listProjects;
+exports.findProject = findProject;
+exports.createProject = createProject;
+exports.getProject = getProject;
+exports.updateProjectNotes = updateProjectNotes;
+exports.unregisteredFolders = unregisteredFolders;
+exports.jarvisBot = jarvisBot;
+exports.ensureJarvisBot = ensureJarvisBot;
+exports.projectBot = projectBot;
+exports.ensureProjectBot = ensureProjectBot;
+exports.syncProjectBots = syncProjectBots;
+exports.jarvisInstructions = jarvisInstructions;
+exports.projectInstructions = projectInstructions;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const bot_store_1 = require("./bot-store");
+const workspace_1 = require("./workspace");
+/**
+ * Jarvis is the persistent engineering partner: one agent that knows every
+ * project and decides where work should happen. Its world is a directory:
+ *
+ *   ~/jarvis/
+ *     CLAUDE.md          notes about the user, editable by hand and by Jarvis
+ *     projects/
+ *       grass.md         one file per project: where it lives, what it is
+ *
+ * A project is a Markdown file with a small front matter (name, path, repo)
+ * and free-form notes under it. Nothing more structured than that: the file is
+ * meant to grow as Jarvis learns the project, not to be filled in like a form.
+ *
+ * Both Jarvis and each project are Bots in the hub, so threads, resume, the
+ * transcript reader and the UI all work unchanged. This module owns the files
+ * and keeps those bots in step with them.
+ */
+// --- Directories ---
+function jarvisDir() {
+    return process.env.JARVIS_DIR || (0, path_1.join)((0, os_1.homedir)(), "jarvis");
+}
+function projectsDir() {
+    return (0, path_1.join)(jarvisDir(), "projects");
+}
+/** Creates the Jarvis directory on first run, with a starter CLAUDE.md. */
+function ensureJarvisDir() {
+    const dir = jarvisDir();
+    if (!(0, fs_1.existsSync)(projectsDir()))
+        (0, fs_1.mkdirSync)(projectsDir(), { recursive: true });
+    const notes = (0, path_1.join)(dir, "CLAUDE.md");
+    if (!(0, fs_1.existsSync)(notes))
+        (0, fs_1.writeFileSync)(notes, STARTER_NOTES, "utf-8");
+}
+const STARTER_NOTES = `# Jarvis notes
+
+This file is loaded into every Jarvis conversation. Keep here what Jarvis
+should always know: who you are, how you like work reported, standing rules
+("never merge without asking"), people and their GitHub handles, and anything
+else that is not specific to one project. Project-specific knowledge belongs
+in projects/<name>.md instead.
+
+## About me
+
+## Standing rules
+
+- Never merge, push to a shared branch, or delete anything unless I explicitly
+  ask for it in the conversation.
+
+## People
+`;
+function slugify(name) {
+    return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+}
+function projectFile(slug) {
+    return (0, path_1.join)(projectsDir(), `${slug}.md`);
+}
+/** Parses a project file: `key: value` lines between `---` fences, then notes. */
+function parseProject(slug, raw, mtime) {
+    const meta = {};
+    let notes = raw;
+    const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+    if (m) {
+        for (const line of m[1].split(/\r?\n/)) {
+            const kv = line.match(/^([A-Za-z_]+):\s*(.*)$/);
+            if (kv)
+                meta[kv[1].toLowerCase()] = kv[2].trim();
+        }
+        notes = raw.slice(m[0].length);
+    }
+    const path = meta.path || "";
+    return {
+        slug,
+        name: meta.name || slug,
+        path,
+        pathMissing: path ? !(0, fs_1.existsSync)(path) : undefined,
+        repo: meta.repo || undefined,
+        notes: notes.trim(),
+        updatedAt: mtime.toISOString(),
+    };
+}
+function serializeProject(p) {
+    const head = [`name: ${p.name}`, `path: ${p.path}`, ...(p.repo ? [`repo: ${p.repo}`] : [])];
+    return `---\n${head.join("\n")}\n---\n\n${p.notes.trim()}\n`;
+}
+function listProjects() {
+    const dir = projectsDir();
+    if (!(0, fs_1.existsSync)(dir))
+        return [];
+    const out = [];
+    for (const f of (0, fs_1.readdirSync)(dir)) {
+        if (!f.endsWith(".md"))
+            continue;
+        const file = (0, path_1.join)(dir, f);
+        try {
+            out.push(parseProject(f.slice(0, -3), (0, fs_1.readFileSync)(file, "utf-8"), (0, fs_1.statSync)(file).mtime));
+        }
+        catch (err) {
+            console.error(`[jarvis] could not read ${file}: ${err.message}`);
+        }
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Finds a project by however the user referred to it: slug, name, or a loose
+ * match ("zap eve" → zap-eve, "the grass repo" → grass). Returns undefined
+ * rather than guessing when nothing is close.
+ */
+function findProject(ref) {
+    const projects = listProjects();
+    const want = slugify(ref);
+    if (!want)
+        return undefined;
+    return projects.find((p) => p.slug === want)
+        ?? projects.find((p) => slugify(p.name) === want)
+        ?? projects.find((p) => want.includes(p.slug) || p.slug.includes(want))
+        ?? projects.find((p) => (0, path_1.basename)(p.path) && slugify((0, path_1.basename)(p.path)) === want);
+}
+/**
+ * Registers a project. Clones the repo into the workspace when no checkout is
+ * given, writes the project file, and makes sure the project has a bot.
+ */
+function createProject(input, workspaceCwd) {
+    const name = input.name.trim();
+    if (!name)
+        throw new Error("A project needs a name");
+    const slug = slugify(name);
+    if ((0, fs_1.existsSync)(projectFile(slug)))
+        throw new Error(`Project "${name}" already exists`);
+    let path = input.path ? (0, path_1.resolve)(input.path) : "";
+    if (path && !(0, fs_1.existsSync)(path))
+        throw new Error(`No such directory: ${path}`);
+    if (!path) {
+        if (!input.repo)
+            throw new Error("Give either a repo URL to clone or the path of an existing checkout");
+        const folder = (0, path_1.basename)(input.repo.replace(/\/+$/, "")).replace(/\.git$/, "");
+        const existing = (0, path_1.join)(workspaceCwd, folder);
+        // A checkout already sitting in the workspace is the project; don't clone beside it.
+        path = (0, fs_1.existsSync)((0, path_1.join)(existing, ".git")) ? existing : (0, workspace_1.cloneRepo)(input.repo, workspaceCwd);
+    }
+    const repo = input.repo || detectRemote(path);
+    (0, fs_1.writeFileSync)(projectFile(slug), serializeProject({ name, path, repo, notes: input.notes ?? `# ${name}\n` }), "utf-8");
+    const project = getProject(slug);
+    ensureProjectBot(project);
+    return project;
+}
+function getProject(slug) {
+    const file = projectFile(slug);
+    if (!(0, fs_1.existsSync)(file))
+        return undefined;
+    return parseProject(slug, (0, fs_1.readFileSync)(file, "utf-8"), (0, fs_1.statSync)(file).mtime);
+}
+/** Rewrites the notes (everything under the front matter); metadata stays. */
+function updateProjectNotes(slug, notes) {
+    const p = getProject(slug);
+    if (!p)
+        throw new Error(`No project "${slug}"`);
+    (0, fs_1.writeFileSync)(projectFile(slug), serializeProject({ ...p, notes }), "utf-8");
+    const next = getProject(slug);
+    ensureProjectBot(next);
+    return next;
+}
+function detectRemote(path) {
+    try {
+        const { execSync } = require("child_process");
+        return execSync("git remote get-url origin", { cwd: path, encoding: "utf-8", stdio: "pipe" }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Folders in the workspace that no project claims — candidates for adoption. */
+function unregisteredFolders(workspaceCwd) {
+    const claimed = new Set(listProjects().map((p) => (0, path_1.resolve)(p.path)));
+    try {
+        return (0, fs_1.readdirSync)(workspaceCwd, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+            .map((e) => ({ name: e.name, path: (0, path_1.join)(workspaceCwd, e.name), isGit: (0, fs_1.existsSync)((0, path_1.join)(workspaceCwd, e.name, ".git")) }))
+            .filter((d) => !claimed.has((0, path_1.resolve)(d.path)));
+    }
+    catch {
+        return [];
+    }
+}
+// --- Bots ---
+// Jarvis and each project are bots, so the rest of the hub needs no special
+// cases. Their definitions are derived, so they are regenerated on every
+// ensure rather than edited by hand.
+function jarvisBot() {
+    return (0, bot_store_1.listBots)().find((b) => b.role === "jarvis");
+}
+function ensureJarvisBot() {
+    ensureJarvisDir();
+    const def = {
+        name: "Jarvis",
+        emoji: "\u{1F9E0}",
+        description: "Your engineering partner. Knows every project; decides where work happens.",
+        instructions: jarvisInstructions(),
+        repoPath: jarvisDir(),
+        permissionMode: "auto-approve",
+        // No shell: Jarvis keeps its notes with the file tools and does everything
+        // else through project agents, which is the point of it.
+        disallowedTools: ["Bash"],
+        role: "jarvis",
+    };
+    const existing = jarvisBot();
+    if (existing)
+        return (0, bot_store_1.updateBot)(existing.id, def) ?? existing;
+    return (0, bot_store_1.createBot)(def);
+}
+function projectBot(slug) {
+    return (0, bot_store_1.listBots)().find((b) => b.role === "project" && b.projectSlug === slug);
+}
+function ensureProjectBot(project) {
+    const def = {
+        name: project.name,
+        emoji: "\u{1F4E6}",
+        description: firstLine(project.notes) || `The ${project.name} project agent.`,
+        instructions: projectInstructions(project),
+        repoPath: project.path,
+        permissionMode: "auto-approve",
+        role: "project",
+        projectSlug: project.slug,
+    };
+    const existing = projectBot(project.slug);
+    if (existing)
+        return (0, bot_store_1.updateBot)(existing.id, def) ?? existing;
+    return (0, bot_store_1.createBot)(def);
+}
+/** Brings every project bot up to date with its file; run at startup. */
+function syncProjectBots() {
+    for (const p of listProjects())
+        ensureProjectBot(p);
+}
+function firstLine(md) {
+    return md.split("\n").map((l) => l.replace(/^#+\s*/, "").trim()).find((l) => l && !l.startsWith("#")) ?? "";
+}
+// --- Prompts ---
+/**
+ * What Jarvis is and how it works. Appended to Claude Code's own prompt; the
+ * user's CLAUDE.md under ~/jarvis rides in through the normal project-settings
+ * path, so this stays about the role and the tools.
+ */
+function jarvisInstructions() {
+    return `You are Jarvis, a persistent AI engineering partner. The user talks to you first about
+anything engineering-related; you work out which project it concerns and how the work should
+be carried out. You are not the coding agent: real repo-level work is done by project agents
+(Claude Code sessions running inside a project's checkout) that you dispatch.
+
+YOUR WORLD
+- Your working directory (${jarvisDir()}) holds CLAUDE.md (notes about the user) and
+  projects/<slug>.md, one file per project. Read and edit these files freely; they are yours.
+- A project is more than a repository: the file records where the checkout is, the remote,
+  people, useful commands, architecture notes and what has been done before. Add to a project's
+  notes whenever you learn something that will save time next time (use update_project).
+
+TOOLS
+- list_projects: every project you know, plus workspace folders nobody has claimed yet.
+- read_project: a project's full notes.
+- create_project: register a project from a repo URL (cloned into the workspace) or an existing
+  folder. Use it once you know enough; then continue the original request.
+- update_project: rewrite a project's notes.
+- delegate: give a project agent a bounded task and get its report back. It blocks until the
+  agent finishes, which may take minutes. You may call it for several projects at once.
+- handoff: move the conversation into a project. The project agent takes over from the next
+  message on and answers the user directly; your turn should end right after the call with at
+  most one short line. Use the message argument to pass the user's request in full, with any
+  context they gave you.
+
+HANDOFF OR DELEGATE
+- Handoff is the default whenever a request concerns one project, however small: a question
+  about it, a review, a fix. The user's attention is moving into that project and their
+  follow-ups ("why did we do that?", "review it properly") should land there, with the context
+  the agent already has. Do not delegate a single-project request just because it looks quick.
+- Delegate when you must stay in charge: the request spans several projects, you need a result
+  in order to combine it with something else, or the user asked you for a synthesis.
+- Never do repo-level work yourself (reading code, running tests, git). Dispatch it.
+
+UNKNOWN PROJECTS
+- If the user names a project you do not have, do not fail and do not poke at the folder
+  yourself. Check list_projects: an unclaimed workspace folder with a matching name is almost
+  certainly it, so create_project with that path, say so in a few words, and carry on with the
+  original request through the new project agent. Otherwise ask which repository it is (URL or
+  path), then create_project and continue.
+
+RULES
+- Project agents may edit code, run tests and open branches, but nothing is merged, pushed to a
+  shared branch or deleted unless the user said so in this conversation. Pass that constraint
+  along explicitly when you dispatch work.
+- Be brief. The user is often on a phone. Lead with the answer or the outcome; no preamble.
+- Refer to people, projects and PRs by the names the user uses.`;
+}
+/**
+ * The project agent is ordinary Claude Code in the checkout, with the project
+ * file as standing context and the guardrails Jarvis relies on.
+ */
+function projectInstructions(project) {
+    return `You are the project agent for "${project.name}". You run inside its checkout at
+${project.path}${project.repo ? ` (remote: ${project.repo})` : ""} and do the actual engineering
+work here: reading code, git history, reviewing changes, running tests and dev servers, using
+gh, Playwright and whatever else is installed, and making changes when asked.
+
+The user reached you through Jarvis, their engineering partner, and may be on a phone. They
+may continue this conversation directly. Lead with the outcome; keep reports short and
+concrete: what you looked at, what you found, what you changed, what remains.
+
+Standing rules:
+- Do not merge, push to a shared branch, force-push or delete anything unless the user
+  explicitly asked for it in this conversation. Work on a branch when changing code.
+- When a task was delegated by Jarvis, finish it and end with a clear report; Jarvis passes
+  your final message on.
+
+Project notes (kept at ${projectFile(project.slug)}; update them when you learn something
+durable about this project):
+
+${project.notes || "(no notes yet)"}`;
+}

package/dist/ls.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ls = ls;
+const prompts_1 = require("@inquirer/prompts");
+const progress_1 = require("./progress");
+const sandboxes = [
+    { name: "my-saas-app", agent: "Claude", lastOpened: "2 minutes ago" },
+    { name: "blog-redesign", agent: "OpenCode", lastOpened: "1 hour ago" },
+    { name: "api-server", agent: "Claude", lastOpened: "3 hours ago" },
+    { name: "mobile-backend", agent: "Cursor", lastOpened: "yesterday" },
+    { name: "landing-page", agent: "Windsurf", lastOpened: "2 days ago" },
+    { name: "data-pipeline", agent: "Claude", lastOpened: "3 days ago" },
+    { name: "chrome-extension", agent: "OpenCode", lastOpened: "1 week ago" },
+];
+function pad(str, len) {
+    return str.padEnd(len);
+}
+async function ls() {
+    console.log();
+    console.log("  Available sandboxes:");
+    console.log();
+    const nameCol = 20;
+    const agentCol = 12;
+    let chosen;
+    try {
+        chosen = await (0, prompts_1.select)({
+            message: "Select a sandbox",
+            choices: sandboxes.map((s) => ({
+                name: `${pad(s.name, nameCol)} ${pad(s.agent, agentCol)} ${s.lastOpened}`,
+                value: s,
+            })),
+        });
+    }
+    catch {
+        console.log();
+        process.exit(0);
+    }
+    console.log();
+    console.log(`  Loading ${chosen.name}...`);
+    console.log();
+    await (0, progress_1.runProgress)([
+        { label: "Connecting to sandbox...", duration: 2000 },
+        { label: "Restoring session...", duration: 1500 },
+        { label: "Ready!", duration: 1500 },
+    ]);
+}

package/dist/progress.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProgress = runProgress;
+const cli_progress_1 = __importDefault(require("cli-progress"));
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runProgress(steps) {
+    const bar = new cli_progress_1.default.SingleBar({
+        format: "{step} [{bar}] {percentage}%",
+        hideCursor: true,
+        barCompleteChar: "\u2588",
+        barIncompleteChar: "\u2591",
+    }, cli_progress_1.default.Presets.shades_classic);
+    const totalDuration = steps.reduce((sum, s) => sum + s.duration, 0);
+    let elapsed = 0;
+    bar.start(totalDuration, 0, { step: steps[0].label });
+    for (const step of steps) {
+        bar.update(elapsed, { step: step.label });
+        const tickInterval = 100;
+        const ticks = step.duration / tickInterval;
+        for (let i = 0; i < ticks; i++) {
+            await sleep(tickInterval);
+            elapsed += tickInterval;
+            bar.update(elapsed, { step: step.label });
+        }
+    }
+    bar.update(totalDuration, { step: "Done!" });
+    bar.stop();
+}

package/dist/relay-client.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRelayMode = startRelayMode;
+const ws_1 = __importDefault(require("ws"));
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const server_common_1 = require("./server-common");
+const server_1 = require("./server");
+// --- RelayRequest ---
+// Implements IRequest without depending on a real socket.
+// The body is already available as a string from the WS frame.
+class RelayRequest {
+    constructor(method, url, headers, body) {
+        this._closeListeners = [];
+        this._dataListeners = [];
+        this._endListeners = [];
+        this._errorListeners = [];
+        this.method = method;
+        this.url = url;
+        this.headers = headers;
+        this._body = body;
+    }
+    on(event, listener) {
+        if (event === "close")
+            this._closeListeners.push(listener);
+        else if (event === "data")
+            this._dataListeners.push(listener);
+        else if (event === "end")
+            this._endListeners.push(listener);
+        else if (event === "error")
+            this._errorListeners.push(listener);
+        return this;
+    }
+    // Called by relay-client to deliver the body to readBody() callers
+    emitBody() {
+        if (this._body) {
+            for (const fn of this._dataListeners)
+                fn(this._body);
+        }
+        for (const fn of this._endListeners)
+            fn();
+    }
+    // Called when the WS closes — notifies SSE listeners to detach
+    emitClose() {
+        for (const fn of this._closeListeners)
+            fn();
+    }
+}
+// --- RelayResponse ---
+// Captures writeHead/write/end calls and forwards them as WS frames to the relay.
+class RelayResponse {
+    constructor(requestId, ws) {
+        this.headersSent = false;
+        this.writableEnded = false;
+        this._requestId = requestId;
+        this._ws = ws;
+    }
+    _send(frame) {
+        if (this._ws.readyState === ws_1.default.OPEN) {
+            this._ws.send(JSON.stringify(frame));
+        }
+    }
+    writeHead(statusCode, headers) {
+        if (this.headersSent)
+            return;
+        this.headersSent = true;
+        this._send({ requestId: this._requestId, type: "response_start", statusCode, headers: headers ?? {} });
+    }
+    write(chunk) {
+        if (this.writableEnded)
+            return;
+        this._send({ requestId: this._requestId, type: "data", chunk });
+    }
+    end(chunk) {
+        if (this.writableEnded)
+            return;
+        if (chunk)
+            this.write(chunk);
+        this.writableEnded = true;
+        this._send({ requestId: this._requestId, type: "end" });
+    }
+}
+// --- Token persistence ---
+async function loadOrCreateToken(workspaceCwd) {
+    const tokenPath = (0, server_common_1.relayTokenPath)(workspaceCwd);
+    try {
+        const existing = (await (0, promises_1.readFile)(tokenPath, "utf-8")).trim();
+        if (existing.length >= 16) {
+            return existing;
+        }
+        throw new Error("token too short");
+    }
+    catch {
+        // File missing, unreadable, or invalid — generate a fresh one
+        const token = (0, crypto_1.randomBytes)(32).toString("base64url");
+        try {
+            await (0, promises_1.writeFile)(tokenPath, token, "utf-8");
+        }
+        catch (writeErr) {
+            console.warn(`[relay] could not save token to ${tokenPath}: ${writeErr.message} (token will not persist across restarts)`);
+        }
+        return token;
+    }
+}
+// --- startRelayMode ---
+const BACKOFF_INITIAL_MS = 1000;
+const BACKOFF_MAX_MS = 30000;
+async function startRelayMode(relayUrl, availableAgents, workspaceCwd) {
+    // Normalise: accept http(s):// or ws(s):// — convert to ws(s)://
+    const wsUrl = relayUrl
+        .replace(/^https:\/\//, "wss://")
+        .replace(/^http:\/\//, "ws://");
+    // Load or generate a stable token for this workspace — done once, reused across reconnects
+    const token = await loadOrCreateToken(workspaceCwd);
+    // Track active RelayRequests so we can fire their close listeners on WS disconnect
+    const activeRequests = new Map();
+    let backoff = BACKOFF_INITIAL_MS;
+    let stopping = false;
+    function connect() {
+        if (stopping)
+            return;
+        const ws = new ws_1.default(`${wsUrl}/grass-connect`);
+        ws.on("open", () => {
+            backoff = BACKOFF_INITIAL_MS;
+            const registerFrame = { type: "register", token };
+            ws.send(JSON.stringify(registerFrame));
+            (0, server_common_1.setPushNotificationSender)((title, body, data) => {
+                if (ws.readyState === ws_1.default.OPEN) {
+                    ws.send(JSON.stringify({ type: "push_notification", title, body, data }));
+                }
+            });
+        });
+        ws.on("message", async (raw) => {
+            let frame;
+            try {
+                frame = JSON.parse(raw.toString());
+            }
+            catch {
+                return;
+            }
+            if (frame.type === "registered") {
+                // Registration accepted — show QR for app to scan
+                await (0, server_common_1.showRelayQR)(relayUrl, token);
+                return;
+            }
+            if (frame.type === "register_error") {
+                console.error(`[relay] registration rejected: ${frame.reason}`);
+                stopping = true; // don't reconnect — token conflict won't resolve on its own
+                ws.close();
+                return;
+            }
+            if (frame.type === "request") {
+                const { requestId, method, path, headers, body } = frame;
+                const req = new RelayRequest(method, path, headers, body);
+                const res = new RelayResponse(requestId, ws);
+                activeRequests.set(requestId, req);
+                // Deliver body asynchronously so handler can attach data/end listeners first
+                setImmediate(() => req.emitBody());
+                try {
+                    await (0, server_1.handleRequest)(req, res, availableAgents, workspaceCwd);
+                }
+                catch (err) {
+                    console.error(`[relay] unhandled error for requestId=${requestId}:`, err.message);
+                    if (!res.headersSent)
+                        res.writeHead(500, { "Content-Type": "application/json" });
+                    if (!res.writableEnded)
+                        res.end(JSON.stringify({ error: "Internal server error" }));
+                }
+                finally {
+                    // Only remove from active map once the response is fully ended.
+                    // SSE responses stay active until res.end() is called by the event listener.
+                    if (res.writableEnded) {
+                        activeRequests.delete(requestId);
+                    }
+                }
+                return;
+            }
+        });
+        ws.on("close", (code) => {
+            (0, server_common_1.setPushNotificationSender)(null);
+            // Notify all active SSE listeners so they detach from the session emitter
+            for (const [id, req] of activeRequests) {
+                req.emitClose();
+                activeRequests.delete(id);
+            }
+            if (stopping)
+                return;
+            // Code 4000 means the relay evicted this connection because a newer one
+            // registered with the same token — the new connection is already live, so
+            // do NOT reconnect (that would evict the new connection and loop forever).
+            if (code === 4000)
+                return;
+            setTimeout(() => {
+                connect();
+            }, backoff);
+            backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
+        });
+        ws.on("error", (err) => {
+            console.error(`[relay] ws error: ${err.message}`);
+            // 'close' event fires after 'error', reconnect happens there
+        });
+    }
+    // Handle graceful shutdown — stopping flag prevents reconnect loop
+    process.on("SIGINT", () => {
+        stopping = true;
+    });
+    process.on("SIGTERM", () => {
+        stopping = true;
+    });
+    connect();
+    // Keep process alive — relay mode has no HTTP server to hold the event loop open
+    await new Promise(() => { });
+}

package/dist/relay-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });