tmux-ide 2.1.5 → 2.6.1

package/packages/daemon/src/schemas/registry.ts

@@ -0,0 +1,55 @@
+/**
+ * Project registry contracts. The dashboard manages a list of projects the
+ * user has registered with tmux-ide; this schema is the wire shape exchanged
+ * over `/api/projects` and the `/ws/events` WebSocket channel.
+ *
+ * The shape is FROZEN — the dashboard imports these via `@tmux-ide/schemas`.
+ * Add new fields by appending optional properties; do not rename existing
+ * fields without bumping a major.
+ */
+
+import { z } from "zod";
+
+export const RegisteredProjectSchemaZ = z.object({
+  /** Unique registry key. Defaults to `basename(dir)`; collisions resolved by appending `-2`, `-3`, … */
+  name: z.string(),
+  /** Absolute path to the project directory. */
+  dir: z.string(),
+  /** Whether `<dir>/ide.yml` exists; refreshed on register and on `probe()`. */
+  hasIdeYml: z.boolean(),
+  /** Git remote origin URL, or `null` if not a git repo / no origin / probe failed. */
+  gitOrigin: z.string().nullable(),
+  /** Current git branch, or `null` if not a git repo / detached HEAD / probe failed. */
+  gitBranch: z.string().nullable(),
+  /** ISO-8601 timestamp the project was first registered. */
+  registeredAt: z.string(),
+});
+
+export type RegisteredProject = z.infer<typeof RegisteredProjectSchemaZ>;
+
+// ---------------------------------------------------------------------------
+// REST request bodies
+// ---------------------------------------------------------------------------
+
+export const RegisterProjectRequestSchemaZ = z.object({
+  dir: z.string().min(1),
+  name: z.string().min(1).optional(),
+});
+export type RegisterProjectRequest = z.infer<typeof RegisterProjectRequestSchemaZ>;
+
+export const InitProjectRequestSchemaZ = z.object({
+  dir: z.string().min(1),
+  template: z.string().min(1).optional(),
+});
+export type InitProjectRequest = z.infer<typeof InitProjectRequestSchemaZ>;
+
+// ---------------------------------------------------------------------------
+// Template metadata (returned by GET /api/projects/templates)
+// ---------------------------------------------------------------------------
+
+export const ProjectTemplateSchemaZ = z.object({
+  id: z.string(),
+  label: z.string(),
+  description: z.string(),
+});
+export type ProjectTemplate = z.infer<typeof ProjectTemplateSchemaZ>;

package/packages/daemon/src/schemas/ws-events.ts

@@ -0,0 +1,135 @@
+/**
+ * Protocol contracts for the unified `/ws/events` WebSocket channel.
+ *
+ * Single push channel clients subscribe to for session / pane / workspace
+ * changes. One socket replaces a fan of individual SSE streams that hit
+ * Chrome's 6-per-origin HTTP/1.1 limit.
+ *
+ * Add new frame variants by appending to the union; do not rename existing
+ * fields.
+ */
+
+import { z } from "zod";
+import { SessionOverviewSchemaZ } from "./domain.ts";
+import { WorkspaceAddedFrameSchemaZ, WorkspaceRemovedFrameSchemaZ } from "@tmux-ide/contracts";
+
+// ---------------------------------------------------------------------------
+// Snapshot payload — mirrors what `/api/project/<name>/stream` already pushes
+// as its `snapshot` SSE event. Kept loose (passthrough) so that adding fields
+// on the producer side does not require shipping schema updates lock-step
+// with consumers. Consumers should validate fields they actually read.
+// ---------------------------------------------------------------------------
+
+export const SessionSnapshotSchemaZ = z.record(z.string(), z.unknown());
+export type SessionSnapshot = z.infer<typeof SessionSnapshotSchemaZ>;
+
+// ---------------------------------------------------------------------------
+// Client → Server frames
+// ---------------------------------------------------------------------------
+
+const SubscribeFrameZ = z.object({
+  type: z.literal("subscribe"),
+  sessions: z.array(z.string()),
+});
+
+const UnsubscribeFrameZ = z.object({
+  type: z.literal("unsubscribe"),
+  sessions: z.array(z.string()),
+});
+
+const PingFrameZ = z.object({
+  type: z.literal("ping"),
+});
+
+export const ClientFrameSchemaZ = z.discriminatedUnion("type", [
+  SubscribeFrameZ,
+  UnsubscribeFrameZ,
+  PingFrameZ,
+]);
+
+export type ClientFrame = z.infer<typeof ClientFrameSchemaZ>;
+
+// ---------------------------------------------------------------------------
+// Server → Client frames
+// ---------------------------------------------------------------------------
+
+const HelloFrameZ = z.object({
+  type: z.literal("hello"),
+  sessions: z.array(SessionOverviewSchemaZ),
+});
+
+const SnapshotFrameZ = z.object({
+  type: z.literal("snapshot"),
+  sessionName: z.string(),
+  data: SessionSnapshotSchemaZ,
+});
+
+const SessionsChangedFrameZ = z.object({
+  type: z.literal("sessions.changed"),
+});
+
+// Project-registry has changed (register / unregister / re-probe / init success).
+// Clients re-fetch GET /api/projects.
+const ProjectsChangedFrameZ = z.object({
+  type: z.literal("projects.changed"),
+});
+
+// Streaming output from `tmux-ide init` invoked via POST /api/projects/init.
+// `chunk` is a single line of stdout/stderr (newline stripped). `done: true`
+// is set on the final frame for the job; no more `init.output` frames will
+// follow for this jobId.
+const InitOutputFrameZ = z.object({
+  type: z.literal("init.output"),
+  jobId: z.string(),
+  chunk: z.string(),
+  done: z.boolean().optional(),
+});
+
+// Init job failed. Terminal — no `init.output` follow-ups.
+const InitErrorFrameZ = z.object({
+  type: z.literal("init.error"),
+  jobId: z.string(),
+  message: z.string(),
+});
+
+const PongFrameZ = z.object({
+  type: z.literal("pong"),
+});
+
+// Broadcast after a successful v2 action dispatch. Clients use these frames to
+// invalidate caches without ad-hoc refetches (e.g. invalidate the project list
+// after `project.launch` succeeds). `name` matches the action name in
+// `command-center/actions/contract.ts`. `result` is loose at the schema layer
+// because each action has its own result shape.
+const ActionCompleteFrameZ = z.object({
+  type: z.literal("action.complete"),
+  name: z.string(),
+  result: z.unknown(),
+});
+
+const ConfigChangedFrameZ = z.object({
+  type: z.literal("config.changed"),
+  sessionName: z.string(),
+});
+
+const TerminalsChangedFrameZ = z.object({
+  type: z.literal("terminals.changed"),
+  sessionName: z.string(),
+});
+
+export const ServerFrameSchemaZ = z.discriminatedUnion("type", [
+  HelloFrameZ,
+  SnapshotFrameZ,
+  SessionsChangedFrameZ,
+  ProjectsChangedFrameZ,
+  InitOutputFrameZ,
+  InitErrorFrameZ,
+  PongFrameZ,
+  ActionCompleteFrameZ,
+  ConfigChangedFrameZ,
+  TerminalsChangedFrameZ,
+  WorkspaceAddedFrameSchemaZ,
+  WorkspaceRemovedFrameSchemaZ,
+]);
+
+export type ServerFrame = z.infer<typeof ServerFrameSchemaZ>;

package/packages/daemon/src/send.ts

@@ -0,0 +1,171 @@
+import { randomUUID } from "node:crypto";
+import { resolve, join } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { getSessionName } from "./lib/yaml-io.ts";
+import { getSessionState } from "@tmux-ide/tmux-bridge";
+import {
+  listSessionPanes,
+  sendCommand,
+  sendText,
+  getPaneBusyStatus,
+  type PaneInfo,
+  type PaneBusyStatus,
+} from "./widgets/lib/pane-comms.ts";
+import { IdeError } from "./lib/errors.ts";
+
+export const LONG_MESSAGE_THRESHOLD = 150;
+
+/**
+ * Write a long message to a dispatch file and return the short trigger command.
+ * Returns null if message is short enough to send directly.
+ */
+export function writeDispatchFile(
+  dir: string,
+  paneId: string,
+  message: string,
+): { filePath: string; triggerCmd: string } | null {
+  if (message.length <= LONG_MESSAGE_THRESHOLD) return null;
+  const dispatchDir = join(dir, ".tasks", "dispatch");
+  if (!existsSync(dispatchDir)) mkdirSync(dispatchDir, { recursive: true });
+  const paneSlug = paneId.replace("%", "");
+  const filename = `send-${paneSlug}-${Date.now()}-${randomUUID().slice(0, 8)}.md`;
+  const filePath = join(dispatchDir, filename);
+  writeFileSync(filePath, message);
+  return { filePath, triggerCmd: `Read and execute: .tasks/dispatch/${filename}` };
+}
+
+interface SendOptions {
+  json?: boolean;
+  to?: string;
+  message?: string;
+  noEnter?: boolean;
+}
+
+/**
+ * Resolve a target string to a pane. Priority:
+ * 1. Exact pane ID (%N)
+ * 2. @ide_name match
+ * 3. Exact title match
+ * 4. Role match (lead, teammate, planner)
+ * 5. Case-insensitive partial title match
+ */
+export function resolvePane(panes: PaneInfo[], target: string): PaneInfo | null {
+  // 1. Exact pane ID
+  if (target.startsWith("%")) {
+    return panes.find((p) => p.id === target) ?? null;
+  }
+
+  // 2. @ide_name match
+  const byName = panes.find((p) => p.name === target);
+  if (byName) return byName;
+
+  // 3. Exact title match
+  const byTitle = panes.find((p) => p.title === target);
+  if (byTitle) return byTitle;
+
+  // 4. Role match
+  const lower = target.toLowerCase();
+  if (["lead", "teammate", "planner"].includes(lower)) {
+    const byRole = panes.find((p) => p.role === lower);
+    if (byRole) return byRole;
+  }
+
+  // 5. Case-insensitive partial title match
+  const byPattern = panes.find((p) => p.title.toLowerCase().includes(lower));
+  if (byPattern) return byPattern;
+
+  return null;
+}
+
+function prepareMessage(message: string, busyStatus: PaneBusyStatus): string {
+  if (busyStatus === "agent") {
+    // Collapse multiline to single line for Claude Code TUI
+    // Prevents paste preview that requires manual Enter
+    return message.replace(/\n+/g, " ").trim();
+  }
+  return message;
+}
+
+export async function send(targetDir: string | undefined, opts: SendOptions): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { name: session } = getSessionName(dir);
+  const { json, to: target, message: rawMessage, noEnter } = opts;
+
+  if (!target) {
+    throw new IdeError("Missing target. Usage: tmux-ide send <target> <message>", {
+      code: "USAGE",
+    });
+  }
+
+  if (!rawMessage) {
+    throw new IdeError("Missing message. Usage: tmux-ide send <target> <message>", {
+      code: "USAGE",
+    });
+  }
+
+  // Verify session is running
+  const state = getSessionState(session);
+  if (!state.running) {
+    throw new IdeError(`Session "${session}" is not running`, {
+      code: "SESSION_NOT_FOUND",
+    });
+  }
+
+  const panes = listSessionPanes(session);
+  const pane = resolvePane(panes, target);
+  if (!pane) {
+    const available = panes
+      .map((p) => {
+        const label = p.name ?? p.title;
+        return `  ${p.id}  ${label}${p.role ? ` (${p.role})` : ""}`;
+      })
+      .join("\n");
+    throw new IdeError(`Pane "${target}" not found.\n\nAvailable panes:\n${available}`, {
+      code: "PANE_NOT_FOUND",
+    });
+  }
+
+  const busyStatus = getPaneBusyStatus(session, pane.id);
+  const message = prepareMessage(rawMessage, busyStatus);
+
+  let sentViaFile = false;
+  if (noEnter) {
+    sendText(session, pane.id, message);
+  } else {
+    const dispatch = writeDispatchFile(dir, pane.id, message);
+    if (dispatch) {
+      sendCommand(session, pane.id, dispatch.triggerCmd);
+      sentViaFile = true;
+    } else {
+      sendCommand(session, pane.id, message);
+    }
+  }
+
+  const result = {
+    ok: true,
+    session,
+    target: {
+      paneId: pane.id,
+      name: pane.name,
+      title: pane.title,
+      role: pane.role,
+    },
+    message,
+    busyStatus,
+    sentViaFile,
+    ...(busyStatus === "agent" ? { warning: "agent_busy" } : {}),
+  };
+
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  const label = pane.name ?? pane.title;
+  const preview = message.length > 60 ? message.slice(0, 60) + "..." : message;
+  console.log(`Sent to "${label}" (${pane.id}): ${preview}`);
+
+  if (busyStatus === "agent") {
+    console.log("Warning: agent appears busy. Message sent anyway.");
+  }
+}

package/packages/daemon/src/server/README.md

@@ -0,0 +1,15 @@
+# src/server/
+
+v2.5.0 unified server. Single-binary HTTP + WS surface.
+
+Slice 1 scope: WebSocket PTY bridge endpoint at `/ws/pty/:id`. Spawns a shell via node-pty, bridges to wterm in the browser.
+
+See `plans/v2.5.0-protocol.md` for the wire protocol.
+See `plans/v2.5.0-architecture.md` for the v2.5.0 design.
+
+## Files (slice 1)
+
+- `index.ts` — Hono app, server bootstrap (`tmux-ide server` entry point)
+- `pty-bridge.ts` — node-pty bridge: spawn, write, resize, lifecycle, cleanup
+- `ws-route.ts` — WebSocket route handler implementing the protocol
+- `*.test.ts` — Vitest unit tests

package/packages/daemon/src/server/index.ts

@@ -0,0 +1,74 @@
+import { createServer, type Server } from "node:http";
+import { parse } from "node:url";
+import { Hono } from "hono";
+import { getRequestListener } from "@hono/node-server";
+import { WebSocketServer } from "ws";
+import { handlePtyWebSocket, shutdownPtyBridges } from "./ws-route.ts";
+
+const DEFAULT_PORT = 6070;
+
+export interface StartedTmuxIdeServer {
+  port: number;
+  server: Server;
+  close(): Promise<void>;
+}
+
+export function resolvePort(port?: number): number {
+  const raw = port ?? Number.parseInt(process.env.TMUX_IDE_PORT ?? String(DEFAULT_PORT), 10);
+  if (!Number.isInteger(raw) || raw <= 0) {
+    throw new Error(`Invalid server port: ${String(port ?? process.env.TMUX_IDE_PORT)}`);
+  }
+  return raw;
+}
+
+export function createApp(): Hono {
+  const app = new Hono();
+
+  app.get("/", (c) => c.text("tmux-ide server"));
+  app.get("/health", (c) => c.json({ ok: true }));
+
+  return app;
+}
+
+export async function start(port?: number): Promise<StartedTmuxIdeServer> {
+  const resolvedPort = resolvePort(port);
+  const app = createApp();
+  const server = createServer(getRequestListener(app.fetch));
+  const ptyWss = new WebSocketServer({ noServer: true });
+
+  server.on("upgrade", (req, socket, head) => {
+    const { pathname } = parse(req.url ?? "/", true);
+    const match = pathname?.match(/^\/ws\/pty\/([^/]+)$/);
+
+    if (!match) {
+      socket.destroy();
+      return;
+    }
+
+    const id = decodeURIComponent(match[1] ?? "");
+    ptyWss.handleUpgrade(req, socket, head, (ws) => {
+      handlePtyWebSocket(ws, id);
+    });
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(resolvedPort, "0.0.0.0", () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+
+  console.log(`tmux-ide server listening on http://0.0.0.0:${resolvedPort}`);
+
+  return {
+    port: resolvedPort,
+    server,
+    close: () =>
+      new Promise<void>((resolve, reject) => {
+        shutdownPtyBridges();
+        ptyWss.close();
+        server.close((err) => (err ? reject(err) : resolve()));
+      }),
+  };
+}