tmux-ide 2.6.0 → 2.7.0

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

@@ -0,0 +1,38 @@
+/**
+ * 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.ts";
+import { ActionError } from "../errors.ts";
+import { type ActionInput, type ActionResult } from "../contract.ts";
+import { resolveProject, type ProjectResolverDeps } from "./_resolve-project.ts";
+
+export interface ProjectRestartDeps extends ProjectResolverDeps {
+  restart?: (dir: string, options: { json?: boolean; attach?: boolean }) => Promise<void>;
+}
+
+export async function projectRestartHandler(
+  input: ActionInput<"project.restart">,
+  deps: ProjectRestartDeps = {},
+): Promise<ActionResult<"project.restart">> {
+  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 as Error).message ?? String(err)}`,
+      details: { sessionName: project.sessionName, dir: project.dir },
+      cause: err,
+    });
+  }
+
+  return { sessionName: project.sessionName, restarted: true };
+}

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

@@ -0,0 +1,62 @@
+/**
+ * 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.ts";
+import { type ActionInput, type ActionResult } from "../contract.ts";
+import { resolveProject, 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;
+}
+
+function defaultKillOrphanDaemons(_session: string): void {
+  // No-op: per-session daemons are no longer spawned.
+}
+
+export async function projectStopHandler(
+  input: ActionInput<"project.stop">,
+  deps: ProjectStopDeps = {},
+): Promise<ActionResult<"project.stop">> {
+  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 as Error).message ?? String(err)}`,
+      details: { sessionName: project.sessionName },
+      cause: err,
+    });
+  }
+}

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

@@ -0,0 +1,119 @@
+/**
+ * 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,
+  type PtyBridgeLike,
+  type PtyBridgeRegistry,
+} from "../../../server/ws-route.ts";
+import { assertValidCwd, TerminalCwdError } from "../../../server/pty-bridge.ts";
+import type { Stats } from "node:fs";
+import { ActionError, actionErrorFromCwdError } from "../errors.ts";
+import { type ActionInput, type ActionResult } from "../contract.ts";
+
+const DEFAULT_RESPAWN_COLS = 80;
+const DEFAULT_RESPAWN_ROWS = 24;
+
+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 function terminalRespawnHandler(
+  input: ActionInput<"terminal.respawn">,
+  deps: TerminalRespawnDeps = {},
+): ActionResult<"terminal.respawn"> {
+  const registry = deps.registry ?? defaultRegistry;
+  const bridge = registry.peek(input.terminalId) as RespawnCapableBridge | null;
+  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 as Error).message ?? String(err)}`,
+      details: { terminalId: input.terminalId },
+      cause: err,
+    });
+  }
+
+  return { respawned: true, cwd };
+}
+
+interface RespawnCapableBridge extends PtyBridgeLike {
+  cols?: number | null;
+  rows?: number | null;
+}
+
+function resolveRespawnCwd(
+  input: ActionInput<"terminal.respawn">,
+  bridge: RespawnCapableBridge,
+  statCwd?: (cwd: string) => Stats,
+): string {
+  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/src/command-center/actions/handlers/terminal-stop.ts

@@ -0,0 +1,35 @@
+/**
+ * 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,
+  type PtyBridgeRegistry,
+} from "../../../server/ws-route.ts";
+import { ActionError } from "../errors.ts";
+import { type ActionInput, type ActionResult } from "../contract.ts";
+
+export interface TerminalStopDeps {
+  registry?: PtyBridgeRegistry;
+}
+
+export function terminalStopHandler(
+  input: ActionInput<"terminal.stop">,
+  deps: TerminalStopDeps = {},
+): ActionResult<"terminal.stop"> {
+  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/src/command-center/actions/registry.ts

@@ -0,0 +1,149 @@
+/**
+ * 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";
+import { projectOpenTerminalHandler } from "./handlers/project-open-terminal.ts";
+import { projectActivateHandler } from "./handlers/project-activate.ts";
+import { projectLaunchHandler } from "./handlers/project-launch.ts";
+import { projectStopHandler } from "./handlers/project-stop.ts";
+import { projectRestartHandler } from "./handlers/project-restart.ts";
+import { terminalRespawnHandler } from "./handlers/terminal-respawn.ts";
+import { terminalStopHandler } from "./handlers/terminal-stop.ts";
+import {
+  configAddPaneHandler,
+  configAddRowHandler,
+  configDisableTeamHandler,
+  configEnableTeamHandler,
+  configRemovePaneHandler,
+  configSetHandler,
+} from "./handlers/config-actions.ts";
+import { appSetRemoteAccessHandler } from "./handlers/app-set-remote-access.ts";
+import { daemonShutdownHandler } from "./handlers/daemon-shutdown.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 const actionRegistry: RegistryShape = {
+  "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<N extends ActionName>(name: N): ActionRegistryEntry<N> {
+  return actionRegistry[name];
+}
+
+// Re-export the loosely-typed shape used by the dispatcher loop. Casting
+// once here prevents the dispatcher from carrying the conditional type
+// through its run-time logic.
+export type LooseActionEntry = ActionRegistryEntry<ActionName> & {
+  inputSchema: z.ZodTypeAny;
+  resultSchema: z.ZodTypeAny;
+  handler: (input: unknown) => Promise<unknown> | unknown;
+};
+
+export function getLooseActionEntry(name: ActionName): LooseActionEntry {
+  return actionRegistry[name] as unknown as LooseActionEntry;
+}

package/packages/daemon/src/command-center/discovery.ts

@@ -0,0 +1,96 @@
+import { execFileSync } from "node:child_process";
+import { listSessionPanes } from "../widgets/lib/pane-comms.ts";
+import type { PaneInfo } from "@tmux-ide/contracts";
+import { getDefaultWorkspaceRegistry } from "../lib/workspace-registry.ts";
+
+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;
+
+let _tmuxRunner: TmuxRunner = (args) =>
+  execFileSync("tmux", args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+  }).trim();
+
+export function _setTmuxRunner(fn: TmuxRunner): () => void {
+  const prev = _tmuxRunner;
+  _tmuxRunner = fn;
+  return () => {
+    _tmuxRunner = prev;
+  };
+}
+
+function tmuxSilent(args: string[]): string {
+  try {
+    return _tmuxRunner(args);
+  } catch {
+    return "";
+  }
+}
+
+export function listTmuxSessions(): string[] {
+  const raw = tmuxSilent(["list-sessions", "-F", "#{session_name}"]);
+  if (!raw) return [];
+  return raw.split("\n").filter(Boolean);
+}
+
+export function getSessionCwd(session: string): string {
+  return tmuxSilent(["display-message", "-t", session, "-p", "#{pane_current_path}"]);
+}
+
+export function discoverSessions(): SessionInfo[] {
+  const sessionNames = listTmuxSessions();
+  const results: SessionInfo[] = [];
+
+  // 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: PaneInfo[] = [];
+    try {
+      panes = listSessionPanes(name);
+    } catch {
+      // session may have vanished
+    }
+
+    results.push({ name, dir, panes });
+  }
+
+  return results;
+}
+
+export function buildOverviews(sessions: SessionInfo[]): SessionOverview[] {
+  return sessions.map((s) => ({ name: s.name, dir: s.dir }));
+}
+
+export function buildProjectDetail(info: SessionInfo): ProjectDetail {
+  return {
+    session: info.name,
+    dir: info.dir,
+    panes: info.panes,
+  };
+}

package/packages/daemon/src/command-center/index.ts

@@ -0,0 +1,31 @@
+import { createServer, type Server } from "node:http";
+import { getRequestListener } from "@hono/node-server";
+import { createApp, type CreateAppOptions } from "./server.ts";
+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 async function startCommandCenter(options: CommandCenterOptions = {}): Promise<Server> {
+  const port = options.port ?? 6060;
+  const hostname = options.hostname ?? "0.0.0.0";
+  const appOpts: CreateAppOptions = {};
+  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/src/command-center/schemas.ts

@@ -0,0 +1,85 @@
+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(),
+});