@gtc6244/immediacy-daemon 0.1.0

package/dist/src/server.js

@@ -0,0 +1,973 @@
+/**
+ * WSS server + message dispatch.
+ *
+ * Speaks the envelope contract only; knows nothing about Cloudflare
+ * (cloudflared dials this local port). A pluggable Codec decides whether
+ * payloads are cleartext (slices 1–4 / dev) or sealed NaCl boxes (slice 5).
+ */
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, extname, join, normalize, resolve, sep } from "node:path";
+import { WebSocketServer } from "ws";
+import { make, ProtocolError } from "./envelope.js";
+import { addPeer, boxCodec, isValidPublicKeyB64 } from "./crypto.js";
+import { Hub } from "./hub.js";
+import { WorkspaceManager } from "./workspace.js";
+import { PortScanner } from "./ports.js";
+import { ForwardManager } from "./forward.js";
+import { AppConfigStore } from "./config.js";
+import { CredentialsStore } from "./credentials.js";
+import { DaemonIdentity } from "./daemon-identity.js";
+import { originUrl } from "./gitops.js";
+import { AllowlistStore } from "./allowlist.js";
+import { SystemEvents } from "./events.js";
+import { JobStore } from "./jobs/store.js";
+import { JobScheduler } from "./jobs/scheduler.js";
+import { status as githubStatus, listRepos } from "./github.js";
+import { MODELS, DEFAULT_MODEL } from "./models.js";
+import { logger } from "./log.js";
+const startedAt = Date.now();
+/**
+ * Web-client static root. Resolves to the repo-level `webApp/` directory (this
+ * module lives at daemon/src/server.ts, so ../../webApp from here). Overridable
+ * via WEB_ROOT for a packaged build. When the directory is absent, serving is
+ * simply skipped — the daemon still answers `/healthz` and WS upgrades.
+ *
+ * Serving the browser client from the same origin cloudflared dials means the
+ * Cloudflare Access cookie (the browser login) also authorizes the WebSocket —
+ * so the web app needs no service-token header (browsers can't set one on a WS
+ * upgrade). Locally it just makes http://127.0.0.1:8787/ open the UI.
+ */
+const WEB_ROOT = resolve(process.env.WEB_ROOT ?? join(dirname(fileURLToPath(import.meta.url)), "..", "..", "webApp"));
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".webmanifest": "application/manifest+json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".map": "application/json; charset=utf-8",
+};
+/**
+ * Serve a file from {@link WEB_ROOT} for a GET/HEAD request. Returns true if the
+ * request was handled (either a file was streamed or a 404 was sent for a path
+ * under the web root); false if the caller should fall through (e.g. traversal
+ * attempt) so the default 426 upgrade response applies. Path traversal outside
+ * the root is refused.
+ */
+async function serveStatic(reqUrl, method, res) {
+    let pathname;
+    try {
+        pathname = decodeURIComponent(new URL(reqUrl, "http://localhost").pathname);
+    }
+    catch {
+        return false;
+    }
+    if (pathname === "/" || pathname === "")
+        pathname = "/index.html";
+    // Normalize and keep the request inside the web root (defeat ../ traversal).
+    const target = normalize(join(WEB_ROOT, pathname));
+    if (target !== WEB_ROOT && !target.startsWith(WEB_ROOT + sep))
+        return false;
+    try {
+        const st = await stat(target);
+        if (!st.isFile())
+            return false;
+        const type = MIME[extname(target).toLowerCase()] ?? "application/octet-stream";
+        res.writeHead(200, {
+            "content-type": type,
+            "content-length": st.size,
+            "cache-control": "no-cache",
+        });
+        if (method === "HEAD") {
+            res.end();
+            return true;
+        }
+        createReadStream(target).pipe(res);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function startServer(opts) {
+    // E2E on ⇒ require a sealed channel before fanning broadcasts to a socket, so
+    // an un-handshaked device can't be sent cleartext payloads over the tunnel.
+    const hub = new Hub(Boolean(opts.crypto));
+    // Bring the structured log up first: rotate an oversized prior file, then
+    // fan every entry out to any client following the log (the Logs pane).
+    await logger.start();
+    logger.setSink((entry) => hub.broadcastLog("log.event", entry.ws ?? null, { entry }));
+    const events = new SystemEvents();
+    // Provider API keys (app-managed, env-seeded). Loaded before the manager so
+    // the first agent spawn resolves keys from a hydrated store.
+    const credentials = new CredentialsStore();
+    await credentials.load();
+    // Daemon-owned app config (prompts + git behavior). Loaded before the manager
+    // so the first spawn/worktree-create reads a hydrated store.
+    const appConfig = new AppConfigStore();
+    await appConfig.load();
+    // This daemon's stable id + human name (default = machine hostname). A client
+    // connected to several daemons labels each by this; sent as `daemon.info`.
+    const identity = new DaemonIdentity();
+    await identity.load();
+    // Daemon-global "Allow all" list. Loaded before the manager so the first agent
+    // spawn already sees any prior grants (auto-approving matching calls).
+    const allowlist = new AllowlistStore();
+    await allowlist.load();
+    // Default chatlog (2nd arg undefined → its default) + event bus + credentials
+    // + app config + allowlist.
+    const workspaces = new WorkspaceManager(hub, undefined, events, undefined, credentials, appConfig, allowlist);
+    await workspaces.load();
+    // Cron/scheduled jobs. The scheduler drives runs through the WorkspaceManager
+    // (which structurally satisfies its JobRunnerHost) and listens on the same
+    // event bus the manager emits to, so reactive ("N min after X") triggers work.
+    const jobStore = new JobStore();
+    await jobStore.load();
+    const jobs = new JobScheduler(jobStore, workspaces, events, (run) => hub.broadcast("event.job_run", run.ws ?? null, { run }));
+    jobs.start();
+    // Dev-server preview: discover the TCP ports agents open inside their
+    // worktrees and let a client forward one to a local browser. The scanner polls
+    // lsof (worktree-scoped by cwd) and broadcasts the owned set on every change;
+    // the manager bridges each forwarded stream to loopback on this box. Both are
+    // idle until at least one client is attached (started/stopped below).
+    const forwardScanner = new PortScanner(() => workspaces.list().map((r) => ({ ws: r.id, worktreePath: r.worktreePath })), (ports) => hub.broadcast("forward.available", null, { ports }));
+    const forwards = new ForwardManager(hub, (ws, port) => forwardScanner.isOwned(ws, port));
+    let clientCount = 0;
+    // Own the HTTP server explicitly so we can serve a plaintext /healthz probe
+    // on the same port cloudflared dials. launchd (KeepAlive) restarts the daemon
+    // if it exits; /healthz lets the tunnel's ingress and any external monitor see
+    // that the *origin* is actually up — the failure mode in the cloudflared logs
+    // was "connection refused" to this port, not the tunnel itself dropping.
+    const http = createServer((req, res) => {
+        if (req.method === "GET" && req.url === "/healthz") {
+            const info = identity.info();
+            const body = JSON.stringify({
+                status: "ok",
+                daemonId: info.daemonId,
+                name: info.name,
+                hostname: info.hostname,
+                version: info.version,
+                uptimeSeconds: Math.round((Date.now() - startedAt) / 1000),
+                pid: process.pid,
+                workspaces: workspaces.list().length,
+            });
+            res.writeHead(200, {
+                "content-type": "application/json",
+                "cache-control": "no-store",
+            });
+            res.end(body);
+            return;
+        }
+        // Serve the browser client (webApp/) on GET/HEAD from the same origin the
+        // tunnel dials, so the Access cookie authorizes both the page and its WS.
+        if ((req.method === "GET" || req.method === "HEAD") && req.url) {
+            void serveStatic(req.url, req.method, res).then((handled) => {
+                if (handled)
+                    return;
+                // Unknown non-upgrade GET → fall back to the SPA entry so deep links work.
+                void serveStatic("/index.html", req.method, res).then((servedIndex) => {
+                    if (servedIndex)
+                        return;
+                    res.writeHead(426, { "content-type": "text/plain" });
+                    res.end("Upgrade Required\n");
+                });
+            });
+            return;
+        }
+        // Everything else on this port is meant to be a WebSocket upgrade.
+        res.writeHead(426, { "content-type": "text/plain" });
+        res.end("Upgrade Required\n");
+    });
+    const wss = new WebSocketServer({ server: http });
+    wss.on("connection", (socket, req) => {
+        const peer = req.socket.remoteAddress ?? "unknown";
+        logger.info("conn", `client connected from ${peer}`);
+        hub.add(socket);
+        // Announce this daemon's identity so a client connected to several daemons can
+        // label this connection (name defaults to the machine hostname). Only pushed
+        // unsolicited on a CLEARTEXT socket — with E2E on, the socket starts cleartext
+        // and the client flips to sealed-only right after its `hello`, so a cleartext
+        // push would race and be rejected as unsealed. Those clients fetch it instead
+        // via a sealed `daemon.get` after the handshake.
+        if (!opts.crypto)
+            hub.sendTo(socket, "daemon.info", null, identity.info());
+        // First client attaching turns on port discovery; a fresh scan runs now so
+        // this client sees any already-running dev servers without waiting a tick.
+        if (clientCount++ === 0)
+            forwardScanner.start();
+        else
+            void forwardScanner.refresh();
+        // Fallback device identity for clients that don't send a stable deviceId:
+        // isolates this connection's terminal, though it won't survive a reconnect.
+        const connId = randomUUID();
+        socket.on("message", (data) => handleFrame(socket, data.toString(), connId, opts.crypto, hub, workspaces, jobs, credentials, appConfig, identity, forwards, forwardScanner));
+        socket.on("close", (code) => {
+            hub.remove(socket);
+            // Reap the per-connection terminal (keyed by this connection's fallback
+            // connId) so a client that sends no stable deviceId doesn't leak a PTY on
+            // every reconnect. Stable-deviceId terminals are left for reconnect.
+            workspaces.reapDevice(connId);
+            // Drop every forwarded stream this socket owned, and stop scanning once the
+            // last client leaves (lsof polling is pointless with nobody to notify).
+            forwards.reapClient(socket);
+            if (--clientCount <= 0) {
+                clientCount = 0;
+                forwardScanner.stop();
+            }
+            logger.info("conn", `client ${peer} disconnected`, { data: { closeCode: code } });
+        });
+        socket.on("error", (err) => logger.error("conn", "socket error", {
+            data: { peer, message: err instanceof Error ? err.message : String(err) },
+        }));
+    });
+    http.listen(opts.port, opts.host, () => logger.info("system", `listening on ws://${opts.host}:${opts.port} (health: http://${opts.host}:${opts.port}/healthz)`));
+    return { http, wss, hub, workspaces, jobs };
+}
+async function projects(workspaces) {
+    return Promise.all(workspaces.listProjects().map(async (p) => {
+        // Origin URL lets a multi-daemon client match this project to the "same"
+        // project on another daemon (same remote) when moving a workspace.
+        const origin = await originUrl(p.repo);
+        return {
+            id: p.id,
+            name: p.name,
+            repo: p.repo,
+            ...(p.github ? { github: p.github } : {}),
+            ...(origin ? { originUrl: origin } : {}),
+        };
+    }));
+}
+const WORKSPACE_ACTION_KINDS = [
+    "code_review",
+    "create_pr",
+    "fix_errors",
+    "resolve_merge_conflicts",
+    "rename_branch",
+];
+function isWorkspaceActionKind(k) {
+    return typeof k === "string" && WORKSPACE_ACTION_KINDS.includes(k);
+}
+/** At most this many attachments per prompt, and this many base64 chars each. */
+const MAX_ATTACHMENTS = 6;
+const MAX_ATTACHMENT_B64 = 12 * 1024 * 1024; // ~9 MB of raw bytes per file
+/**
+ * Validate + bound the `attachments` a client sent with a prompt. Anything that
+ * isn't a well-formed {name, mediaType, data} triple is dropped; oversized files
+ * and excess count are trimmed so a malformed or hostile frame can't wedge the
+ * single multiplexed connection. Returns undefined when nothing valid remains.
+ */
+function sanitizeAttachments(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const out = [];
+    for (const item of raw) {
+        if (out.length >= MAX_ATTACHMENTS)
+            break;
+        if (!item || typeof item !== "object")
+            continue;
+        const a = item;
+        if (typeof a.name !== "string" ||
+            typeof a.mediaType !== "string" ||
+            typeof a.data !== "string" ||
+            a.data.length === 0 ||
+            a.data.length > MAX_ATTACHMENT_B64) {
+            continue;
+        }
+        out.push({ name: a.name, mediaType: a.mediaType, data: a.data });
+    }
+    return out.length > 0 ? out : undefined;
+}
+async function handleFrame(socket, raw, connId, crypto, hub, workspaces, jobs, credentials, appConfig, identity, forwards, forwardScanner) {
+    let env;
+    try {
+        // Decode with this socket's own codec — cleartext until it has completed the
+        // `hello` handshake, then the NaCl box sealed to that device's key.
+        env = hub.codecFor(socket).decode(raw);
+    }
+    catch (err) {
+        const pe = err instanceof ProtocolError ? err : null;
+        logger.warn("conn", "frame decode failed", {
+            data: { code: pe?.code ?? "decode_error" },
+        });
+        hub.send(socket, make("error", null, {
+            code: pe?.code ?? "decode_error",
+            message: pe?.message ?? "could not decode frame",
+        }));
+        return;
+    }
+    // DEBUG_WIRE=1 logs every inbound frame type — handy when bringing up a new
+    // client against the protocol.
+    if (process.env.DEBUG_WIRE)
+        console.log(`[wire] <- ${env.type}`);
+    const reply = (env2) => hub.send(socket, env2);
+    try {
+        switch (env.type) {
+            case "hello": {
+                // Multi-device pairing handshake. The client announces its public key
+                // (cleartext, but already inside the Access-authenticated tunnel — the
+                // Access token IS the pairing secret, so this is trust-on-first-use).
+                // We bind THIS socket to a box sealed to that key; other devices keep
+                // their own keys and codecs, so no device clobbers another.
+                const p = env.payload;
+                if (!crypto) {
+                    // E2E off: acknowledge but stay cleartext.
+                    reply(make("hello.ok", null, { pub: "", sealed: false }));
+                    return;
+                }
+                if (typeof p.pub !== "string" || !isValidPublicKeyB64(p.pub)) {
+                    reply(make("error", null, { code: "bad_pubkey", message: "hello.pub is not a valid public key" }));
+                    return;
+                }
+                const label = typeof p.label === "string" ? p.label : undefined;
+                // Switch this socket to a sealed codec SYNCHRONOUSLY — before any await —
+                // so a sealed frame the client sends right after hello can't race in and
+                // get decoded with the stale cleartext codec. Persistence is best-effort
+                // and runs after (its own writes are serialized in addPeer).
+                hub.setCodec(socket, boxCodec(crypto.self, Buffer.from(p.pub, "base64")));
+                // Sealed from here on: the client enabled its box right after sending
+                // hello, so it can open this reply.
+                reply(make("hello.ok", null, { pub: crypto.self.publicKey.toString("base64"), sealed: true }));
+                void addPeer(p.pub, label).catch((err) => logger.error("conn", "failed to persist peer", {
+                    data: { message: err instanceof Error ? err.message : String(err) },
+                }));
+                // Never log the device public key — only that a labelled device paired.
+                logger.info("conn", "paired device", { data: { label: label ?? "no label" } });
+                return;
+            }
+            case "pair.info":
+                reply(make("pair.info.result", null, { pub: crypto?.self.publicKey.toString("base64") ?? "" }));
+                return;
+            case "daemon.get":
+                reply(make("daemon.info", null, identity.info()));
+                return;
+            case "daemon.rename": {
+                const p = env.payload;
+                if (typeof p.name !== "string" || !p.name.trim()) {
+                    reply(make("error", null, { code: "bad_args", message: "daemon name is empty" }));
+                    return;
+                }
+                await identity.rename(p.name);
+                // Broadcast the new identity so every connected client converges.
+                hub.broadcast("daemon.info", null, identity.info());
+                return;
+            }
+            case "ping":
+                reply(make("pong", env.ws, {}));
+                return;
+            case "echo": {
+                const p = env.payload;
+                reply(make("echo.result", env.ws, { text: typeof p.text === "string" ? p.text : "" }));
+                return;
+            }
+            case "project.list":
+                reply(make("project.list.result", null, { projects: await projects(workspaces) }));
+                return;
+            case "project.create": {
+                const p = env.payload;
+                if (!p.blank && !p.repo && !p.github?.fullName) {
+                    reply(make("error", null, { code: "bad_args", message: "blank, repo, or github is required" }));
+                    return;
+                }
+                await workspaces.createProject({ blank: p.blank, repo: p.repo, github: p.github, name: p.name });
+                hub.broadcast("project.list.result", null, { projects: await projects(workspaces) });
+                return;
+            }
+            case "project.delete": {
+                const p = env.payload;
+                if (!p.id) {
+                    reply(make("error", null, { code: "bad_args", message: "id is required" }));
+                    return;
+                }
+                await workspaces.deleteProject(p.id);
+                hub.broadcast("project.list.result", null, { projects: await projects(workspaces) });
+                return;
+            }
+            case "project.reorder": {
+                const p = env.payload;
+                const ids = Array.isArray(p.ids)
+                    ? p.ids.filter((x) => typeof x === "string")
+                    : [];
+                if (ids.length === 0) {
+                    reply(make("error", null, { code: "bad_args", message: "ids is required" }));
+                    return;
+                }
+                await workspaces.reorderProjects(ids);
+                hub.broadcast("project.list.result", null, { projects: await projects(workspaces) });
+                return;
+            }
+            case "project.branches": {
+                const p = env.payload;
+                if (!p.projectId) {
+                    reply(make("error", null, { code: "bad_args", message: "projectId is required" }));
+                    return;
+                }
+                try {
+                    const { branches, defaultBranch } = await workspaces.listBranches(p.projectId);
+                    reply(make("project.branches.result", null, { projectId: p.projectId, branches, defaultBranch }));
+                }
+                catch (err) {
+                    reply(make("error", null, {
+                        code: "branches_error",
+                        message: err instanceof Error ? err.message : "listing branches failed",
+                    }));
+                }
+                return;
+            }
+            case "project.pulls": {
+                const p = env.payload;
+                if (!p.projectId) {
+                    reply(make("error", null, { code: "bad_args", message: "projectId is required" }));
+                    return;
+                }
+                try {
+                    const pulls = await workspaces.listPullRequests(p.projectId);
+                    reply(make("project.pulls.result", null, { projectId: p.projectId, pulls }));
+                }
+                catch (err) {
+                    reply(make("error", null, {
+                        code: "pulls_error",
+                        message: err instanceof Error ? err.message : "listing pull requests failed",
+                    }));
+                }
+                return;
+            }
+            case "project.issues": {
+                const p = env.payload;
+                if (!p.projectId) {
+                    reply(make("error", null, { code: "bad_args", message: "projectId is required" }));
+                    return;
+                }
+                try {
+                    const issues = await workspaces.listIssues(p.projectId);
+                    reply(make("project.issues.result", null, { projectId: p.projectId, issues }));
+                }
+                catch (err) {
+                    reply(make("error", null, {
+                        code: "issues_error",
+                        message: err instanceof Error ? err.message : "listing issues failed",
+                    }));
+                }
+                return;
+            }
+            case "workspace.list":
+                // Reply immediately from local git state so the sidebar paints fast,
+                // then — since every app sends this on connect — fetch fresh remote refs
+                // for each base repo and re-broadcast if the freshened base moved any
+                // diff-stat. Without this the list path never fetched, so a base that
+                // advanced on origin while the app was closed stayed stale until the
+                // user happened to open a workspace (and Flutter fetched nothing at all).
+                reply(make("workspace.list.result", null, { workspaces: await workspaces.summaries() }));
+                void workspaces.syncAllReposAndRefresh();
+                return;
+            case "models.list":
+                reply(make("models.list.result", null, {
+                    models: MODELS,
+                    defaultModel: DEFAULT_MODEL.id,
+                }));
+                return;
+            case "workspace.create": {
+                const p = env.payload;
+                // A chat is repo-less: no project/repo/github required — the daemon
+                // spins up a private scratch dir instead of a worktree.
+                if (p.kind === "chat") {
+                    await workspaces.createChat({ model: p.model });
+                    await workspaces.broadcastWorkspaceList();
+                    return;
+                }
+                if (!p.projectId && !p.repo && !p.github?.fullName) {
+                    reply(make("error", null, { code: "bad_args", message: "projectId, repo, or github is required" }));
+                    return;
+                }
+                await workspaces.create({
+                    projectId: p.projectId,
+                    repo: p.repo,
+                    github: p.github,
+                    name: p.name,
+                    branchBase: p.branchBase,
+                    sourceBranch: p.sourceBranch,
+                    sourcePr: p.sourcePr,
+                    initialPrompt: p.initialPrompt,
+                    model: p.model,
+                });
+                // Broadcast fresh lists so every client converges. Projects too: the
+                // legacy bare-repo path may have just registered a new one.
+                hub.broadcast("project.list.result", null, { projects: await projects(workspaces) });
+                await workspaces.broadcastWorkspaceList();
+                return;
+            }
+            case "github.status": {
+                reply(make("github.status.result", null, await githubStatus()));
+                return;
+            }
+            case "github.repos": {
+                const p = env.payload;
+                try {
+                    const repos = await listRepos(p.limit ?? 100);
+                    reply(make("github.repos.result", null, { repos }));
+                }
+                catch (err) {
+                    reply(make("error", null, {
+                        code: "github_error",
+                        message: err instanceof Error ? err.message : "listing repos failed",
+                    }));
+                }
+                return;
+            }
+            case "workspace.delete": {
+                const p = env.payload;
+                if (p.ws)
+                    await workspaces.delete(p.ws);
+                await workspaces.broadcastWorkspaceList();
+                return;
+            }
+            case "workspace.archive": {
+                const p = env.payload;
+                if (p.ws)
+                    await workspaces.archive(p.ws);
+                await workspaces.broadcastWorkspaceList();
+                return;
+            }
+            case "workspace.action": {
+                const p = env.payload;
+                if (!p.ws || !isWorkspaceActionKind(p.kind)) {
+                    reply(make("error", p.ws ?? null, { code: "bad_args", message: "unknown workspace action" }));
+                    return;
+                }
+                // Seeds the workspace's agent; its events stream over the normal chat
+                // flow, so no dedicated result frame is needed here.
+                workspaces.runAction(p.ws, p.kind);
+                return;
+            }
+            case "delete.batch": {
+                const p = env.payload;
+                // Keep only string ids, and cap how much one frame can drive: the fold
+                // + sequential git work is synchronous on the event loop, so an
+                // authenticated client shouldn't be able to wedge the daemon with a
+                // giant id blob (mirrors the settings.set length guard).
+                const asIds = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+                const wsIds = asIds(p.workspaces);
+                const projIds = asIds(p.projects);
+                if (wsIds.length + projIds.length > 1000) {
+                    reply(make("error", null, { code: "bad_args", message: "delete.batch accepts at most 1000 ids" }));
+                    return;
+                }
+                const result = await workspaces.deleteBatch({ workspaces: wsIds, projects: projIds });
+                // Refresh both catalogs once (either may have shrunk), then tell the
+                // requester exactly what landed and what refused.
+                hub.broadcast("project.list.result", null, { projects: await projects(workspaces) });
+                await workspaces.broadcastWorkspaceList();
+                reply(make("delete.batch.result", null, result));
+                return;
+            }
+            case "prompt.send": {
+                const p = env.payload;
+                if (p.ws && typeof p.text === "string") {
+                    workspaces.prompt(p.ws, p.text, sanitizeAttachments(p.attachments));
+                }
+                return;
+            }
+            case "agent.stop": {
+                const p = env.payload;
+                if (p.ws)
+                    await workspaces.stopAgent(p.ws);
+                return;
+            }
+            case "permission.respond": {
+                const p = env.payload;
+                if (p.ws &&
+                    p.requestId &&
+                    (p.decision === "allow" || p.decision === "deny" || p.decision === "allow_all")) {
+                    workspaces.respondPermission(p.ws, p.requestId, p.decision);
+                    // A grant may have changed the allowlist — fan the fresh list out so
+                    // every client's admin view converges (no-op for allow/deny).
+                    if (p.decision === "allow_all") {
+                        hub.broadcast("allowlist.result", null, {
+                            entries: workspaces.allowlistStore().list(),
+                        });
+                    }
+                }
+                return;
+            }
+            case "question.respond": {
+                const p = env.payload;
+                // Require actual answer content: an empty `{}` answers object is truthy
+                // but carries nothing, so it must not mark the question as answered.
+                const hasAnswers = p.answers != null && Object.keys(p.answers).length > 0;
+                const hasResponse = typeof p.response === "string" && p.response.trim() !== "";
+                if (p.ws && p.requestId && (hasAnswers || hasResponse)) {
+                    workspaces.answerQuestion(p.ws, p.requestId, p.answers ?? {}, p.response);
+                }
+                return;
+            }
+            case "allowlist.list": {
+                reply(make("allowlist.result", null, { entries: workspaces.allowlistStore().list() }));
+                return;
+            }
+            case "allowlist.revoke": {
+                const p = env.payload;
+                if (p.key) {
+                    await workspaces.allowlistStore().revoke(p.key);
+                    hub.broadcast("allowlist.result", null, {
+                        entries: workspaces.allowlistStore().list(),
+                    });
+                }
+                return;
+            }
+            case "allowlist.clear": {
+                await workspaces.allowlistStore().clear();
+                hub.broadcast("allowlist.result", null, {
+                    entries: workspaces.allowlistStore().list(),
+                });
+                return;
+            }
+            case "terminal.input": {
+                const p = env.payload;
+                if (p.ws && typeof p.data === "string") {
+                    workspaces.terminalInput(p.ws, p.deviceId || connId, p.data, socket);
+                }
+                return;
+            }
+            case "terminal.resize": {
+                const p = env.payload;
+                if (p.ws && typeof p.cols === "number" && typeof p.rows === "number") {
+                    workspaces.terminalResize(p.ws, p.deviceId || connId, Math.floor(p.cols), Math.floor(p.rows), socket);
+                }
+                return;
+            }
+            case "terminal.snapshot": {
+                const p = env.payload;
+                if (!p.ws)
+                    return;
+                const data = workspaces.terminalSnapshot(p.ws, p.deviceId || connId, socket);
+                if (data === null) {
+                    reply(make("error", p.ws, { code: "no_such_ws", message: "unknown workspace", ws: p.ws }));
+                    return;
+                }
+                reply(make("terminal.snapshot.result", p.ws, { ws: p.ws, data }));
+                return;
+            }
+            case "forward.list": {
+                // Point-to-point: answer just the requester with the current owned set.
+                reply(make("forward.available", null, { ports: forwardScanner.current }));
+                return;
+            }
+            case "forward.open": {
+                const p = env.payload;
+                if (p.ws && typeof p.streamId === "string" && typeof p.port === "number") {
+                    forwards.open(socket, p.ws, p.streamId, Math.floor(p.port));
+                }
+                return;
+            }
+            case "forward.data": {
+                const p = env.payload;
+                if (typeof p.streamId === "string" && typeof p.data === "string") {
+                    forwards.data(p.streamId, p.data);
+                }
+                return;
+            }
+            case "forward.close": {
+                const p = env.payload;
+                if (typeof p.streamId === "string")
+                    forwards.close(p.streamId);
+                return;
+            }
+            case "git.status": {
+                const p = env.payload;
+                if (!p.ws)
+                    return;
+                // `sync` (deliberate open/refresh) forces a fetch past the per-repo
+                // throttle; a plain poll omits it and stays throttled.
+                const result = await workspaces.gitStatus(p.ws, p.sync === true);
+                if (!result) {
+                    // Unknown ws, or the workspace was just auto-archived on merge — push
+                    // the fresh list so every client drops it, then report it gone.
+                    await workspaces.broadcastWorkspaceList();
+                    reply(make("error", p.ws, { code: "no_such_ws", message: "unknown workspace", ws: p.ws }));
+                    return;
+                }
+                reply(make("git.status.result", p.ws, result));
+                return;
+            }
+            case "git.commit": {
+                const p = env.payload;
+                if (!p.ws || typeof p.message !== "string")
+                    return;
+                const result = await workspaces.gitCommit(p.ws, p.message);
+                if (result)
+                    reply(make("git.result", p.ws, result));
+                return;
+            }
+            case "git.push": {
+                const p = env.payload;
+                if (!p.ws)
+                    return;
+                const result = await workspaces.gitPush(p.ws);
+                if (result)
+                    reply(make("git.result", p.ws, result));
+                return;
+            }
+            case "git.resolve": {
+                const p = env.payload;
+                if (!p.ws)
+                    return;
+                const result = await workspaces.gitResolve(p.ws);
+                if (result)
+                    reply(make("git.result", p.ws, result));
+                return;
+            }
+            case "git.merge": {
+                const p = env.payload;
+                if (!p.ws)
+                    return;
+                if (p.action !== "ours" && p.action !== "theirs" && p.action !== "commit" && p.action !== "abort")
+                    return;
+                const paths = Array.isArray(p.paths) ? p.paths.filter((x) => typeof x === "string") : undefined;
+                const result = await workspaces.gitMerge(p.ws, p.action, paths);
+                if (result)
+                    reply(make("git.result", p.ws, result));
+                return;
+            }
+            case "pr.create": {
+                const p = env.payload;
+                if (!p.ws || typeof p.title !== "string")
+                    return;
+                const result = await workspaces.prCreate(p.ws, p.title, p.body);
+                if (result)
+                    reply(make("git.result", p.ws, result));
+                return;
+            }
+            case "pr.merge": {
+                const p = env.payload;
+                if (!p.ws)
+                    return;
+                const result = await workspaces.prMerge(p.ws);
+                if (result)
+                    reply(make("git.result", p.ws, result));
+                return;
+            }
+            case "issue.create": {
+                const p = env.payload;
+                if (!p.ws || typeof p.title !== "string")
+                    return;
+                const result = await workspaces.issueCreate(p.ws, p.title, p.body);
+                if (result)
+                    reply(make("git.result", p.ws, result));
+                return;
+            }
+            case "workspace.open": {
+                const p = env.payload;
+                const target = p.target;
+                if (p.ws && (target === "finder" || target === "terminal" || target === "editor")) {
+                    await workspaces.open(p.ws, target);
+                }
+                return;
+            }
+            case "diff.get": {
+                const p = env.payload;
+                if (!p.ws)
+                    return;
+                const files = (await workspaces.diff(p.ws)) ?? [];
+                reply(make("diff.result", p.ws, { ws: p.ws, files }));
+                return;
+            }
+            case "tree.get": {
+                const p = env.payload;
+                if (!p.ws)
+                    return;
+                const files = (await workspaces.tree(p.ws)) ?? [];
+                reply(make("tree.result", p.ws, { ws: p.ws, files }));
+                return;
+            }
+            case "chat.history": {
+                const p = env.payload;
+                if (!p.ws)
+                    return;
+                reply(make("chat.history.result", p.ws, { ws: p.ws, entries: workspaces.history(p.ws) }));
+                return;
+            }
+            case "file.get": {
+                const p = env.payload;
+                if (!p.ws || typeof p.path !== "string")
+                    return;
+                const file = await workspaces.readFile(p.ws, p.path);
+                if (!file) {
+                    reply(make("error", p.ws, { code: "no_such_ws", message: "unknown workspace", ws: p.ws }));
+                    return;
+                }
+                reply(make("file.result", p.ws, { ws: p.ws, ...file }));
+                return;
+            }
+            case "file.set": {
+                const p = env.payload;
+                if (!p.ws || typeof p.path !== "string" || typeof p.content !== "string")
+                    return;
+                try {
+                    const bytes = await workspaces.writeFile(p.ws, p.path, p.content);
+                    if (bytes === null) {
+                        reply(make("error", p.ws, { code: "no_such_ws", message: "unknown workspace", ws: p.ws }));
+                        return;
+                    }
+                    reply(make("file.saved", p.ws, { ws: p.ws, path: p.path, bytes }));
+                }
+                catch (err) {
+                    reply(make("error", p.ws, {
+                        code: "file_write_failed",
+                        message: err instanceof Error ? err.message : "file.set failed",
+                        ws: p.ws,
+                    }));
+                }
+                return;
+            }
+            case "job.list": {
+                reply(make("job.list.result", null, { jobs: jobs.list() }));
+                return;
+            }
+            case "job.create": {
+                const p = env.payload;
+                if (!p.job) {
+                    reply(make("error", null, { code: "bad_args", message: "job is required" }));
+                    return;
+                }
+                try {
+                    await jobs.create(p.job);
+                    hub.broadcast("job.list.result", null, { jobs: jobs.list() });
+                }
+                catch (err) {
+                    reply(make("error", null, {
+                        code: "job_error",
+                        message: err instanceof Error ? err.message : "job.create failed",
+                    }));
+                }
+                return;
+            }
+            case "job.update": {
+                const p = env.payload;
+                if (!p.id || !p.patch) {
+                    reply(make("error", null, { code: "bad_args", message: "id and patch are required" }));
+                    return;
+                }
+                try {
+                    await jobs.update(p.id, p.patch);
+                    hub.broadcast("job.list.result", null, { jobs: jobs.list() });
+                }
+                catch (err) {
+                    reply(make("error", null, {
+                        code: "job_error",
+                        message: err instanceof Error ? err.message : "job.update failed",
+                    }));
+                }
+                return;
+            }
+            case "job.delete": {
+                const p = env.payload;
+                if (!p.id) {
+                    reply(make("error", null, { code: "bad_args", message: "id is required" }));
+                    return;
+                }
+                await jobs.delete(p.id);
+                hub.broadcast("job.list.result", null, { jobs: jobs.list() });
+                return;
+            }
+            case "job.run": {
+                const p = env.payload;
+                if (!p.id)
+                    return;
+                try {
+                    await jobs.runNow(p.id);
+                }
+                catch (err) {
+                    reply(make("error", null, {
+                        code: "job_error",
+                        message: err instanceof Error ? err.message : "job.run failed",
+                    }));
+                }
+                return;
+            }
+            case "job.runs": {
+                const p = env.payload;
+                reply(make("job.runs.result", null, { runs: jobs.runsFor(p.jobId, p.limit) }));
+                return;
+            }
+            case "settings.get":
+                // Credential presence (never the raw keys — status() masks them) plus
+                // the daemon-owned app config; both ride this one convergence event.
+                reply(make("settings.result", null, {
+                    credentials: credentials.status(),
+                    config: appConfig.get(),
+                }));
+                return;
+            case "settings.set": {
+                const p = env.payload;
+                if (!CredentialsStore.isProvider(p.provider)) {
+                    reply(make("error", null, { code: "bad_args", message: "unknown credential provider" }));
+                    return;
+                }
+                const apiKey = typeof p.apiKey === "string" ? p.apiKey : "";
+                // No real provider key approaches this; the cap just stops a malicious
+                // client persisting a multi-MB blob to disk. Never log the value.
+                if (apiKey.length > 1024) {
+                    reply(make("error", null, { code: "bad_args", message: "apiKey too long" }));
+                    return;
+                }
+                // Empty string clears the key (→ SSO/none).
+                await credentials.setKey(p.provider, apiKey);
+                // Broadcast the fresh status so every client's indicator converges.
+                hub.broadcast("settings.result", null, {
+                    credentials: credentials.status(),
+                    config: appConfig.get(),
+                });
+                return;
+            }
+            case "config.set": {
+                // Full-object replacement (last-write-wins). The store sanitizes/clamps
+                // every field, so an untrusted or partial payload can't corrupt state.
+                const p = env.payload;
+                await appConfig.set(p.config);
+                // Broadcast the fresh, sanitized config (alongside credential status) so
+                // every client converges on what the daemon actually stored.
+                hub.broadcast("settings.result", null, {
+                    credentials: credentials.status(),
+                    config: appConfig.get(),
+                });
+                return;
+            }
+            case "log.tail": {
+                const p = env.payload;
+                // Snapshot from the ring, then follow live entries on this socket.
+                reply(make("log.tail.result", null, { entries: logger.tail(p.limit, p.sinceSeq) }));
+                hub.subscribeLog(socket);
+                return;
+            }
+            default:
+                reply(make("error", env.ws, {
+                    code: "not_implemented",
+                    message: `type "${env.type}" is not handled`,
+                }));
+                return;
+        }
+    }
+    catch (err) {
+        logger.error("error", `handler failed for "${env.type}"`, {
+            ws: env.ws ?? undefined,
+            data: { message: err instanceof Error ? err.message : String(err) },
+        });
+        reply(make("error", env.ws, {
+            code: "handler_error",
+            message: err instanceof Error ? err.message : String(err),
+            ws: env.ws ?? undefined,
+        }));
+    }
+}
+//# sourceMappingURL=server.js.map