tmux-ide 2.1.4 → 2.6.0

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

@@ -0,0 +1,12 @@
+import { basename } from "node:path";
+import { getSessionName } from "../../../lib/yaml-io.js";
+import { resolveProject } from "./_resolve-project.js";
+export function resolveProjectContext(input, deps = {}) {
+    if (input.projectName) {
+        const project = resolveProject(input.projectName, deps);
+        return { dir: project.dir, sessionName: project.sessionName };
+    }
+    const dir = deps.cwd ?? process.cwd();
+    const sessionName = getSessionName(dir).name || basename(dir);
+    return { dir, sessionName };
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Shared helper: resolve a registered project by name and project the
+ * fields the action handlers actually consume.
+ *
+ * Lives in handlers/ so the registry stays the only public surface; tests
+ * import from here directly.
+ */
+import type { RegisteredProject } from "../../../schemas/registry.ts";
+export interface ResolvedProject {
+    name: string;
+    dir: string;
+    sessionName: string;
+    /**
+     * `true` when the project was resolved from a live tmux session
+     * (rather than the registry). Useful for handlers that want to
+     * auto-register on first action — out of scope for this slice but
+     * makes the intent explicit at the boundary.
+     */
+    fromLiveSession: boolean;
+}
+export interface ProjectResolverDeps {
+    /** Override for tests — must satisfy the same contract as `getProject`. */
+    getProject?: (name: string) => RegisteredProject | null;
+    /** Override the live-session existence probe. */
+    hasSession?: (session: string) => boolean;
+    /** Override the live-session cwd lookup. */
+    getSessionCwd?: (session: string) => string | null;
+}
+/**
+ * Resolve a project by name. The registry is the canonical source of
+ * truth, but as a fallback we also accept a live tmux session by the
+ * same name — the dashboard merges registered projects + live sessions
+ * in its sidebar, so action handlers must accept either. Throws an
+ * {@link ActionError} with code `project_not_found` when neither path
+ * succeeds.
+ *
+ * Note: the registry does not currently persist a session name distinct
+ * from the project name, so the session name returned here mirrors the
+ * project name. If they diverge in the future, this is the only call site
+ * that needs to change.
+ */
+export declare function resolveProject(name: string, deps?: ProjectResolverDeps): ResolvedProject;

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

@@ -0,0 +1,48 @@
+/**
+ * Shared helper: resolve a registered project by name and project the
+ * fields the action handlers actually consume.
+ *
+ * Lives in handlers/ so the registry stays the only public surface; tests
+ * import from here directly.
+ */
+import { getProject as getRegisteredProject } from "../../../lib/project-registry.js";
+import { getSessionCwd as getSessionCwdDefault, hasSession as hasSessionDefault, } from "@tmux-ide/tmux-bridge";
+import { ActionError } from "../errors.js";
+/**
+ * Resolve a project by name. The registry is the canonical source of
+ * truth, but as a fallback we also accept a live tmux session by the
+ * same name — the dashboard merges registered projects + live sessions
+ * in its sidebar, so action handlers must accept either. Throws an
+ * {@link ActionError} with code `project_not_found` when neither path
+ * succeeds.
+ *
+ * Note: the registry does not currently persist a session name distinct
+ * from the project name, so the session name returned here mirrors the
+ * project name. If they diverge in the future, this is the only call site
+ * that needs to change.
+ */
+export function resolveProject(name, deps = {}) {
+    const lookup = deps.getProject ?? getRegisteredProject;
+    const project = lookup(name);
+    if (project) {
+        return {
+            name: project.name,
+            dir: project.dir,
+            sessionName: project.name,
+            fromLiveSession: false,
+        };
+    }
+    // Registry miss — fall back to a live tmux session of the same name.
+    const hasSession = deps.hasSession ?? hasSessionDefault;
+    if (hasSession(name)) {
+        const cwd = (deps.getSessionCwd ?? getSessionCwdDefault)(name);
+        if (cwd) {
+            return { name, dir: cwd, sessionName: name, fromLiveSession: true };
+        }
+    }
+    throw new ActionError({
+        code: "project_not_found",
+        message: `Project "${name}" not found in registry or as a live tmux session`,
+        details: { name },
+    });
+}

package/packages/daemon/dist/command-center/actions/handlers/app-set-remote-access.d.ts

@@ -0,0 +1,23 @@
+import { type AppSettings } from "../../../lib/app-settings.ts";
+import type { ActionInput, ActionResult } from "../contract.ts";
+export interface RemoteAccessRestartRequest {
+    enabled: boolean;
+    bindHostname: "0.0.0.0" | "127.0.0.1";
+    token: string | null;
+    port?: number;
+}
+export interface RemoteAccessRestartResult {
+    port?: number;
+    host?: string;
+}
+export interface AppSetRemoteAccessDeps {
+    readSettings?: () => AppSettings;
+    writeSettings?: (next: AppSettings) => void;
+    generateToken?: () => string;
+    restartDaemon?: (request: RemoteAccessRestartRequest) => Promise<RemoteAccessRestartResult> | RemoteAccessRestartResult;
+    deferRestart?: (restart: () => void) => void;
+    port?: number;
+    host?: string;
+}
+export declare function setRemoteAccessRestartBackend(backend: ((request: RemoteAccessRestartRequest) => Promise<RemoteAccessRestartResult> | RemoteAccessRestartResult) | null): void;
+export declare function appSetRemoteAccessHandler(input: ActionInput<"app.setRemoteAccess">, deps?: AppSetRemoteAccessDeps): Promise<ActionResult<"app.setRemoteAccess">>;

package/packages/daemon/dist/command-center/actions/handlers/app-set-remote-access.js

@@ -0,0 +1,67 @@
+import { hostname, networkInterfaces } from "node:os";
+import { generateAuthToken } from "../../../lib/auth-token.js";
+import { readAppSettings, writeAppSettings } from "../../../lib/app-settings.js";
+let remoteAccessRestartBackend = null;
+export function setRemoteAccessRestartBackend(backend) {
+    remoteAccessRestartBackend = backend;
+}
+function currentPort(deps) {
+    const envPort = Number(process.env.TMUX_IDE_DAEMON_PORT);
+    return deps.port ?? (Number.isInteger(envPort) && envPort > 0 ? envPort : 6060);
+}
+function primaryLanHost() {
+    const interfaces = networkInterfaces();
+    for (const entries of Object.values(interfaces)) {
+        for (const entry of entries ?? []) {
+            if (entry.family === "IPv4" && !entry.internal)
+                return entry.address;
+        }
+    }
+    return hostname();
+}
+function buildUrl(host, port) {
+    return `http://${host}:${port}`;
+}
+function defaultDeferRestart(restart) {
+    setImmediate(restart);
+}
+export async function appSetRemoteAccessHandler(input, deps = {}) {
+    const readSettings = deps.readSettings ?? readAppSettings;
+    const writeSettings = deps.writeSettings ?? writeAppSettings;
+    const nextEnabled = input.enabled;
+    const current = readSettings();
+    const token = nextEnabled
+        ? (current.remoteAccess.token ?? (deps.generateToken ?? generateAuthToken)())
+        : null;
+    const next = {
+        ...current,
+        remoteAccess: { enabled: nextEnabled, token },
+    };
+    writeSettings(next);
+    const port = currentPort(deps);
+    const request = {
+        enabled: nextEnabled,
+        bindHostname: nextEnabled ? "0.0.0.0" : "127.0.0.1",
+        token,
+        port,
+    };
+    const restartDaemon = deps.restartDaemon ?? remoteAccessRestartBackend;
+    if (restartDaemon) {
+        (deps.deferRestart ?? defaultDeferRestart)(() => {
+            void Promise.resolve(restartDaemon(request)).catch((err) => {
+                console.error(`[actions] Failed to restart daemon for remote access: ${err.message ?? String(err)}`);
+            });
+        });
+    }
+    if (!nextEnabled) {
+        return { enabled: false, url: null, token: null, qrPayload: null };
+    }
+    const host = deps.host ?? primaryLanHost();
+    const url = buildUrl(host, port);
+    return {
+        enabled: true,
+        url,
+        token,
+        qrPayload: `${url}?token=${encodeURIComponent(token ?? "")}`,
+    };
+}

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

@@ -0,0 +1,12 @@
+import type { ActionInput, ActionResult } from "../contract.ts";
+import { type ProjectContextDeps } from "./_project-context.ts";
+interface ConfigActionDeps extends ProjectContextDeps {
+    broadcastConfigChanged?: (sessionName: string) => void;
+}
+export declare function configSetHandler(input: ActionInput<"config.set">, deps?: ConfigActionDeps): ActionResult<"config.set">;
+export declare function configAddPaneHandler(input: ActionInput<"config.addPane">, deps?: ConfigActionDeps): ActionResult<"config.addPane">;
+export declare function configRemovePaneHandler(input: ActionInput<"config.removePane">, deps?: ConfigActionDeps): ActionResult<"config.removePane">;
+export declare function configAddRowHandler(input: ActionInput<"config.addRow">, deps?: ConfigActionDeps): ActionResult<"config.addRow">;
+export declare function configEnableTeamHandler(input: ActionInput<"config.enableTeam">, deps?: ConfigActionDeps): ActionResult<"config.enableTeam">;
+export declare function configDisableTeamHandler(input: ActionInput<"config.disableTeam">, deps?: ConfigActionDeps): ActionResult<"config.disableTeam">;
+export {};

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

@@ -0,0 +1,69 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { configAddPane, configAddRow, configDisableTeam, configEnableTeam, configRemovePane, configSetValue, } from "../../../config.js";
+import { broadcastConfigChanged as broadcastConfigChangedDefault } from "../../ws-events.js";
+import { ActionError } from "../errors.js";
+import { resolveProjectContext } from "./_project-context.js";
+function mutateConfigAction(input, deps, fn) {
+    const context = resolveProjectContext(input, deps);
+    if (!existsSync(join(context.dir, "ide.yml"))) {
+        throw new ActionError({
+            code: "ide_yml_missing",
+            message: "ide.yml was not found",
+            details: { dir: context.dir },
+        });
+    }
+    try {
+        const result = fn(context.dir);
+        (deps.broadcastConfigChanged ?? broadcastConfigChangedDefault)(context.sessionName);
+        return result;
+    }
+    catch (err) {
+        const message = err.message ?? String(err);
+        throw new ActionError({
+            code: message.toLowerCase().includes("path")
+                ? "config_path_invalid"
+                : "config_validation_failed",
+            message,
+            cause: err,
+        });
+    }
+}
+export function configSetHandler(input, deps = {}) {
+    const config = mutateConfigAction(input, deps, (dir) => configSetValue(dir, input.path, input.value));
+    return { config };
+}
+export function configAddPaneHandler(input, deps = {}) {
+    const pane = {
+        title: input.title,
+        command: input.command,
+        type: input.type,
+        target: input.target,
+        dir: input.dir,
+        size: input.size,
+        focus: input.focus,
+        env: input.env,
+        role: input.role,
+        task: input.task,
+        specialty: input.specialty,
+        skill: input.skill,
+    };
+    const config = mutateConfigAction(input, deps, (dir) => configAddPane(dir, input.rowIndex, pane));
+    return { config };
+}
+export function configRemovePaneHandler(input, deps = {}) {
+    const config = mutateConfigAction(input, deps, (dir) => configRemovePane(dir, input.rowIndex, input.paneIndex)).config;
+    return { config };
+}
+export function configAddRowHandler(input, deps = {}) {
+    const config = mutateConfigAction(input, deps, (dir) => configAddRow(dir, input.size));
+    return { config };
+}
+export function configEnableTeamHandler(input, deps = {}) {
+    const config = mutateConfigAction(input, deps, (dir) => configEnableTeam(dir, input.name));
+    return { config };
+}
+export function configDisableTeamHandler(input, deps = {}) {
+    const config = mutateConfigAction(input, deps, (dir) => configDisableTeam(dir));
+    return { config };
+}

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

@@ -0,0 +1,6 @@
+import type { ActionInput, ActionResult } from "../contract.ts";
+export interface DaemonShutdownDeps {
+    shutdown?: (reason: string | null) => Promise<void> | void;
+}
+export declare function setDaemonShutdownBackend(backend: ((reason: string | null) => Promise<void> | void) | null): void;
+export declare function daemonShutdownHandler(input: ActionInput<"daemon.shutdown">, deps?: DaemonShutdownDeps): ActionResult<"daemon.shutdown">;

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

@@ -0,0 +1,24 @@
+import { ActionError } from "../errors.js";
+let shutdownBackend = null;
+let shutdownInProgress = false;
+export function setDaemonShutdownBackend(backend) {
+    shutdownBackend = backend;
+    if (!backend)
+        shutdownInProgress = false;
+}
+export function daemonShutdownHandler(input, deps = {}) {
+    if (shutdownInProgress) {
+        throw new ActionError({
+            code: "shutdown_already_in_progress",
+            message: "Daemon shutdown is already in progress",
+        });
+    }
+    shutdownInProgress = true;
+    const shutdown = deps.shutdown ?? shutdownBackend;
+    process.nextTick(() => {
+        void Promise.resolve(shutdown?.(input.reason ?? null)).catch((err) => {
+            console.error("[daemon] shutdown action failed:", err);
+        });
+    });
+    return { stopping: true };
+}

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

@@ -0,0 +1,7 @@
+import type { ProjectActivationOptions } from "../../../lib/active-projects.ts";
+import type { ActionInput, ActionResult } from "../contract.ts";
+import { type ProjectResolverDeps } from "./_resolve-project.ts";
+export interface ProjectActivateDeps extends ProjectResolverDeps {
+    activateProject?: (name: string, options?: ProjectActivationOptions) => Promise<void>;
+}
+export declare function projectActivateHandler(input: ActionInput<"project.activate">, deps?: ProjectActivateDeps): Promise<ActionResult<"project.activate">>;

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

@@ -0,0 +1,19 @@
+import { activateProject as activateProjectDefault } from "../../../lib/active-projects.js";
+import { ActionError } from "../errors.js";
+import { resolveProject } from "./_resolve-project.js";
+export async function projectActivateHandler(input, deps = {}) {
+    const project = resolveProject(input.name, deps);
+    const activateProject = deps.activateProject ?? activateProjectDefault;
+    try {
+        await activateProject(project.name);
+    }
+    catch (err) {
+        throw new ActionError({
+            code: "internal",
+            message: `Failed to activate project "${project.name}": ${err.message ?? String(err)}`,
+            details: { projectName: project.name },
+            cause: err,
+        });
+    }
+    return { active: true, projectName: project.name };
+}

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

@@ -0,0 +1,18 @@
+/**
+ * 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 { type ActionInput, type ActionResult } from "../contract.ts";
+import { type ProjectResolverDeps } from "./_resolve-project.ts";
+export interface ProjectLaunchDeps extends ProjectResolverDeps {
+    hasSession?: (session: string) => boolean;
+    launch?: (dir: string, options: {
+        json: boolean;
+        attach: boolean;
+    }) => Promise<void>;
+}
+export declare function projectLaunchHandler(input: ActionInput<"project.launch">, deps?: ProjectLaunchDeps): Promise<ActionResult<"project.launch">>;

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">;