tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/cli.js

@@ -0,0 +1,425 @@
+import { parseArgs } from "node:util";
+import { resolve, dirname } from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+import { init } from "./init.js";
+import { ls } from "./ls.js";
+import { doctor } from "./doctor.js";
+import { status } from "./status.js";
+import { inspect } from "./inspect.js";
+import { validate } from "./validate.js";
+import { detect } from "./detect.js";
+import { config } from "./config.js";
+import { send } from "./send.js";
+import { IdeError, TmuxError } from "./lib/errors.js";
+import { printCommandError } from "./lib/output.js";
+import { getSessionName } from "./lib/yaml-io.js";
+import { attachSession } from "@tmux-ide/tmux-bridge";
+import { tryDispatchAction } from "./lib/cli-action-bridge.js";
+import { startEmbeddedDaemon } from "./index.js";
+export async function main() {
+    const { positionals, values: rawValues } = parseArgs({
+        allowPositionals: true,
+        strict: false,
+        options: {
+            json: { type: "boolean" },
+            headless: { type: "boolean" },
+            tasks: { type: "boolean" },
+            fix: { type: "boolean" },
+            row: { type: "string" },
+            pane: { type: "string" },
+            title: { type: "string" },
+            command: { type: "string" },
+            size: { type: "string" },
+            write: { type: "boolean" },
+            template: { type: "string" },
+            name: { type: "string" },
+            verbose: { type: "boolean", default: false },
+            help: { type: "boolean", short: "h" },
+            version: { type: "boolean", short: "v" },
+            // task command flags
+            description: { type: "string", short: "d" },
+            acceptance: { type: "string" },
+            priority: { type: "string", short: "p" },
+            status: { type: "string", short: "s" },
+            assign: { type: "string", short: "a" },
+            goal: { type: "string", short: "g" },
+            tags: { type: "string", short: "t" },
+            proof: { type: "string" },
+            depends: { type: "string" },
+            pr: { type: "boolean" },
+            specialty: { type: "string" },
+            milestone: { type: "string" },
+            fulfills: { type: "string" },
+            summary: { type: "string" },
+            sequence: { type: "string" },
+            evidence: { type: "string" },
+            port: { type: "string" },
+            // tunnel command flags
+            provider: { type: "string" },
+            domain: { type: "string" },
+            authtoken: { type: "string" },
+            // setup command flags
+            edit: { type: "boolean" },
+            wizard: { type: "boolean" },
+            // remote command flags
+            url: { type: "string" },
+            "hq-url": { type: "string" },
+            // send command flags
+            to: { type: "string" },
+            "no-enter": { type: "boolean" },
+        },
+    });
+    const values = rawValues;
+    const knownCommands = new Set([
+        "start",
+        "init",
+        "stop",
+        "attach",
+        "restart",
+        "ls",
+        "doctor",
+        "status",
+        "inspect",
+        "validate",
+        "detect",
+        "config",
+        "setup",
+        "send",
+        "settings",
+        "command-center",
+        "server",
+        "help",
+    ]);
+    // --version / -v
+    if (values.version) {
+        const pkg = await import("../../../package.json");
+        console.log(`tmux-ide v${pkg.default.version}`);
+        process.exit(0);
+    }
+    if (values.verbose) {
+        globalThis.__tmuxIdeVerbose = true;
+    }
+    const ALIASES = {};
+    const firstPositional = positionals[0];
+    const resolved = firstPositional ? (ALIASES[firstPositional] ?? firstPositional) : undefined;
+    const hasKnownCommand = resolved ? knownCommands.has(resolved) : false;
+    const command = hasKnownCommand ? resolved : "start";
+    const startTargetDir = hasKnownCommand ? positionals[1] : firstPositional;
+    const json = values.json ?? false;
+    const noColor = "NO_COLOR" in process.env;
+    const bold = (s) => (noColor ? s : `\x1b[1m${s}\x1b[22m`);
+    const cyan = (s) => (noColor ? s : `\x1b[36m${s}\x1b[39m`);
+    const dim = (s) => (noColor ? s : `\x1b[2m${s}\x1b[22m`);
+    if (values.help) {
+        printHelp();
+        process.exit(0);
+    }
+    function printHelp() {
+        console.log(`${bold("tmux-ide")} — Terminal IDE powered by tmux
+
+${bold("Usage:")}
+  ${cyan("tmux-ide")}                    ${dim("Launch IDE from ide.yml")}
+  ${cyan("tmux-ide --headless")}         ${dim("Start the canonical daemon without the app")}
+  ${cyan("tmux-ide <path>")}             ${dim("Launch from a specific directory")}
+  ${cyan("tmux-ide setup")}              ${dim("Interactive TUI setup wizard")}
+  ${cyan("tmux-ide setup --edit")}       ${dim("Open config tree editor")}
+  ${cyan("tmux-ide settings")}           ${dim("Interactive TUI config manager")}
+  ${cyan("tmux-ide init")} [--template]  ${dim("Scaffold a new ide.yml (auto-detects stack)")}
+  ${cyan("tmux-ide stop")}               ${dim("Kill the current IDE session")}
+  ${cyan("tmux-ide restart")}            ${dim("Stop and relaunch the IDE session")}
+  ${cyan("tmux-ide attach")}             ${dim("Reattach to a running session")}
+  ${cyan("tmux-ide ls")}                 ${dim("List all tmux sessions")}
+  ${cyan("tmux-ide status")} [--json]    ${dim("Show session status")}
+  ${cyan("tmux-ide inspect")} [--json]   ${dim("Show effective config and runtime state")}
+  ${cyan("tmux-ide doctor")}             ${dim("Check system requirements")}
+  ${cyan("tmux-ide validate")} [--json]  ${dim("Validate ide.yml")}
+  ${cyan("tmux-ide detect")} [--json]    ${dim("Detect project stack")}
+  ${cyan("tmux-ide detect --write")}     ${dim("Detect and write ide.yml")}
+  ${cyan("tmux-ide config")} [--json]    ${dim("Dump config as JSON")}
+  ${cyan("tmux-ide config set")} <path> <value>
+  ${cyan("tmux-ide config add-pane")} --row <N> --title <T> [--command <C>]
+  ${cyan("tmux-ide config remove-pane")} --row <N> --pane <M>
+  ${cyan("tmux-ide config add-row")} [--size <percent>]
+  ${cyan("tmux-ide config enable-team")} [--name <N>]   ${dim("Enable agent teams")}
+  ${cyan("tmux-ide config disable-team")}               ${dim("Disable agent teams")}
+
+${bold("Pane Messaging:")}
+  ${cyan("tmux-ide send")} <target> <message>     ${dim("Send message to a pane")}
+  ${cyan("tmux-ide send")} --to <name> <message>   ${dim("Target by name, title, role, or ID")}
+  ${cyan("tmux-ide send")} <target> --no-enter msg  ${dim("Send text without pressing Enter")}
+
+${bold("Server:")}
+  ${cyan("tmux-ide command-center")} [--port N]    ${dim("Start the command-center HTTP API")}
+  ${cyan("tmux-ide server")} [--port N]            ${dim("Start HTTP + PTY WebSocket server")}
+
+${bold("Flags:")}
+  ${cyan("--json")}                      ${dim("Output as JSON (all commands)")}
+  ${cyan("--headless")}                  ${dim("Run the canonical daemon in this process")}
+  ${cyan("--template <name>")}           ${dim("Use specific template for init")}
+  ${cyan("--write")}                     ${dim("Write detected config to ide.yml")}
+  ${cyan("--verbose")}                   ${dim("Log all tmux commands (or set TMUX_IDE_DEBUG=1)")}
+  ${cyan("-h, --help")}                  ${dim("Show usage")}
+      ${cyan("-v, --version")}               ${dim("Show version number")}`);
+    }
+    function resolveProjectName(targetDir) {
+        return getSessionName(resolve(targetDir ?? ".")).name;
+    }
+    async function dispatchProjectLaunch(projectName, cwd) {
+        const result = await tryDispatchAction("project.launch", { name: projectName }, { cwd });
+        if (!result) {
+            throw new IdeError("Canonical daemon is not available", {
+                code: "DAEMON_UNAVAILABLE",
+                exitCode: 1,
+            });
+        }
+        return result;
+    }
+    async function dispatchProjectOpenTerminal(projectName, cwd) {
+        const result = await tryDispatchAction("project.openTerminal", { name: projectName }, { cwd });
+        if (!result) {
+            throw new IdeError("Canonical daemon is not available", {
+                code: "DAEMON_UNAVAILABLE",
+                exitCode: 1,
+            });
+        }
+        return result;
+    }
+    async function dispatchProjectStop(projectName, cwd) {
+        const result = await tryDispatchAction("project.stop", { name: projectName }, { cwd });
+        if (!result) {
+            throw new IdeError("Canonical daemon is not available", {
+                code: "DAEMON_UNAVAILABLE",
+                exitCode: 1,
+            });
+        }
+        return result;
+    }
+    async function dispatchProjectRestart(projectName, cwd) {
+        const result = await tryDispatchAction("project.restart", { name: projectName }, { cwd });
+        if (!result) {
+            throw new IdeError("Canonical daemon is not available", {
+                code: "DAEMON_UNAVAILABLE",
+                exitCode: 1,
+            });
+        }
+        return result;
+    }
+    async function runHeadlessDaemon() {
+        let handle = null;
+        let stopping = false;
+        const stop = async () => {
+            if (stopping)
+                return;
+            stopping = true;
+            if (handle)
+                await handle.stop();
+        };
+        process.on("SIGINT", () => {
+            void stop().finally(() => process.exit(0));
+        });
+        process.on("SIGTERM", () => {
+            void stop().finally(() => process.exit(0));
+        });
+        handle = await startEmbeddedDaemon({ bindHostname: "127.0.0.1" });
+        console.log(`Canonical daemon: ${handle.apiBaseUrl}`);
+        await new Promise(() => undefined);
+    }
+    try {
+        if (values.headless) {
+            await runHeadlessDaemon();
+        }
+        else
+            switch (command) {
+                case "start":
+                    {
+                        const cwd = resolve(startTargetDir ?? ".");
+                        const projectName = resolveProjectName(startTargetDir);
+                        const result = await dispatchProjectLaunch(projectName, cwd);
+                        if (json) {
+                            console.log(JSON.stringify(result));
+                        }
+                        else if (result.started) {
+                            console.log(`Started "${result.sessionName}".`);
+                        }
+                        else {
+                            console.log(`Session "${result.sessionName}" is already running. Attaching...`);
+                        }
+                        attachSession(result.sessionName);
+                    }
+                    break;
+                case "init":
+                    await init({ template: values.template, json });
+                    break;
+                case "stop":
+                    {
+                        const cwd = resolve(positionals[1] ?? ".");
+                        const projectName = resolveProjectName(positionals[1]);
+                        const result = await dispatchProjectStop(projectName, cwd);
+                        if (json)
+                            console.log(JSON.stringify(result));
+                        else
+                            console.log(result.stopped ? `Stopped "${result.sessionName}".` : "No session running.");
+                    }
+                    break;
+                case "attach":
+                    {
+                        const cwd = resolve(positionals[1] ?? ".");
+                        const projectName = resolveProjectName(positionals[1]);
+                        const result = await dispatchProjectOpenTerminal(projectName, cwd);
+                        if (json)
+                            console.log(JSON.stringify(result));
+                        attachSession(result.sessionName);
+                    }
+                    break;
+                case "restart":
+                    {
+                        const cwd = resolve(positionals[1] ?? ".");
+                        const projectName = resolveProjectName(positionals[1]);
+                        const result = await dispatchProjectRestart(projectName, cwd);
+                        if (json)
+                            console.log(JSON.stringify(result));
+                        else
+                            console.log(`Restarted "${result.sessionName}".`);
+                        attachSession(result.sessionName);
+                    }
+                    break;
+                case "ls":
+                    await ls({ json });
+                    break;
+                case "doctor":
+                    await doctor({ json });
+                    break;
+                case "status":
+                    await status(positionals[1], { json });
+                    break;
+                case "inspect":
+                    await inspect(positionals[1], { json });
+                    break;
+                case "validate":
+                    await validate(positionals[1], { json });
+                    break;
+                case "detect":
+                    await detect(positionals[1], { json, write: values.write });
+                    break;
+                case "config": {
+                    const sub = positionals[1];
+                    let action = "dump";
+                    let configArgs = [];
+                    if (sub === "set") {
+                        action = "set";
+                        configArgs = positionals.slice(2);
+                    }
+                    else if (sub === "add-pane") {
+                        action = "add-pane";
+                        configArgs = [];
+                        if (values.row !== undefined)
+                            configArgs.push("--row", values.row);
+                        if (values.title !== undefined)
+                            configArgs.push("--title", values.title);
+                        if (values.command !== undefined)
+                            configArgs.push("--command", values.command);
+                        if (values.size !== undefined)
+                            configArgs.push("--size", values.size);
+                    }
+                    else if (sub === "remove-pane") {
+                        action = "remove-pane";
+                        configArgs = [];
+                        if (values.row !== undefined)
+                            configArgs.push("--row", values.row);
+                        if (values.pane !== undefined)
+                            configArgs.push("--pane", values.pane);
+                    }
+                    else if (sub === "add-row") {
+                        action = "add-row";
+                        configArgs = [];
+                        if (values.size !== undefined)
+                            configArgs.push("--size", values.size);
+                    }
+                    else if (sub === "enable-team") {
+                        action = "enable-team";
+                        configArgs = [];
+                        if (values.name !== undefined)
+                            configArgs.push("--name", values.name);
+                    }
+                    else if (sub === "disable-team") {
+                        action = "disable-team";
+                        configArgs = [];
+                    }
+                    else if (sub === "edit") {
+                        const scriptPath = resolve(__dirname, "./widgets/setup/index.tsx");
+                        execFileSync("bun", [scriptPath, "--dir=" + resolve(startTargetDir || "."), "--edit"], {
+                            stdio: "inherit",
+                        });
+                        break;
+                    }
+                    await config(null, { json, action, args: configArgs });
+                    break;
+                }
+                case "setup": {
+                    const scriptPath = resolve(__dirname, "./widgets/setup/index.tsx");
+                    const setupArgs = [scriptPath, "--dir=" + resolve(startTargetDir || ".")];
+                    if (positionals[1] === "--edit" || values.edit)
+                        setupArgs.push("--edit");
+                    if (positionals[1] === "--wizard" || values.wizard)
+                        setupArgs.push("--wizard");
+                    execFileSync("bun", setupArgs, { stdio: "inherit" });
+                    break;
+                }
+                case "send": {
+                    const target = values.to ?? positionals[1];
+                    const messageStart = values.to ? 1 : 2;
+                    let message = positionals.slice(messageStart).join(" ");
+                    if (!message && !process.stdin.isTTY) {
+                        const { readFileSync } = await import("node:fs");
+                        message = readFileSync(0, "utf-8").trim();
+                    }
+                    await send(undefined, { json, to: target, message, noEnter: values["no-enter"] });
+                    break;
+                }
+                case "settings": {
+                    const scriptPath = resolve(__dirname, "./widgets/config/index.tsx");
+                    execFileSync("bun", [scriptPath, "--dir=" + resolve(startTargetDir || ".")], {
+                        stdio: "inherit",
+                    });
+                    break;
+                }
+                case "command-center": {
+                    const { startCommandCenter } = await import("./command-center/index.js");
+                    await startCommandCenter({ port: parseInt(values.port ?? "4000") });
+                    break;
+                }
+                case "server": {
+                    if ("bun" in process.versions) {
+                        const scriptPath = resolve(__dirname, "./server/standalone.ts");
+                        const serverArgs = ["--experimental-strip-types", scriptPath];
+                        if (values.port)
+                            serverArgs.push("--port", values.port);
+                        execFileSync("node", serverArgs, { stdio: "inherit" });
+                    }
+                    else {
+                        const { start } = await import("./server/index.js");
+                        await start(values.port ? parseInt(values.port, 10) : undefined);
+                    }
+                    break;
+                }
+                case "help":
+                    printHelp();
+                    break;
+                default:
+                    throw new IdeError(`Unknown command: ${command}\nRun "tmux-ide help" for usage.`, {
+                        code: "USAGE",
+                        exitCode: 1,
+                    });
+            }
+    }
+    catch (error) {
+        if (error instanceof IdeError || error instanceof TmuxError) {
+            printCommandError(error, { json });
+        }
+        else {
+            throw error;
+        }
+    }
+}

package/packages/daemon/dist/command-center/actions/contract.d.ts

@@ -0,0 +1 @@
+export * from "@tmux-ide/contracts";

package/packages/daemon/dist/command-center/actions/contract.js

@@ -0,0 +1,2 @@
+// Action contract moved to @tmux-ide/contracts (T059). Re-export shim.
+export * from "@tmux-ide/contracts";

package/packages/daemon/dist/command-center/actions/dispatcher.d.ts

@@ -0,0 +1,27 @@
+/**
+ * v2 action dispatcher — single Hono route that resolves an action name
+ * against the registry, parses input + output with Zod, runs the handler,
+ * and broadcasts an `action.complete` WS frame on success.
+ *
+ * Endpoint: `POST /api/v2/action/:name`
+ *
+ * Wire envelope:
+ *   200 OK  { ok: true,  result }
+ *   200 OK  { ok: false, error: { code, message, details? } }   (typed app error)
+ *   400     malformed JSON body
+ *   404     unknown action name (transport-level — name isn't in the registry)
+ *
+ * `ok: false` is intentionally HTTP 200: it represents a typed application
+ * outcome the client is expected to handle. HTTP 4xx/5xx remain reserved
+ * for transport-level failures.
+ */
+import type { Context } from "hono";
+export interface DispatcherDeps {
+    /** Override the WS broadcaster (tests / non-default daemons). */
+    broadcast?: (name: string, result: unknown) => void;
+}
+/**
+ * Build the Hono handler. Exposed as a factory so tests can inject a
+ * broadcaster and assert on the WS event without mounting a real server.
+ */
+export declare function createActionDispatcher(deps?: DispatcherDeps): (c: Context) => Promise<Response>;

package/packages/daemon/dist/command-center/actions/dispatcher.js

@@ -0,0 +1,109 @@
+/**
+ * v2 action dispatcher — single Hono route that resolves an action name
+ * against the registry, parses input + output with Zod, runs the handler,
+ * and broadcasts an `action.complete` WS frame on success.
+ *
+ * Endpoint: `POST /api/v2/action/:name`
+ *
+ * Wire envelope:
+ *   200 OK  { ok: true,  result }
+ *   200 OK  { ok: false, error: { code, message, details? } }   (typed app error)
+ *   400     malformed JSON body
+ *   404     unknown action name (transport-level — name isn't in the registry)
+ *
+ * `ok: false` is intentionally HTTP 200: it represents a typed application
+ * outcome the client is expected to handle. HTTP 4xx/5xx remain reserved
+ * for transport-level failures.
+ */
+import { isActionName } from "./contract.js";
+import { wrapInternalError } from "./errors.js";
+import { getLooseActionEntry } from "./registry.js";
+import { broadcastActionComplete } from "../ws-events.js";
+function errorEnvelope(err) {
+    return { ok: false, error: err.toEnvelope() };
+}
+function zodErrorEnvelope(err) {
+    return {
+        ok: false,
+        error: {
+            code: "validation_failed",
+            message: "Input failed schema validation",
+            details: { issues: err.issues },
+        },
+    };
+}
+function outputZodErrorEnvelope(err) {
+    // A handler returned a value that does not conform to its declared output
+    // schema — log loudly and surface as `internal`. The dashboard treats
+    // this the same as any other server bug.
+    console.error("[actions] handler output failed schema validation", err.issues);
+    return {
+        ok: false,
+        error: {
+            code: "internal",
+            message: "Handler returned an invalid result",
+            details: { issues: err.issues },
+        },
+    };
+}
+/**
+ * Build the Hono handler. Exposed as a factory so tests can inject a
+ * broadcaster and assert on the WS event without mounting a real server.
+ */
+export function createActionDispatcher(deps = {}) {
+    const broadcast = deps.broadcast ?? broadcastActionComplete;
+    return async function dispatcher(c) {
+        const name = c.req.param("name");
+        if (!name || !isActionName(name)) {
+            return c.json({
+                ok: false,
+                error: {
+                    code: "validation_failed",
+                    message: `Unknown action: ${name}`,
+                    details: { name },
+                },
+            }, 404);
+        }
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch (err) {
+            // Malformed JSON is a transport problem, not an app outcome.
+            return c.json({
+                ok: false,
+                error: {
+                    code: "validation_failed",
+                    message: `Invalid JSON body: ${err.message ?? String(err)}`,
+                },
+            }, 400);
+        }
+        const actionName = name;
+        const entry = getLooseActionEntry(actionName);
+        const inputParsed = entry.inputSchema.safeParse(body);
+        if (!inputParsed.success) {
+            return c.json(zodErrorEnvelope(inputParsed.error), 200);
+        }
+        let result;
+        try {
+            result = await entry.handler(inputParsed.data);
+        }
+        catch (err) {
+            const wrapped = wrapInternalError(err);
+            return c.json(errorEnvelope(wrapped), 200);
+        }
+        const outputParsed = entry.resultSchema.safeParse(result);
+        if (!outputParsed.success) {
+            return c.json(outputZodErrorEnvelope(outputParsed.error), 200);
+        }
+        // Fire-and-forget: subscribers learn about the success via the WS bus.
+        try {
+            broadcast(actionName, outputParsed.data);
+        }
+        catch (err) {
+            // Broadcast failure must not turn a successful action into a failure.
+            console.error("[actions] broadcast failed:", err);
+        }
+        return c.json({ ok: true, result: outputParsed.data }, 200);
+    };
+}

package/packages/daemon/dist/command-center/actions/errors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Typed errors for the v2 action dispatcher. Every error path through a
+ * handler funnels into one of these so the dispatcher can map to the
+ * `{ ok: false, error: { code, message, details? } }` envelope without
+ * stringly-typed catches.
+ *
+ * Codes are stable wire identifiers — never rename without a coordinated
+ * dashboard release. New codes go at the bottom of the union.
+ */
+import { TerminalCwdError } from "../../server/pty-bridge.ts";
+export type ActionErrorCode = "project_not_found" | "cwd_not_found" | "cwd_not_directory" | "cwd_stat_failed" | "session_already_running" | "session_not_running" | "launch_failed" | "stop_failed" | "terminal_not_found" | "validation_failed" | "task_not_found" | "goal_not_found" | "milestone_not_found" | "mission_not_set" | "task_dependency_unmet" | "task_already_assigned" | "skill_invalid" | "skill_not_found" | "ide_yml_missing" | "config_path_invalid" | "config_validation_failed" | "validation_assertion_not_found" | "webhook_not_found" | "webhook_test_failed" | "remote_access_restart_failed" | "shutdown_already_in_progress" | "bad_request" | "thread_not_found" | "permission_request_not_found" | "internal";
+export declare class ActionError extends Error {
+    readonly code: ActionErrorCode;
+    readonly details: unknown | undefined;
+    constructor(args: {
+        code: ActionErrorCode;
+        message: string;
+        details?: unknown;
+        cause?: unknown;
+    });
+    toEnvelope(): {
+        code: ActionErrorCode;
+        message: string;
+        details?: unknown;
+    };
+}
+/**
+ * Translate a {@link TerminalCwdError} into an {@link ActionError} with the
+ * matching wire code. The cwd is preserved in `details` so the dashboard can
+ * surface it without re-parsing the error message.
+ */
+export declare function actionErrorFromCwdError(err: TerminalCwdError): ActionError;
+/**
+ * Wrap an unknown thrown value as an `internal` ActionError. Used as the
+ * last-resort branch in dispatcher catch blocks so handlers never leak raw
+ * Error stacks across the wire.
+ */
+export declare function wrapInternalError(err: unknown): ActionError;

package/packages/daemon/dist/command-center/actions/errors.js

@@ -0,0 +1,56 @@
+/**
+ * Typed errors for the v2 action dispatcher. Every error path through a
+ * handler funnels into one of these so the dispatcher can map to the
+ * `{ ok: false, error: { code, message, details? } }` envelope without
+ * stringly-typed catches.
+ *
+ * Codes are stable wire identifiers — never rename without a coordinated
+ * dashboard release. New codes go at the bottom of the union.
+ */
+import { TerminalCwdError } from "../../server/pty-bridge.js";
+export class ActionError extends Error {
+    code;
+    details;
+    constructor(args) {
+        super(args.message, args.cause !== undefined ? { cause: args.cause } : undefined);
+        this.name = "ActionError";
+        this.code = args.code;
+        this.details = args.details;
+    }
+    toEnvelope() {
+        return this.details !== undefined
+            ? { code: this.code, message: this.message, details: this.details }
+            : { code: this.code, message: this.message };
+    }
+}
+const CWD_REASON_TO_CODE = {
+    notFound: "cwd_not_found",
+    notDirectory: "cwd_not_directory",
+    statFailed: "cwd_stat_failed",
+};
+/**
+ * Translate a {@link TerminalCwdError} into an {@link ActionError} with the
+ * matching wire code. The cwd is preserved in `details` so the dashboard can
+ * surface it without re-parsing the error message.
+ */
+export function actionErrorFromCwdError(err) {
+    return new ActionError({
+        code: CWD_REASON_TO_CODE[err.reason],
+        message: err.message,
+        details: { cwd: err.cwd, reason: err.reason },
+        cause: err,
+    });
+}
+/**
+ * Wrap an unknown thrown value as an `internal` ActionError. Used as the
+ * last-resort branch in dispatcher catch blocks so handlers never leak raw
+ * Error stacks across the wire.
+ */
+export function wrapInternalError(err) {
+    if (err instanceof ActionError)
+        return err;
+    if (err instanceof TerminalCwdError)
+        return actionErrorFromCwdError(err);
+    const message = err instanceof Error ? err.message : String(err);
+    return new ActionError({ code: "internal", message, cause: err });
+}

package/packages/daemon/dist/command-center/actions/handlers/_project-context.d.ts

@@ -0,0 +1,12 @@
+import { type ProjectResolverDeps } from "./_resolve-project.ts";
+export interface ProjectContextDeps extends ProjectResolverDeps {
+    cwd?: string;
+}
+export interface ProjectContextInput {
+    projectName?: string;
+}
+export interface ProjectContext {
+    dir: string;
+    sessionName: string;
+}
+export declare function resolveProjectContext(input: ProjectContextInput, deps?: ProjectContextDeps): ProjectContext;