tmux-ide 2.1.4 → 2.6.0

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,
+    };
+}

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

@@ -0,0 +1,10 @@
+import { type Server } from "node:http";
+import { AuthService } from "../lib/auth/auth-service.ts";
+import type { AuthConfig } from "../lib/auth/types.ts";
+export interface CommandCenterOptions {
+    port?: number;
+    hostname?: string;
+    authService?: AuthService;
+    authConfig?: AuthConfig;
+}
+export declare function startCommandCenter(options?: CommandCenterOptions): Promise<Server>;

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

@@ -0,0 +1,21 @@
+import { createServer } from "node:http";
+import { getRequestListener } from "@hono/node-server";
+import { createApp } from "./server.js";
+export async function startCommandCenter(options = {}) {
+    const port = options.port ?? 6060;
+    const hostname = options.hostname ?? "0.0.0.0";
+    const appOpts = {};
+    if (options.authService)
+        appOpts.authService = options.authService;
+    if (options.authConfig)
+        appOpts.authConfig = options.authConfig;
+    const app = createApp(appOpts);
+    const listener = getRequestListener(app.fetch);
+    const server = createServer(listener);
+    return new Promise((resolve) => {
+        server.listen(port, hostname, () => {
+            console.log(`Command Center API on http://${hostname}:${port}`);
+            resolve(server);
+        });
+    });
+}

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

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export declare const updateTaskSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        done: "done";
+        todo: "todo";
+        "in-progress": "in-progress";
+        review: "review";
+    }>>;
+    assignee: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const createTaskSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    goal: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const savePlanSchema: z.ZodObject<{
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const savePlanContentSchema: z.ZodObject<{
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const sendCommandSchema: z.ZodObject<{
+    target: z.ZodString;
+    message: z.ZodString;
+    noEnter: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const createMilestoneSchema: z.ZodObject<{
+    title: z.ZodString;
+    sequence: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateMilestoneSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        done: "done";
+        locked: "locked";
+        validating: "validating";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateAssertionSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        pending: "pending";
+        passing: "passing";
+        failing: "failing";
+    }>;
+    evidence: z.ZodOptional<z.ZodString>;
+    verifiedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const triggerResearchSchema: z.ZodObject<{
+    type: z.ZodString;
+}, z.core.$strip>;
+export declare const launchSchema: z.ZodOptional<z.ZodObject<{
+    attach: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export declare const stopSchema: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
+export declare const createSkillSchema: z.ZodObject<{
+    name: z.ZodString;
+    role: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    specialties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    body: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateSkillSchema: z.ZodObject<{
+    role: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    specialties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    body: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

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

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export const updateTaskSchema = z.object({
+    status: z.enum(["todo", "in-progress", "review", "done"]).optional(),
+    assignee: z.string().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    priority: z.number().optional(),
+});
+export const createTaskSchema = z.object({
+    title: z.string().trim().min(1, "Title is required"),
+    description: z.string().optional(),
+    priority: z.number().optional(),
+    goal: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+});
+export const savePlanSchema = z.object({
+    content: z.string().max(1_000_000, "Plan content is too large"),
+});
+export const savePlanContentSchema = z.object({
+    content: z.string().max(1_000_000, "Plan content is too large"),
+});
+export const sendCommandSchema = z.object({
+    target: z.string().min(1, "Target pane is required"),
+    message: z.string().min(1, "Message is required"),
+    noEnter: z.boolean().optional(),
+});
+export const createMilestoneSchema = z.object({
+    title: z.string().trim().min(1, "Title is required"),
+    sequence: z.number().int().positive(),
+    description: z.string().optional(),
+});
+export const updateMilestoneSchema = z.object({
+    status: z.enum(["locked", "active", "done", "validating"]).optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+});
+export const updateAssertionSchema = z.object({
+    status: z.enum(["pending", "passing", "failing", "blocked"]),
+    evidence: z.string().optional(),
+    verifiedBy: z.string().optional(),
+});
+export const triggerResearchSchema = z.object({
+    type: z.string().trim().min(1, "Research type is required"),
+});
+export const launchSchema = z
+    .object({
+    attach: z.boolean().optional(),
+})
+    .optional();
+export const stopSchema = z.object({}).optional();
+const skillNameRegex = /^[A-Za-z0-9._ -]+$/;
+export const createSkillSchema = z.object({
+    name: z
+        .string()
+        .trim()
+        .min(1, "Skill name is required")
+        .regex(skillNameRegex, "Skill name may only contain letters, digits, dot, dash, underscore, or space"),
+    role: z.string().trim().optional(),
+    description: z.string().optional(),
+    specialties: z.array(z.string()).optional(),
+    body: z.string().optional(),
+});
+export const updateSkillSchema = z.object({
+    role: z.string().trim().optional(),
+    description: z.string().optional(),
+    specialties: z.array(z.string()).optional(),
+    body: z.string().optional(),
+});

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

@@ -0,0 +1,26 @@
+import { Hono } from "hono";
+import { AuthService } from "../lib/auth/auth-service.ts";
+import type { AuthConfig } from "../lib/auth/types.ts";
+export interface CreateAppOptions {
+    authService?: AuthService;
+    authConfig?: AuthConfig;
+    remoteAccess?: {
+        bindHostname?: string;
+        token?: string | null;
+        localBypassToken?: string | null;
+    };
+}
+export declare function getSseMetrics(): {
+    connections: number;
+    messagesSent: number;
+};
+export declare function createApp(options?: CreateAppOptions): Hono;
+/**
+ * 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 declare function attachWsEvents(server: import("node:http").Server): {
+    close: () => void;
+};