tmux-ide 2.1.5 → 2.6.1

package/packages/daemon/dist/command-center/actions/handlers/project-launch.js

@@ -0,0 +1,58 @@
+/**
+ * Handler: `project.launch`.
+ *
+ * Idempotent programmatic launch. Resolves the project from the registry,
+ * checks whether a session is already running, and returns
+ * `{ started: false }` without invoking the launcher when so. Otherwise
+ * delegates to `src/launch.ts` with `attach: false`.
+ */
+import { hasSession as hasSessionDefault } from "@tmux-ide/tmux-bridge";
+import { launch as launchDefault } from "../../../launch.js";
+import { ActionError } from "../errors.js";
+import { resolveProject } from "./_resolve-project.js";
+import { getDefaultWorkspaceRegistry } from "../../../lib/workspace-registry.js";
+/**
+ * Ensure the workspace registry knows about this project. The project
+ * registry (`registerProject`) only updates the project-list — but
+ * `discoverSessions` / `/api/project/:name` consult the WORKSPACE registry
+ * before returning anything. Without this sync, every dashboard fetch
+ * 404s for projects that weren't passed as the daemon's primary sessionName.
+ */
+function ensureWorkspaceRegistered(name, sessionName, dir) {
+    const reg = getDefaultWorkspaceRegistry();
+    if (reg.has(name))
+        return;
+    try {
+        reg.add({ name, sessionName, projectDir: dir });
+    }
+    catch {
+        // ALREADY_EXISTS or persistence error — non-fatal; the next discover
+        // pass will pick it up if persistence eventually succeeds.
+    }
+}
+export async function projectLaunchHandler(input, deps = {}) {
+    const project = resolveProject(input.name, deps);
+    const hasSession = deps.hasSession ?? hasSessionDefault;
+    if (hasSession(project.sessionName)) {
+        // Session already running — but the workspace registry may still be
+        // stale (e.g. tmux session created via curl, or daemon restarted).
+        // Sync before returning so /api/project/:name resolves.
+        ensureWorkspaceRegistered(project.name, project.sessionName, project.dir);
+        return { sessionName: project.sessionName, started: false };
+    }
+    const launch = deps.launch ?? launchDefault;
+    try {
+        await launch(project.dir, { json: false, attach: false });
+    }
+    catch (err) {
+        throw new ActionError({
+            code: "launch_failed",
+            message: `Failed to launch session "${project.sessionName}": ${err.message ?? String(err)}`,
+            details: { sessionName: project.sessionName, dir: project.dir },
+            cause: err,
+        });
+    }
+    // Freshly launched — workspace registry definitely needs the entry.
+    ensureWorkspaceRegistered(project.name, project.sessionName, project.dir);
+    return { sessionName: project.sessionName, started: true };
+}

package/packages/daemon/dist/command-center/actions/handlers/project-open-terminal.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Handler: `project.openTerminal`.
+ *
+ * Resolves the project's cwd from the registry, ensures the tmux session is
+ * running (launching it if necessary), and asserts the resolved cwd is a
+ * real directory. Returns the dashboard's stable terminal tab id together
+ * with the resolved cwd so the dashboard does not need to stitch together
+ * the registry / session / cwd paths itself.
+ *
+ * This is the action that swallows the seam where the dashboard previously
+ * juggled `/api/projects` + `/api/project/:name` to figure out where to
+ * open a terminal.
+ */
+import type { Stats } from "node:fs";
+import { type ActionInput, type ActionResult } from "../contract.ts";
+import { type ProjectResolverDeps } from "./_resolve-project.ts";
+/**
+ * Build the dashboard-facing terminal tab id for a session's default
+ * terminal. Mirrors the layout state convention `terminal:<session>:default`.
+ * Centralised here so both this handler and tests share the source of truth.
+ */
+export declare function defaultTerminalTabId(sessionName: string): string;
+export interface ProjectOpenTerminalDeps extends ProjectResolverDeps {
+    hasSession?: (session: string) => boolean;
+    launch?: (dir: string, options: {
+        json: boolean;
+        attach: boolean;
+    }) => Promise<void>;
+    statCwd?: (cwd: string) => Stats;
+    activateProject?: (name: string) => Promise<void>;
+}
+export declare function projectOpenTerminalHandler(input: ActionInput<"project.openTerminal">, deps?: ProjectOpenTerminalDeps): Promise<ActionResult<"project.openTerminal">>;

package/packages/daemon/dist/command-center/actions/handlers/project-open-terminal.js

@@ -0,0 +1,69 @@
+/**
+ * Handler: `project.openTerminal`.
+ *
+ * Resolves the project's cwd from the registry, ensures the tmux session is
+ * running (launching it if necessary), and asserts the resolved cwd is a
+ * real directory. Returns the dashboard's stable terminal tab id together
+ * with the resolved cwd so the dashboard does not need to stitch together
+ * the registry / session / cwd paths itself.
+ *
+ * This is the action that swallows the seam where the dashboard previously
+ * juggled `/api/projects` + `/api/project/:name` to figure out where to
+ * open a terminal.
+ */
+import { hasSession as hasSessionDefault } from "@tmux-ide/tmux-bridge";
+import { launch as launchDefault } from "../../../launch.js";
+import { activateProject as activateProjectDefault } from "../../../lib/active-projects.js";
+import { assertValidCwd, TerminalCwdError } from "../../../server/pty-bridge.js";
+import { ActionError, actionErrorFromCwdError } from "../errors.js";
+import { resolveProject } from "./_resolve-project.js";
+const TERMINAL_TAB_ID_PREFIX = "terminal";
+const TERMINAL_TAB_ID_SUFFIX = "default";
+/**
+ * Build the dashboard-facing terminal tab id for a session's default
+ * terminal. Mirrors the layout state convention `terminal:<session>:default`.
+ * Centralised here so both this handler and tests share the source of truth.
+ */
+export function defaultTerminalTabId(sessionName) {
+    return `${TERMINAL_TAB_ID_PREFIX}:${sessionName}:${TERMINAL_TAB_ID_SUFFIX}`;
+}
+export async function projectOpenTerminalHandler(input, deps = {}) {
+    const project = resolveProject(input.name, deps);
+    const activateProject = deps.activateProject ?? activateProjectDefault;
+    await activateProject(project.name);
+    // Always validate cwd up-front. A missing/broken project dir is the most
+    // common cause of the bugs this slice exists to eliminate.
+    try {
+        assertValidCwd(project.dir, deps.statCwd);
+    }
+    catch (err) {
+        if (err instanceof TerminalCwdError) {
+            throw actionErrorFromCwdError(err);
+        }
+        throw err;
+    }
+    const hasSession = deps.hasSession ?? hasSessionDefault;
+    const launch = deps.launch ?? launchDefault;
+    let launched = false;
+    if (!hasSession(project.sessionName)) {
+        try {
+            // attach: false — we run inside the daemon HTTP server, not a TTY.
+            await launch(project.dir, { json: false, attach: false });
+            launched = true;
+        }
+        catch (err) {
+            throw new ActionError({
+                code: "launch_failed",
+                message: `Failed to launch session "${project.sessionName}": ${err.message ?? String(err)}`,
+                details: { sessionName: project.sessionName, dir: project.dir },
+                cause: err,
+            });
+        }
+    }
+    return {
+        sessionName: project.sessionName,
+        cwd: project.dir,
+        terminalTabId: defaultTerminalTabId(project.sessionName),
+        launched,
+    };
+}

package/packages/daemon/dist/command-center/actions/handlers/project-restart.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Handler: `project.restart`.
+ *
+ * Programmatic version of `tmux-ide restart`. Stops the session monitor +
+ * kills the existing tmux session (when present), then re-launches with
+ * `attach: false`. Always reports `restarted: true` on success — the call
+ * is meaningful whether or not a session was previously running.
+ */
+import { type ActionInput, type ActionResult } from "../contract.ts";
+import { type ProjectResolverDeps } from "./_resolve-project.ts";
+export interface ProjectRestartDeps extends ProjectResolverDeps {
+    restart?: (dir: string, options: {
+        json?: boolean;
+        attach?: boolean;
+    }) => Promise<void>;
+}
+export declare function projectRestartHandler(input: ActionInput<"project.restart">, deps?: ProjectRestartDeps): Promise<ActionResult<"project.restart">>;

package/packages/daemon/dist/command-center/actions/handlers/project-restart.js

@@ -0,0 +1,27 @@
+/**
+ * Handler: `project.restart`.
+ *
+ * Programmatic version of `tmux-ide restart`. Stops the session monitor +
+ * kills the existing tmux session (when present), then re-launches with
+ * `attach: false`. Always reports `restarted: true` on success — the call
+ * is meaningful whether or not a session was previously running.
+ */
+import { restart as restartDefault } from "../../../restart.js";
+import { ActionError } from "../errors.js";
+import { resolveProject } from "./_resolve-project.js";
+export async function projectRestartHandler(input, deps = {}) {
+    const project = resolveProject(input.name, deps);
+    const restart = deps.restart ?? restartDefault;
+    try {
+        await restart(project.dir, { json: false, attach: false });
+    }
+    catch (err) {
+        throw new ActionError({
+            code: "launch_failed",
+            message: `Failed to restart session "${project.sessionName}": ${err.message ?? String(err)}`,
+            details: { sessionName: project.sessionName, dir: project.dir },
+            cause: err,
+        });
+    }
+    return { sessionName: project.sessionName, restarted: true };
+}

package/packages/daemon/dist/command-center/actions/handlers/project-stop.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Handler: `project.stop`.
+ *
+ * Wraps the CLI `tmux-ide stop` flow programmatically: stop the session
+ * monitor, then `killSession`. Idempotent —
+ * returns `{ stopped: false }` when no session was running rather than
+ * throwing, so the dashboard can call this freely.
+ */
+import { type ActionInput, type ActionResult } from "../contract.ts";
+import { type ProjectResolverDeps } from "./_resolve-project.ts";
+export interface ProjectStopDeps extends ProjectResolverDeps {
+    hasSession?: (session: string) => boolean;
+    killSession?: (session: string) => {
+        stopped: boolean;
+        reason: string | null;
+    };
+    stopSessionMonitor?: (session: string) => void;
+    /**
+     * Legacy hook retained for tests. Per-session daemon cleanup is no longer
+     * needed because the canonical daemon is app/headless owned.
+     */
+    killOrphanDaemons?: (session: string) => void;
+}
+export declare function projectStopHandler(input: ActionInput<"project.stop">, deps?: ProjectStopDeps): Promise<ActionResult<"project.stop">>;

package/packages/daemon/dist/command-center/actions/handlers/project-stop.js

@@ -0,0 +1,38 @@
+/**
+ * Handler: `project.stop`.
+ *
+ * Wraps the CLI `tmux-ide stop` flow programmatically: stop the session
+ * monitor, then `killSession`. Idempotent —
+ * returns `{ stopped: false }` when no session was running rather than
+ * throwing, so the dashboard can call this freely.
+ */
+import { hasSession as hasSessionDefault, killSession as killSessionDefault, stopSessionMonitor as stopSessionMonitorDefault, } from "@tmux-ide/tmux-bridge";
+import { ActionError } from "../errors.js";
+import { resolveProject } from "./_resolve-project.js";
+function defaultKillOrphanDaemons(_session) {
+    // No-op: per-session daemons are no longer spawned.
+}
+export async function projectStopHandler(input, deps = {}) {
+    const project = resolveProject(input.name, deps);
+    const hasSession = deps.hasSession ?? hasSessionDefault;
+    if (!hasSession(project.sessionName)) {
+        return { sessionName: project.sessionName, stopped: false };
+    }
+    const stopSessionMonitor = deps.stopSessionMonitor ?? stopSessionMonitorDefault;
+    const killSession = deps.killSession ?? killSessionDefault;
+    const killOrphanDaemons = deps.killOrphanDaemons ?? defaultKillOrphanDaemons;
+    try {
+        stopSessionMonitor(project.sessionName);
+        killOrphanDaemons(project.sessionName);
+        const result = killSession(project.sessionName);
+        return { sessionName: project.sessionName, stopped: result.stopped };
+    }
+    catch (err) {
+        throw new ActionError({
+            code: "stop_failed",
+            message: `Failed to stop session "${project.sessionName}": ${err.message ?? String(err)}`,
+            details: { sessionName: project.sessionName },
+            cause: err,
+        });
+    }
+}

package/packages/daemon/dist/command-center/actions/handlers/terminal-respawn.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Handler: `terminal.respawn`.
+ *
+ * Server-side equivalent of the dashboard's `bridge.restartWith(...)` call.
+ * Looks up the PTY bridge by id; if a cwd is supplied it validates the
+ * directory and passes it through; otherwise it respawns at the bridge's
+ * recorded `lastCwd`.
+ *
+ * Why server-side? The dashboard previously had to do the cwd resolution
+ * itself before it could ask the bridge to restart. Centralising it here
+ * keeps the cwd contract on the server, where it has direct access to the
+ * project registry and the bridge's filesystem.
+ */
+import { type PtyBridgeRegistry } from "../../../server/ws-route.ts";
+import type { Stats } from "node:fs";
+import { type ActionInput, type ActionResult } from "../contract.ts";
+export interface TerminalRespawnDeps {
+    registry?: PtyBridgeRegistry;
+    /** Override for the bridge dimensions used on respawn. Tests inject these. */
+    cols?: number;
+    rows?: number;
+    statCwd?: (cwd: string) => Stats;
+}
+export declare function terminalRespawnHandler(input: ActionInput<"terminal.respawn">, deps?: TerminalRespawnDeps): ActionResult<"terminal.respawn">;

package/packages/daemon/dist/command-center/actions/handlers/terminal-respawn.js

@@ -0,0 +1,88 @@
+/**
+ * Handler: `terminal.respawn`.
+ *
+ * Server-side equivalent of the dashboard's `bridge.restartWith(...)` call.
+ * Looks up the PTY bridge by id; if a cwd is supplied it validates the
+ * directory and passes it through; otherwise it respawns at the bridge's
+ * recorded `lastCwd`.
+ *
+ * Why server-side? The dashboard previously had to do the cwd resolution
+ * itself before it could ask the bridge to restart. Centralising it here
+ * keeps the cwd contract on the server, where it has direct access to the
+ * project registry and the bridge's filesystem.
+ */
+import { defaultPtyBridgeRegistry as defaultRegistry, } from "../../../server/ws-route.js";
+import { assertValidCwd, TerminalCwdError } from "../../../server/pty-bridge.js";
+import { ActionError, actionErrorFromCwdError } from "../errors.js";
+const DEFAULT_RESPAWN_COLS = 80;
+const DEFAULT_RESPAWN_ROWS = 24;
+export function terminalRespawnHandler(input, deps = {}) {
+    const registry = deps.registry ?? defaultRegistry;
+    const bridge = registry.peek(input.terminalId);
+    if (!bridge) {
+        throw new ActionError({
+            code: "terminal_not_found",
+            message: `No running terminal bridge for id "${input.terminalId}"`,
+            details: { terminalId: input.terminalId, sessionName: input.sessionName },
+        });
+    }
+    if (!bridge.restartWith) {
+        throw new ActionError({
+            code: "internal",
+            message: "Bridge does not support restartWith",
+            details: { terminalId: input.terminalId },
+        });
+    }
+    const cwd = resolveRespawnCwd(input, bridge, deps.statCwd);
+    const cols = deps.cols ?? bridge.cols ?? DEFAULT_RESPAWN_COLS;
+    const rows = deps.rows ?? bridge.rows ?? DEFAULT_RESPAWN_ROWS;
+    try {
+        bridge.restartWith(cols, rows, { cwd });
+    }
+    catch (err) {
+        if (err instanceof TerminalCwdError) {
+            throw actionErrorFromCwdError(err);
+        }
+        throw new ActionError({
+            code: "internal",
+            message: `Failed to respawn terminal "${input.terminalId}": ${err.message ?? String(err)}`,
+            details: { terminalId: input.terminalId },
+            cause: err,
+        });
+    }
+    return { respawned: true, cwd };
+}
+function resolveRespawnCwd(input, bridge, statCwd) {
+    if (input.cwd) {
+        try {
+            assertValidCwd(input.cwd, statCwd);
+        }
+        catch (err) {
+            if (err instanceof TerminalCwdError) {
+                throw actionErrorFromCwdError(err);
+            }
+            throw err;
+        }
+        return input.cwd;
+    }
+    const last = bridge.getCwd?.() ?? null;
+    if (!last) {
+        throw new ActionError({
+            code: "internal",
+            message: "Cannot respawn terminal without an explicit cwd: bridge has no recorded cwd",
+            details: { terminalId: input.terminalId },
+        });
+    }
+    // Validate the recorded cwd too — the directory may have been deleted
+    // since the bridge first spawned.
+    try {
+        assertValidCwd(last, statCwd);
+    }
+    catch (err) {
+        if (err instanceof TerminalCwdError) {
+            throw actionErrorFromCwdError(err);
+        }
+        throw err;
+    }
+    return last;
+}

package/packages/daemon/dist/command-center/actions/handlers/terminal-stop.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Handler: `terminal.stop`.
+ *
+ * Kill a running PTY bridge by id. Wraps {@link PtyBridgeRegistry.delete} —
+ * the registry delete is what resets the entry's clients counter, clears
+ * any idle timer, and emits SIGTERM. Returns `{ stopped: true }` only when
+ * a bridge actually existed; otherwise raises `terminal_not_found`.
+ */
+import { type PtyBridgeRegistry } from "../../../server/ws-route.ts";
+import { type ActionInput, type ActionResult } from "../contract.ts";
+export interface TerminalStopDeps {
+    registry?: PtyBridgeRegistry;
+}
+export declare function terminalStopHandler(input: ActionInput<"terminal.stop">, deps?: TerminalStopDeps): ActionResult<"terminal.stop">;

package/packages/daemon/dist/command-center/actions/handlers/terminal-stop.js

@@ -0,0 +1,22 @@
+/**
+ * Handler: `terminal.stop`.
+ *
+ * Kill a running PTY bridge by id. Wraps {@link PtyBridgeRegistry.delete} —
+ * the registry delete is what resets the entry's clients counter, clears
+ * any idle timer, and emits SIGTERM. Returns `{ stopped: true }` only when
+ * a bridge actually existed; otherwise raises `terminal_not_found`.
+ */
+import { defaultPtyBridgeRegistry as defaultRegistry, } from "../../../server/ws-route.js";
+import { ActionError } from "../errors.js";
+export function terminalStopHandler(input, deps = {}) {
+    const registry = deps.registry ?? defaultRegistry;
+    const ok = registry.delete(input.terminalId);
+    if (!ok) {
+        throw new ActionError({
+            code: "terminal_not_found",
+            message: `No terminal bridge for id "${input.terminalId}"`,
+            details: { terminalId: input.terminalId, sessionName: input.sessionName },
+        });
+    }
+    return { stopped: true };
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Registry: maps each action name to its input/output schemas and handler.
+ *
+ * The dispatcher in `dispatcher.ts` is the only consumer — it parses the
+ * URL `:name` against `ACTION_NAMES`, then looks up the handler here. Every
+ * handler accepts a typed input and returns the typed result; the
+ * dispatcher applies output-side Zod validation as defense in depth.
+ *
+ * Adding a new action: define schemas in `contract.ts`, add a handler in
+ * `handlers/`, then wire it here.
+ */
+import type { z } from "zod";
+import { ActionContractsZ, type ActionInput, type ActionName, type ActionResult } from "./contract.ts";
+export type ActionHandler<N extends ActionName> = (input: ActionInput<N>) => Promise<ActionResult<N>> | ActionResult<N>;
+export interface ActionRegistryEntry<N extends ActionName> {
+    inputSchema: (typeof ActionContractsZ)[N]["input"];
+    resultSchema: (typeof ActionContractsZ)[N]["result"];
+    handler: ActionHandler<N>;
+}
+type RegistryShape = {
+    [N in ActionName]: ActionRegistryEntry<N>;
+};
+export declare const actionRegistry: RegistryShape;
+/**
+ * Generic accessor that preserves the `N` type binding. Exposed as a
+ * convenience for tests; the dispatcher uses the registry directly.
+ */
+export declare function getActionEntry<N extends ActionName>(name: N): ActionRegistryEntry<N>;
+export type LooseActionEntry = ActionRegistryEntry<ActionName> & {
+    inputSchema: z.ZodTypeAny;
+    resultSchema: z.ZodTypeAny;
+    handler: (input: unknown) => Promise<unknown> | unknown;
+};
+export declare function getLooseActionEntry(name: ActionName): LooseActionEntry;
+export {};

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

@@ -0,0 +1,109 @@
+/**
+ * Registry: maps each action name to its input/output schemas and handler.
+ *
+ * The dispatcher in `dispatcher.ts` is the only consumer — it parses the
+ * URL `:name` against `ACTION_NAMES`, then looks up the handler here. Every
+ * handler accepts a typed input and returns the typed result; the
+ * dispatcher applies output-side Zod validation as defense in depth.
+ *
+ * Adding a new action: define schemas in `contract.ts`, add a handler in
+ * `handlers/`, then wire it here.
+ */
+import { ActionContractsZ, } from "./contract.js";
+import { projectOpenTerminalHandler } from "./handlers/project-open-terminal.js";
+import { projectActivateHandler } from "./handlers/project-activate.js";
+import { projectLaunchHandler } from "./handlers/project-launch.js";
+import { projectStopHandler } from "./handlers/project-stop.js";
+import { projectRestartHandler } from "./handlers/project-restart.js";
+import { terminalRespawnHandler } from "./handlers/terminal-respawn.js";
+import { terminalStopHandler } from "./handlers/terminal-stop.js";
+import { configAddPaneHandler, configAddRowHandler, configDisableTeamHandler, configEnableTeamHandler, configRemovePaneHandler, configSetHandler, } from "./handlers/config-actions.js";
+import { appSetRemoteAccessHandler } from "./handlers/app-set-remote-access.js";
+import { daemonShutdownHandler } from "./handlers/daemon-shutdown.js";
+export const actionRegistry = {
+    "project.openTerminal": {
+        inputSchema: ActionContractsZ["project.openTerminal"].input,
+        resultSchema: ActionContractsZ["project.openTerminal"].result,
+        handler: projectOpenTerminalHandler,
+    },
+    "project.launch": {
+        inputSchema: ActionContractsZ["project.launch"].input,
+        resultSchema: ActionContractsZ["project.launch"].result,
+        handler: projectLaunchHandler,
+    },
+    "project.stop": {
+        inputSchema: ActionContractsZ["project.stop"].input,
+        resultSchema: ActionContractsZ["project.stop"].result,
+        handler: projectStopHandler,
+    },
+    "project.restart": {
+        inputSchema: ActionContractsZ["project.restart"].input,
+        resultSchema: ActionContractsZ["project.restart"].result,
+        handler: projectRestartHandler,
+    },
+    "project.activate": {
+        inputSchema: ActionContractsZ["project.activate"].input,
+        resultSchema: ActionContractsZ["project.activate"].result,
+        handler: projectActivateHandler,
+    },
+    "terminal.respawn": {
+        inputSchema: ActionContractsZ["terminal.respawn"].input,
+        resultSchema: ActionContractsZ["terminal.respawn"].result,
+        handler: terminalRespawnHandler,
+    },
+    "terminal.stop": {
+        inputSchema: ActionContractsZ["terminal.stop"].input,
+        resultSchema: ActionContractsZ["terminal.stop"].result,
+        handler: terminalStopHandler,
+    },
+    "config.set": {
+        inputSchema: ActionContractsZ["config.set"].input,
+        resultSchema: ActionContractsZ["config.set"].result,
+        handler: configSetHandler,
+    },
+    "config.addPane": {
+        inputSchema: ActionContractsZ["config.addPane"].input,
+        resultSchema: ActionContractsZ["config.addPane"].result,
+        handler: configAddPaneHandler,
+    },
+    "config.removePane": {
+        inputSchema: ActionContractsZ["config.removePane"].input,
+        resultSchema: ActionContractsZ["config.removePane"].result,
+        handler: configRemovePaneHandler,
+    },
+    "config.addRow": {
+        inputSchema: ActionContractsZ["config.addRow"].input,
+        resultSchema: ActionContractsZ["config.addRow"].result,
+        handler: configAddRowHandler,
+    },
+    "config.enableTeam": {
+        inputSchema: ActionContractsZ["config.enableTeam"].input,
+        resultSchema: ActionContractsZ["config.enableTeam"].result,
+        handler: configEnableTeamHandler,
+    },
+    "config.disableTeam": {
+        inputSchema: ActionContractsZ["config.disableTeam"].input,
+        resultSchema: ActionContractsZ["config.disableTeam"].result,
+        handler: configDisableTeamHandler,
+    },
+    "app.setRemoteAccess": {
+        inputSchema: ActionContractsZ["app.setRemoteAccess"].input,
+        resultSchema: ActionContractsZ["app.setRemoteAccess"].result,
+        handler: appSetRemoteAccessHandler,
+    },
+    "daemon.shutdown": {
+        inputSchema: ActionContractsZ["daemon.shutdown"].input,
+        resultSchema: ActionContractsZ["daemon.shutdown"].result,
+        handler: daemonShutdownHandler,
+    },
+};
+/**
+ * Generic accessor that preserves the `N` type binding. Exposed as a
+ * convenience for tests; the dispatcher uses the registry directly.
+ */
+export function getActionEntry(name) {
+    return actionRegistry[name];
+}
+export function getLooseActionEntry(name) {
+    return actionRegistry[name];
+}

package/packages/daemon/dist/command-center/discovery.d.ts

@@ -0,0 +1,23 @@
+import type { PaneInfo } from "@tmux-ide/contracts";
+export interface SessionInfo {
+    name: string;
+    dir: string;
+    panes: PaneInfo[];
+}
+export interface SessionOverview {
+    name: string;
+    dir: string;
+}
+export interface ProjectDetail {
+    session: string;
+    dir: string;
+    panes: PaneInfo[];
+}
+type TmuxRunner = (args: string[]) => string;
+export declare function _setTmuxRunner(fn: TmuxRunner): () => void;
+export declare function listTmuxSessions(): string[];
+export declare function getSessionCwd(session: string): string;
+export declare function discoverSessions(): SessionInfo[];
+export declare function buildOverviews(sessions: SessionInfo[]): SessionOverview[];
+export declare function buildProjectDetail(info: SessionInfo): ProjectDetail;
+export {};

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

@@ -0,0 +1,67 @@
+import { execFileSync } from "node:child_process";
+import { listSessionPanes } from "../widgets/lib/pane-comms.js";
+import { getDefaultWorkspaceRegistry } from "../lib/workspace-registry.js";
+let _tmuxRunner = (args) => execFileSync("tmux", args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+}).trim();
+export function _setTmuxRunner(fn) {
+    const prev = _tmuxRunner;
+    _tmuxRunner = fn;
+    return () => {
+        _tmuxRunner = prev;
+    };
+}
+function tmuxSilent(args) {
+    try {
+        return _tmuxRunner(args);
+    }
+    catch {
+        return "";
+    }
+}
+export function listTmuxSessions() {
+    const raw = tmuxSilent(["list-sessions", "-F", "#{session_name}"]);
+    if (!raw)
+        return [];
+    return raw.split("\n").filter(Boolean);
+}
+export function getSessionCwd(session) {
+    return tmuxSilent(["display-message", "-t", session, "-p", "#{pane_current_path}"]);
+}
+export function discoverSessions() {
+    const sessionNames = listTmuxSessions();
+    const results = [];
+    // Once the workspace registry is loaded (post daemon-embed startup),
+    // discovery is gated by registry membership: only registered workspaces
+    // are visible. Pre-load (e.g. unit tests that bypass daemon-embed) we
+    // fall through to the legacy "any tmux session with a cwd" behavior.
+    const registry = getDefaultWorkspaceRegistry();
+    const enforceRegistry = registry._isLoaded();
+    for (const name of sessionNames) {
+        if (enforceRegistry && !registry.has(name))
+            continue;
+        const dir = getSessionCwd(name);
+        if (!dir)
+            continue;
+        let panes = [];
+        try {
+            panes = listSessionPanes(name);
+        }
+        catch {
+            // session may have vanished
+        }
+        results.push({ name, dir, panes });
+    }
+    return results;
+}
+export function buildOverviews(sessions) {
+    return sessions.map((s) => ({ name: s.name, dir: s.dir }));
+}
+export function buildProjectDetail(info) {
+    return {
+        session: info.name,
+        dir: info.dir,
+        panes: info.panes,
+    };
+}