tmux-ide 2.1.5 → 2.6.1

package/packages/daemon/dist/command-center/server.js

@@ -0,0 +1,1103 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, dirname, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { cors } from "hono/cors";
+import { discoverSessions, buildOverviews, buildProjectDetail, } from "./discovery.js";
+import { listSessionPanes, sendCommand, sendEnterToPane, sendLiteralToPane, sendText, getPaneBusyStatus, } from "../widgets/lib/pane-comms.js";
+import { resolvePane } from "../send.js";
+import { getSessionState, killSession, stopSessionMonitor } from "@tmux-ide/tmux-bridge";
+import { readConfig, writeConfig } from "../lib/yaml-io.js";
+import { IdeConfigSchema } from "../schemas/ide-config.js";
+import { getLogBuffer, subscribeLogs } from "../lib/log.js";
+import { zValidator } from "@hono/zod-validator";
+import { getDefaultWorkspaceRegistry, WorkspaceAlreadyExistsError, WorkspaceNotFoundError, } from "../lib/workspace-registry.js";
+import { AddWorkspaceRequestSchemaZ } from "@tmux-ide/contracts";
+import { sendCommandSchema } from "./schemas.js";
+import { createScriptTerminalId, terminalCreateRequestSchema, terminalRenameRequestSchema, } from "@tmux-ide/contracts";
+import { deleteTerminal as deleteTerminalRecord, loadTerminals, renameTerminal as renameTerminalRecord, upsertTerminal as upsertTerminalRecord, } from "../lib/terminals-store.js";
+import { defaultPtyBridgeRegistry } from "../server/ws-route.js";
+import { broadcastTerminalsChanged } from "./ws-events.js";
+import { AuthService } from "../lib/auth/auth-service.js";
+import { authMiddleware } from "../lib/auth/middleware.js";
+import { handleWsEventsConnection, broadcastInitOutput, broadcastInitError } from "./ws-events.js";
+import { createActionDispatcher } from "./actions/dispatcher.js";
+import { listProjects, getProject, registerProject, unregisterProject, refreshProject, ProjectAlreadyRegisteredError, ProjectDirNotFoundError, ProjectNotFoundError, } from "../lib/project-registry.js";
+import { runInit, ProjectInitFailedError, ProjectInitTimeoutError, } from "../lib/project-init-runner.js";
+import { RegisterProjectRequestSchemaZ, InitProjectRequestSchemaZ, } from "../schemas/registry.js";
+import { OnboardProjectRequestSchemaZ } from "../schemas/inspect.js";
+import { SandboxViolationError, assertInsideSandbox } from "../lib/filesystem-browser.js";
+import { inspectProject, InspectDirNotFoundError } from "../lib/project-inspect.js";
+import { composeIdeYmlConfig, assertNoExistingIdeYml, OnboardConflictError, OnboardInvalidInputError, } from "../lib/project-onboard.js";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve as pathResolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { WebSocketServer } from "ws";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Resolve our package.json's version. The lookup needs to handle BOTH
+// dev (this file lives at src/command-center/, so the workspace root
+// is two levels up) AND the packaged Electron bundle (this file is
+// flattened into app.asar/dist-electron/, so the bundled package.json
+// is ONE level up; two levels up escapes the asar). Try the candidates
+// in order; fall back to a sentinel if neither is readable.
+function resolvePackageVersion() {
+    const candidates = [join(__dirname, "../../package.json"), join(__dirname, "../package.json")];
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse(readFileSync(candidate, "utf-8"));
+            if (typeof parsed.version === "string")
+                return parsed.version;
+        }
+        catch {
+            /* try the next candidate */
+        }
+    }
+    return "0.0.0";
+}
+const pkgVersion = resolvePackageVersion();
+let projectStreamConnections = 0;
+function bearerToken(authHeader) {
+    if (!authHeader?.startsWith("Bearer "))
+        return null;
+    return authHeader.slice("Bearer ".length);
+}
+function requireAuth(token, localBypassToken) {
+    return async (c, next) => {
+        if (!token)
+            return next();
+        const url = new URL(c.req.url);
+        const suppliedToken = bearerToken(c.req.header("Authorization")) ?? url.searchParams.get("token");
+        if (suppliedToken === token || (localBypassToken && suppliedToken === localBypassToken)) {
+            return next();
+        }
+        return c.json({ error: "Remote access token required" }, 401);
+    };
+}
+function remoteAccessAuth(options) {
+    const bindHostname = options.remoteAccess?.bindHostname ?? "127.0.0.1";
+    return {
+        token: bindHostname === "127.0.0.1" ? null : (options.remoteAccess?.token ?? null),
+        localBypassToken: options.remoteAccess?.localBypassToken ?? null,
+    };
+}
+const sseMetrics = {
+    connections: 0,
+    messagesSent: 0,
+};
+export function getSseMetrics() {
+    return { ...sseMetrics };
+}
+/**
+ * Resolve a BottomPanel Output-tab channel id to a `LogEntry` predicate.
+ * Channels are simple component-prefix filters over the single in-process
+ * structured logger. Returns `null` for unknown channels (handler emits
+ * 404). Add new channels here when adding new log components.
+ */
+function matchLogChannel(channel) {
+    switch (channel) {
+        case "daemon":
+            return () => true;
+        case "hq":
+            return (entry) => entry.component.startsWith("hq") || entry.component.startsWith("remote");
+        case "watchdog":
+            return (entry) => entry.component.startsWith("watchdog");
+        default:
+            return null;
+    }
+}
+function freezePayload(payload) {
+    if (payload && typeof payload === "object") {
+        for (const value of Object.values(payload)) {
+            freezePayload(value);
+        }
+        Object.freeze(payload);
+    }
+    return payload;
+}
+function buildProjectStreamSnapshot(session) {
+    return {
+        project: buildProjectDetail(session),
+    };
+}
+function sandboxResolveDir(rawDir) {
+    const trimmed = rawDir.trim();
+    if (!trimmed)
+        return { error: "invalid-path", message: "Path must not be empty", status: 400 };
+    if (trimmed.includes("\0")) {
+        return { error: "invalid-path", message: "Path contains a null byte", status: 400 };
+    }
+    const home = process.env.TMUX_IDE_HOME_OVERRIDE && process.env.TMUX_IDE_HOME_OVERRIDE.trim().length > 0
+        ? process.env.TMUX_IDE_HOME_OVERRIDE
+        : homedir();
+    let candidate = trimmed;
+    if (candidate === "~") {
+        candidate = home;
+    }
+    else if (candidate.startsWith("~/")) {
+        candidate = `${home.replace(/\/+$/, "")}/${candidate.slice(2)}`;
+    }
+    if (!isAbsolute(candidate)) {
+        return { error: "invalid-path", message: "Path must be absolute", status: 400 };
+    }
+    const resolved = pathResolve(candidate);
+    let canonical;
+    try {
+        canonical = realpathSync(resolved);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR") {
+            return {
+                error: "not-found",
+                message: `Path "${resolved}" does not exist`,
+                status: 404,
+            };
+        }
+        throw err;
+    }
+    try {
+        assertInsideSandbox(canonical, home);
+    }
+    catch (err) {
+        if (err instanceof SandboxViolationError) {
+            return { error: "outside-sandbox", message: err.message, status: 403 };
+        }
+        throw err;
+    }
+    return { canonical };
+}
+export function createApp(options = {}) {
+    const authConfig = options.authConfig ?? { method: "none", token_expiry: 86400 };
+    const authService = options.authService ?? new AuthService();
+    const app = new Hono();
+    // Allow cross-origin (Next.js dashboard, Tailscale, etc.)
+    app.use("/*", cors());
+    // Remote access bearer gate. Local Electron access uses a per-daemon
+    // bypass token from preload; loopback IPs are not implicitly trusted.
+    const remoteAuth = remoteAccessAuth(options);
+    app.use("/api/*", requireAuth(remoteAuth.token, remoteAuth.localBypassToken));
+    // Auth middleware — passes through when method is "none"
+    app.use("/*", authMiddleware(authService, authConfig));
+    // Global error handler
+    app.onError((err, c) => {
+        console.error("[command-center]", err.message);
+        return c.json({ error: err.message }, 500);
+    });
+    // --- Auth routes (always available, bypassed by middleware) ---
+    app.post("/api/auth/challenge", async (c) => {
+        const body = await c.req.json();
+        const userId = body.userId ?? authService.getCurrentUser();
+        const challenge = authService.createChallenge(userId);
+        return c.json(challenge);
+    });
+    app.post("/api/auth/verify", async (c) => {
+        const body = await c.req.json();
+        const result = await authService.authenticateWithSSHKey({
+            publicKey: body.publicKey,
+            signature: body.signature,
+            challengeId: body.challengeId,
+        });
+        if (!result.success) {
+            return c.json({ error: result.error }, 401);
+        }
+        return c.json({ token: result.token, userId: result.userId });
+    });
+    app.post("/api/auth/token", async (c) => {
+        if (authConfig.method !== "none") {
+            return c.json({ error: "Direct token generation requires auth method 'none'" }, 403);
+        }
+        const body = await c.req.json();
+        const userId = body.userId ?? authService.getCurrentUser();
+        const token = authService.generateToken(userId);
+        return c.json({ token, userId });
+    });
+    // --- v2 action dispatcher (single typed entry-point for state-changing
+    //     project / terminal operations — see src/command-center/actions/) ---
+    app.post("/api/v2/action/:name", createActionDispatcher());
+    app.get("/api/widget/:name/spawn", async (c) => {
+        const { resolveWidgetSpawn, WIDGET_TYPES } = await import("../widgets/resolve.js");
+        const name = c.req.param("name");
+        if (!WIDGET_TYPES.includes(name)) {
+            return c.json({ error: `unknown widget: ${name}`, available: WIDGET_TYPES }, 404);
+        }
+        const session = c.req.query("session");
+        const dir = c.req.query("dir");
+        if (!session || !dir) {
+            return c.json({ error: "session and dir query params are required" }, 400);
+        }
+        const target = c.req.query("target") ?? null;
+        const themeRaw = c.req.query("theme");
+        let theme = null;
+        if (themeRaw) {
+            try {
+                theme = JSON.parse(themeRaw);
+            }
+            catch {
+                return c.json({ error: "theme must be valid JSON" }, 400);
+            }
+        }
+        try {
+            const spec = resolveWidgetSpawn(name, {
+                session,
+                dir,
+                target,
+                theme: theme,
+            });
+            return c.json(spec);
+        }
+        catch (err) {
+            return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+    });
+    // T067: /healthz — minimal liveness probe used by daemon-client.
+    // Intentionally NOT under /api so it bypasses the auth middleware on
+    // every consumer. Returns ok + version + uptime (ms since boot).
+    const HEALTHZ_BOOTED_AT = Date.now();
+    app.get("/healthz", (c) => {
+        return c.json({
+            ok: true,
+            version: process.env.npm_package_version ?? "dev",
+            uptimeMs: Date.now() - HEALTHZ_BOOTED_AT,
+        });
+    });
+    app.get("/api/sessions", (c) => {
+        const sessions = discoverSessions();
+        const overviews = buildOverviews(sessions);
+        return c.json({ sessions: overviews });
+    });
+    // ---------------------------------------------------------------------
+    // /api/workspaces — registry-backed CRUD. The registry is the source of
+    // truth for which projects the daemon serves. WS frames `workspace.added`
+    // and `workspace.removed` are emitted by the registry's emitter, picked
+    // up by ws-events' ensureWorkspaceRegistryListener and fanned to clients.
+    // ---------------------------------------------------------------------
+    app.get("/api/workspaces", (c) => {
+        const registry = getDefaultWorkspaceRegistry();
+        return c.json({ workspaces: registry.list() });
+    });
+    app.get("/api/workspaces/:name", (c) => {
+        const name = c.req.param("name");
+        const registry = getDefaultWorkspaceRegistry();
+        const workspace = registry.get(name);
+        if (!workspace)
+            return c.json({ error: "Workspace not found" }, 404);
+        return c.json({ workspace });
+    });
+    app.post("/api/workspaces", zValidator("json", AddWorkspaceRequestSchemaZ), (c) => {
+        const body = c.req.valid("json");
+        const registry = getDefaultWorkspaceRegistry();
+        const name = body.name ?? basename(body.projectDir);
+        if (!name || name.length === 0) {
+            return c.json({ error: "Cannot derive workspace name from projectDir" }, 400);
+        }
+        try {
+            const workspace = registry.add({
+                name,
+                sessionName: body.sessionName,
+                projectDir: body.projectDir,
+                ideConfigPath: body.ideConfigPath ?? null,
+            });
+            return c.json({ workspace }, 201);
+        }
+        catch (err) {
+            if (err instanceof WorkspaceAlreadyExistsError) {
+                return c.json({ error: err.message, code: err.code }, 409);
+            }
+            throw err;
+        }
+    });
+    // GET /api/chat/providers — discovery (claude-code / codex binaries on
+    // PATH). Distinct from `/api/providers`, which serves the redacted
+    // user-configured `ProviderInstanceSummary` set (T079).
+    app.delete("/api/workspaces/:name", (c) => {
+        const name = c.req.param("name");
+        const registry = getDefaultWorkspaceRegistry();
+        try {
+            registry.remove(name);
+            return c.body(null, 204);
+        }
+        catch (err) {
+            if (err instanceof WorkspaceNotFoundError) {
+                return c.json({ error: err.message, code: err.code }, 404);
+            }
+            throw err;
+        }
+    });
+    app.get("/api/project/:name", (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session) {
+            return c.json({ error: "Session not found" }, 404);
+        }
+        const detail = buildProjectDetail(session);
+        return c.json({ ...detail });
+    });
+    app.get("/api/project/:name/panes", (c) => {
+        const name = c.req.param("name");
+        let panes;
+        try {
+            panes = listSessionPanes(name);
+        }
+        catch {
+            return c.json({ error: "Session not found" }, 404);
+        }
+        if (panes.length === 0) {
+            // Verify the session actually exists before returning empty
+            const sessions = discoverSessions();
+            if (!sessions.find((s) => s.name === name)) {
+                return c.json({ error: "Session not found" }, 404);
+            }
+        }
+        return c.json({
+            panes: panes.map((p) => ({
+                id: p.id,
+                index: p.index,
+                title: p.title,
+                currentCommand: p.currentCommand,
+                width: p.width,
+                height: p.height,
+                active: p.active,
+                role: p.role,
+                name: p.name,
+                type: p.type,
+            })),
+        });
+    });
+    app.get("/api/project/:name/terminals", async (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        const records = loadTerminals(session.dir);
+        const terminals = records.map((t) => {
+            const bridge = defaultPtyBridgeRegistry.peek(t.id);
+            let runtime = { running: false };
+            if (bridge) {
+                const cols = typeof bridge.cols === "number" ? bridge.cols : undefined;
+                const rows = typeof bridge.rows === "number" ? bridge.rows : undefined;
+                const replay = typeof bridge.getReplayBuffer === "function"
+                    ? bridge.getReplayBuffer().byteLength
+                    : undefined;
+                runtime = {
+                    running: bridge.running !== false,
+                    ...(cols !== undefined ? { cols } : {}),
+                    ...(rows !== undefined ? { rows } : {}),
+                    ...(replay !== undefined ? { replayBytes: replay } : {}),
+                };
+            }
+            return { ...t, runtime };
+        });
+        return c.json({ terminals });
+    });
+    app.post("/api/project/:name/terminals", zValidator("json", terminalCreateRequestSchema), async (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        const body = c.req.valid("json");
+        // Pick the id: explicit > deterministic (when script provided) >
+        // UUID. The script-derived id collapse is the load-bearing bit
+        // for "two callers asking for the same run-script tab share a
+        // bridge + scrollback".
+        let id = body.id;
+        let scripted = false;
+        const kind = body.kind ?? "shell";
+        if (!id && body.script) {
+            id = await createScriptTerminalId({
+                projectId: name,
+                scopeId: body.scopeId,
+                kind,
+                script: body.script,
+            });
+            scripted = true;
+        }
+        if (!id)
+            id = randomUUID();
+        try {
+            const upsertInput = {
+                id,
+                projectId: name,
+                scopeId: body.scopeId,
+                name: body.name,
+                kind,
+            };
+            if (scripted)
+                upsertInput.scripted = true;
+            const record = upsertTerminalRecord(session.dir, upsertInput);
+            broadcastTerminalsChanged(name);
+            return c.json({ ok: true, terminal: record });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
+    app.post("/api/project/:name/terminals/:id/rename", zValidator("json", terminalRenameRequestSchema), async (c) => {
+        const name = c.req.param("name");
+        const id = c.req.param("id");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        try {
+            const record = renameTerminalRecord(session.dir, id, c.req.valid("json").name);
+            if (!record)
+                return c.json({ error: "Terminal not found" }, 404);
+            broadcastTerminalsChanged(name);
+            return c.json({ ok: true, terminal: record });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
+    app.delete("/api/project/:name/terminals/:id", async (c) => {
+        const name = c.req.param("name");
+        const id = c.req.param("id");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        const removedRecord = deleteTerminalRecord(session.dir, id);
+        // Kill the live bridge too — keep store + registry consistent.
+        const killed = defaultPtyBridgeRegistry.delete(id);
+        if (!removedRecord && !killed) {
+            return c.json({ error: "Terminal not found" }, 404);
+        }
+        broadcastTerminalsChanged(name);
+        return c.json({ ok: true });
+    });
+    // --- Project event/stream endpoints ---
+    // The orchestrator/task event feed moved out of tmux-ide (now in sfora.ai),
+    // so these surfaces only carry the live pane/project snapshot.
+    app.get("/api/project/:name/events", (c) => {
+        const name = c.req.param("name");
+        const session = discoverSessions().find((s) => s.name === name);
+        if (!session) {
+            return c.json({ error: "Session not found" }, 404);
+        }
+        return c.json({ events: [] });
+    });
+    app.get("/api/project/:name/stream", (c) => {
+        const name = c.req.param("name");
+        const session = discoverSessions().find((s) => s.name === name);
+        if (!session) {
+            return c.json({ error: "Session not found" }, 404);
+        }
+        return streamSSE(c, async (stream) => {
+            projectStreamConnections += 1;
+            sseMetrics.connections = projectStreamConnections;
+            let closed = false;
+            let previousSnapshotHash = "";
+            let lastPing = Date.now();
+            function writeSse(event, payload) {
+                sseMetrics.messagesSent += 1;
+                void stream.writeSSE({ event, data: JSON.stringify(freezePayload(payload)) });
+            }
+            function writeChanges(currentSession) {
+                const snapshot = buildProjectStreamSnapshot(currentSession);
+                const snapshotHash = JSON.stringify(snapshot);
+                if (snapshotHash !== previousSnapshotHash) {
+                    writeSse("snapshot", snapshot);
+                    previousSnapshotHash = snapshotHash;
+                }
+            }
+            try {
+                stream.onAbort(() => {
+                    closed = true;
+                });
+                writeChanges(session);
+                while (!closed) {
+                    await stream.sleep(250);
+                    const current = discoverSessions().find((candidate) => candidate.name === name);
+                    if (!current)
+                        break;
+                    writeChanges(current);
+                    const now = Date.now();
+                    if (now - lastPing >= 25_000) {
+                        writeSse("ping", { at: new Date().toISOString() });
+                        lastPing = now;
+                    }
+                }
+            }
+            finally {
+                projectStreamConnections = Math.max(0, projectStreamConnections - 1);
+                sseMetrics.connections = projectStreamConnections;
+            }
+        });
+    });
+    app.post("/api/project/:name/inject", async (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session) {
+            return c.json({ error: "Session not found" }, 404);
+        }
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        if (!body || typeof body !== "object" || Array.isArray(body)) {
+            return c.json({ error: "Invalid request body" }, 400);
+        }
+        const text = body.text;
+        const paneId = body.paneId;
+        const sendEnter = body.sendEnter;
+        if (typeof text !== "string" || text.trim().length === 0) {
+            return c.json({ error: "text must be a non-empty string" }, 400);
+        }
+        if (paneId !== undefined && (typeof paneId !== "string" || !/^%\d+$/.test(paneId))) {
+            return c.json({ error: "paneId must match /^%\\d+$/" }, 400);
+        }
+        if (sendEnter !== undefined && typeof sendEnter !== "boolean") {
+            return c.json({ error: "sendEnter must be a boolean" }, 400);
+        }
+        const panes = listSessionPanes(name);
+        const pane = paneId
+            ? panes.find((candidate) => candidate.id === paneId)
+            : panes.find((p) => p.active);
+        if (!pane) {
+            return c.json({ error: "Pane not found" }, 404);
+        }
+        sendLiteralToPane(name, pane.id, text);
+        if (sendEnter)
+            sendEnterToPane(name, pane.id);
+        return c.json({ ok: true });
+    });
+    // Send message to a pane by name/title/role/ID
+    app.post("/api/project/:name/send", zValidator("json", sendCommandSchema), async (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session) {
+            return c.json({ error: "Session not found" }, 404);
+        }
+        const { target, message, noEnter } = c.req.valid("json");
+        const panes = listSessionPanes(name);
+        const pane = resolvePane(panes, target);
+        if (!pane) {
+            const available = panes.map((p) => ({
+                id: p.id,
+                title: p.title,
+                name: p.name,
+                role: p.role,
+            }));
+            return c.json({ error: "Pane not found", target, available }, 404);
+        }
+        const busyStatus = getPaneBusyStatus(name, pane.id);
+        // Collapse multiline for agent panes
+        const prepared = busyStatus === "agent" ? message.replace(/\n+/g, " ").trim() : message;
+        if (noEnter) {
+            sendText(name, pane.id, prepared);
+        }
+        else {
+            sendCommand(name, pane.id, prepared);
+        }
+        return c.json({
+            ok: true,
+            session: name,
+            target: {
+                paneId: pane.id,
+                name: pane.name,
+                title: pane.title,
+                role: pane.role,
+            },
+            busyStatus,
+        });
+    });
+    // GET /api/project/:name/config — read parsed ide.yml + raw text. Used by
+    // the v2 Config editor to hydrate the form.
+    app.get("/api/project/:name/config", (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        try {
+            const { config, configPath } = readConfig(session.dir);
+            return c.json({ ok: true, config, configPath });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: "Failed to read ide.yml", detail: message }, 500);
+        }
+    });
+    // POST /api/project/:name/config — accept a full IdeConfig payload, validate
+    // against IdeConfigSchema, and write to ide.yml. Returns the persisted
+    // config so the client can re-hydrate without a follow-up GET.
+    app.post("/api/project/:name/config", async (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const parsed = IdeConfigSchema.safeParse(body);
+        if (!parsed.success) {
+            return c.json({ error: "Invalid config", details: parsed.error.issues }, 400);
+        }
+        try {
+            const configPath = writeConfig(session.dir, parsed.data);
+            return c.json({ ok: true, config: parsed.data, configPath });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: "Failed to write ide.yml", detail: message }, 500);
+        }
+    });
+    // Launch a tmux-ide session (shells out to CLI since launch has complex side effects)
+    const execFileAsync = promisify(execFile);
+    // POST /api/project/:name/restart — fire `tmux-ide restart` async. The CLI
+    // handles stop+launch; this endpoint is fire-and-forget aside from a short
+    // 30s timeout so the client can retry on its own.
+    app.post("/api/project/:name/restart", async (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session)
+            return c.json({ error: "Session not found" }, 404);
+        try {
+            await execFileAsync("tmux-ide", ["restart", "--json"], {
+                cwd: session.dir,
+                timeout: 30000,
+                env: { ...process.env, TMUX: "" },
+            });
+            return c.json({ ok: true, session: name, status: "restarted" });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: "Restart failed", detail: message }, 500);
+        }
+    });
+    app.post("/api/project/:name/launch", async (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session) {
+            return c.json({ error: "Session not found" }, 404);
+        }
+        // Check if already running
+        const state = getSessionState(name);
+        if (state.running) {
+            return c.json({ ok: true, session: name, status: "already_running" });
+        }
+        try {
+            await execFileAsync("tmux-ide", ["--json"], {
+                cwd: session.dir,
+                timeout: 30000,
+                env: { ...process.env, TMUX: "" }, // Clear TMUX to avoid nesting
+            });
+            return c.json({ ok: true, session: name, status: "launched" });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: "Launch failed", detail: message }, 500);
+        }
+    });
+    // Stop a tmux-ide session
+    app.post("/api/project/:name/stop", async (c) => {
+        const name = c.req.param("name");
+        const sessions = discoverSessions();
+        const session = sessions.find((s) => s.name === name);
+        if (!session) {
+            return c.json({ error: "Session not found" }, 404);
+        }
+        const state = getSessionState(name);
+        if (!state.running) {
+            return c.json({ ok: true, session: name, status: "not_running" });
+        }
+        stopSessionMonitor(name);
+        const result = killSession(name);
+        if (result.stopped) {
+            return c.json({ ok: true, session: name, status: "stopped" });
+        }
+        return c.json({ error: "Stop failed", reason: result.reason }, 500);
+    });
+    // SSE endpoint — cursor-based event streaming with orchestrator state
+    app.get("/api/events", (c) => {
+        return streamSSE(c, async (stream) => {
+            let prevOverviews = [];
+            const poll = () => {
+                const sessions = discoverSessions();
+                const overviews = buildOverviews(sessions);
+                const prevNames = new Set(prevOverviews.map((s) => s.name));
+                const currNames = new Set(overviews.map((s) => s.name));
+                for (const overview of overviews) {
+                    if (!prevNames.has(overview.name)) {
+                        stream.writeSSE({ event: "session_added", data: JSON.stringify(overview) });
+                    }
+                }
+                for (const prev of prevOverviews) {
+                    if (!currNames.has(prev.name)) {
+                        stream.writeSSE({
+                            event: "session_removed",
+                            data: JSON.stringify({ name: prev.name }),
+                        });
+                    }
+                }
+                prevOverviews = overviews;
+            };
+            poll();
+            while (true) {
+                await stream.sleep(2000);
+                poll();
+            }
+        });
+    });
+    // ---------------------------------------------------------------------
+    // GET /api/logs/:channel — SSE stream of structured logger entries.
+    //
+    // Channels are filtered views over the single in-process logger:
+    //   - "daemon"   → no component filter (all entries)
+    //   - "hq"       → component starts with "hq" or "remote"
+    //   - "watchdog" → component starts with "watchdog"
+    // The dashboard BottomPanel Output tab opens one EventSource per
+    // selected channel. Backfill from the in-memory ring buffer is sent
+    // first as `event: "backfill"` followed by a `bookmark` event so the
+    // client can render history immediately; new entries arrive as
+    // `event: "entry"` data.
+    // ---------------------------------------------------------------------
+    app.get("/api/logs/:channel", (c) => {
+        const channel = c.req.param("channel");
+        const match = matchLogChannel(channel);
+        if (!match) {
+            return c.json({ error: `Unknown log channel: ${channel}` }, 404);
+        }
+        return streamSSE(c, async (stream) => {
+            // 1. Backfill from the ring buffer.
+            const backfill = getLogBuffer().filter(match);
+            for (const entry of backfill) {
+                await stream.writeSSE({ event: "entry", data: JSON.stringify(entry) });
+            }
+            await stream.writeSSE({ event: "bookmark", data: String(backfill.length) });
+            // 2. Subscribe to live entries.
+            const queue = [];
+            let cancelled = false;
+            const unsub = subscribeLogs((entry) => {
+                if (cancelled)
+                    return;
+                if (match(entry))
+                    queue.push(entry);
+            });
+            try {
+                while (!cancelled) {
+                    if (queue.length === 0) {
+                        await stream.sleep(500);
+                        continue;
+                    }
+                    const drained = queue.splice(0, queue.length);
+                    for (const entry of drained) {
+                        await stream.writeSSE({ event: "entry", data: JSON.stringify(entry) });
+                    }
+                }
+            }
+            finally {
+                cancelled = true;
+                unsub();
+            }
+        });
+    });
+    app.get("/health", (c) => {
+        return c.json({
+            ok: true,
+            uptime: Math.round(process.uptime()),
+            version: pkgVersion,
+        });
+    });
+    // --- Project registry ---
+    app.get("/api/projects", (c) => {
+        return c.json({ projects: listProjects() });
+    });
+    app.get("/api/projects/templates", (c) => {
+        return c.json({ templates: listAvailableTemplates() });
+    });
+    app.post("/api/projects", async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const parsed = RegisterProjectRequestSchemaZ.safeParse(body);
+        if (!parsed.success) {
+            return c.json({ error: "Invalid request", details: parsed.error.issues }, 400);
+        }
+        try {
+            const project = await registerProject({
+                dir: parsed.data.dir,
+                name: parsed.data.name,
+            });
+            return c.json({ project }, 201);
+        }
+        catch (err) {
+            if (err instanceof ProjectDirNotFoundError) {
+                return c.json({ error: err.message, code: err.code }, 400);
+            }
+            if (err instanceof ProjectAlreadyRegisteredError) {
+                return c.json({ error: err.message, code: err.code, suggestion: err.suggestion }, 409);
+            }
+            throw err;
+        }
+    });
+    app.delete("/api/projects/:name", (c) => {
+        const name = c.req.param("name");
+        try {
+            unregisterProject(name);
+            return c.json({ ok: true });
+        }
+        catch (err) {
+            if (err instanceof ProjectNotFoundError) {
+                return c.json({ error: err.message, code: err.code }, 404);
+            }
+            throw err;
+        }
+    });
+    app.post("/api/projects/:name/probe", async (c) => {
+        const name = c.req.param("name");
+        if (!getProject(name)) {
+            return c.json({ error: `Project "${name}" not found in registry`, code: "NOT_FOUND" }, 404);
+        }
+        try {
+            const project = await refreshProject(name);
+            return c.json({ project });
+        }
+        catch (err) {
+            if (err instanceof ProjectNotFoundError) {
+                return c.json({ error: err.message, code: err.code }, 404);
+            }
+            throw err;
+        }
+    });
+    app.post("/api/projects/init", async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const parsed = InitProjectRequestSchemaZ.safeParse(body);
+        if (!parsed.success) {
+            return c.json({ error: "Invalid request", details: parsed.error.issues }, 400);
+        }
+        if (!existsSync(parsed.data.dir)) {
+            return c.json({ error: `Directory "${parsed.data.dir}" does not exist` }, 400);
+        }
+        const jobId = randomUUID();
+        const command = process.env.TMUX_IDE_INIT_COMMAND ?? "tmux-ide";
+        // Fire-and-forget — runs in the background and streams chunks via WS.
+        void (async () => {
+            try {
+                await runInit({
+                    cwd: parsed.data.dir,
+                    template: parsed.data.template,
+                    command,
+                    onChunk: (chunk) => {
+                        broadcastInitOutput(jobId, chunk);
+                    },
+                });
+                // Mark stream complete
+                broadcastInitOutput(jobId, "", true);
+                // Probe + register the freshly-init'd project so it shows up in
+                // the registry — also broadcasts `projects.changed`.
+                try {
+                    await registerProject({ dir: parsed.data.dir });
+                }
+                catch (err) {
+                    // Already-registered is benign here; report anything else.
+                    if (!(err instanceof ProjectAlreadyRegisteredError) &&
+                        !(err instanceof ProjectDirNotFoundError)) {
+                        broadcastInitError(jobId, err.message);
+                    }
+                }
+            }
+            catch (err) {
+                if (err instanceof ProjectInitTimeoutError) {
+                    broadcastInitError(jobId, err.message);
+                }
+                else if (err instanceof ProjectInitFailedError) {
+                    broadcastInitError(jobId, err.message);
+                }
+                else {
+                    broadcastInitError(jobId, err.message);
+                }
+            }
+        })();
+        return c.json({ jobId }, 202);
+    });
+    // -------------------------------------------------------------------------
+    // POST /api/filesystem/inspect — registry-agnostic directory inspection.
+    // POST /api/projects/onboard   — generate ide.yml + register the project.
+    // -------------------------------------------------------------------------
+    app.post("/api/projects/onboard", async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const parsed = OnboardProjectRequestSchemaZ.safeParse(body);
+        if (!parsed.success) {
+            return c.json({ error: "Invalid request", details: parsed.error.issues }, 400);
+        }
+        const sandboxResult = sandboxResolveDir(parsed.data.dir);
+        if ("error" in sandboxResult) {
+            return c.json({ error: sandboxResult.error, message: sandboxResult.message }, sandboxResult.status);
+        }
+        const dir = sandboxResult.canonical;
+        let inspect;
+        try {
+            inspect = await inspectProject(dir);
+        }
+        catch (err) {
+            if (err instanceof InspectDirNotFoundError) {
+                return c.json({ error: "not-found", message: err.message }, 404);
+            }
+            throw err;
+        }
+        // Never overwrite an existing ide.yml.
+        try {
+            assertNoExistingIdeYml(dir);
+        }
+        catch (err) {
+            if (err instanceof OnboardConflictError) {
+                return c.json({ error: err.message, code: err.code }, 409);
+            }
+            throw err;
+        }
+        // Compose the config from inputs (defaults to inspect.name).
+        const finalName = parsed.data.name?.trim() || inspect.name;
+        let config;
+        try {
+            config = composeIdeYmlConfig({
+                name: finalName,
+                agents: parsed.data.agents,
+                agentNames: parsed.data.agentNames,
+                devCommand: parsed.data.devCommand ?? null,
+                testCommand: parsed.data.testCommand ?? null,
+                lintCommand: parsed.data.lintCommand ?? null,
+            });
+        }
+        catch (err) {
+            if (err instanceof OnboardInvalidInputError) {
+                return c.json({ error: err.message, code: err.code }, 400);
+            }
+            throw err;
+        }
+        writeConfig(dir, config);
+        // Now register — this also broadcasts `projects.changed`.
+        try {
+            const project = await registerProject({ dir, name: finalName });
+            return c.json({ project }, 201);
+        }
+        catch (err) {
+            if (err instanceof ProjectAlreadyRegisteredError) {
+                return c.json({ error: err.message, code: err.code, suggestion: err.suggestion }, 409);
+            }
+            if (err instanceof ProjectDirNotFoundError) {
+                return c.json({ error: err.message, code: err.code }, 400);
+            }
+            throw err;
+        }
+    });
+    return app;
+}
+/**
+ * Discover bundled templates by reading `templates/*.yml`. Hardcoded
+ * descriptions for the canonical set; unknown templates surface with a
+ * generic label so we don't break if templates are added without updating
+ * this map.
+ */
+function listAvailableTemplates() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dir = dirname(__filename);
+    // Repo-root templates/ — 4 levels up from packages/daemon/src/command-center/.
+    // Pre-fold this lived at <pkg>/templates (..,.. worked); post-fold the
+    // canonical templates dir is at the repo root.
+    const templatesDir = join(__dir, "..", "..", "..", "..", "templates");
+    if (!existsSync(templatesDir))
+        return [];
+    const labels = {
+        default: { label: "Default", description: "Single Claude pane + dev/shell row" },
+        nextjs: {
+            label: "Next.js",
+            description: "Two Claude panes + Next.js dev server + shell",
+        },
+        vite: { label: "Vite", description: "Vite dev server + Claude + shell" },
+        convex: {
+            label: "Convex",
+            description: "Convex dev + Next.js + Claude pane",
+        },
+        python: { label: "Python", description: "Python project with Claude + tests" },
+        go: { label: "Go", description: "Go project with Claude + tests + shell" },
+        "agent-team": {
+            label: "Agent Team",
+            description: "Lead + teammate Claude panes for coordinated multi-agent work",
+        },
+        "agent-team-nextjs": {
+            label: "Agent Team — Next.js",
+            description: "Agent team layout tuned for a Next.js app",
+        },
+        "agent-team-monorepo": {
+            label: "Agent Team — Monorepo",
+            description: "Agent team layout for monorepos with multiple apps",
+        },
+        missions: {
+            label: "Missions",
+            description: "Mission-driven layout with planner, validator, and researcher",
+        },
+    };
+    const entries = readdirSync(templatesDir).filter((f) => f.endsWith(".yml"));
+    return entries
+        .map((file) => {
+        const id = file.replace(/\.yml$/, "");
+        const meta = labels[id];
+        return {
+            id,
+            label: meta?.label ?? id,
+            description: meta?.description ?? `Template: ${id}`,
+        };
+    })
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * Attach the unified `/ws/events` push channel to a Node HTTP server. The
+ * daemon calls this once after binding the command-center port. Existing
+ * SSE endpoints (`/api/events`, `/api/project/<name>/stream`) continue to
+ * work alongside this — they will be retired in a follow-up slice.
+ */
+export function attachWsEvents(server) {
+    const wss = new WebSocketServer({ noServer: true });
+    const upgradeListener = (req, socket, head) => {
+        const url = req.url ?? "/";
+        const pathname = url.split("?")[0];
+        if (pathname !== "/ws/events")
+            return;
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            handleWsEventsConnection(ws);
+        });
+    };
+    server.on("upgrade", upgradeListener);
+    return {
+        close: () => {
+            server.off("upgrade", upgradeListener);
+            wss.close();
+        },
+    };
+}