tmux-ide 2.6.0 → 2.6.1

package/packages/daemon/src/lib/log.ts

@@ -0,0 +1,134 @@
+/** Minimal structured logger for tmux-ide daemon processes. */
+
+type Level = "debug" | "info" | "warn" | "error";
+
+const LEVEL_RANK: Record<Level, number> = { debug: 0, info: 1, warn: 2, error: 3 };
+
+let minLevel: Level = (process.env.LOG_LEVEL as Level) ?? "info";
+
+export function setLogLevel(level: Level): void {
+  minLevel = level;
+}
+
+// ---------------------------------------------------------------------------
+// Ring buffer + subscriber bus
+//
+// Every structured log entry is also captured in an in-memory ring (last
+// `LOG_BUFFER_SIZE` entries) and broadcast to any subscriber. Used by the
+// command-center's `/api/logs/:channel` SSE endpoint so the dashboard
+// BottomPanel Output tab can stream daemon logs without scraping stderr.
+// ---------------------------------------------------------------------------
+
+export interface LogEntry {
+  ts: string;
+  level: Level;
+  component: string;
+  msg: string;
+  data?: Record<string, unknown>;
+}
+
+const LOG_BUFFER_SIZE = 1_000;
+const logBuffer: LogEntry[] = [];
+type Subscriber = (entry: LogEntry) => void;
+const subscribers = new Set<Subscriber>();
+
+/** Snapshot the current ring buffer; useful for SSE backfill. */
+export function getLogBuffer(): ReadonlyArray<LogEntry> {
+  return logBuffer.slice();
+}
+
+/**
+ * Subscribe to live log entries. Returns an unsubscribe function. The
+ * handler runs synchronously inside the writer — keep it cheap; throw
+ * inside the handler is caught + logged once so one bad subscriber
+ * can't stall the daemon.
+ */
+export function subscribeLogs(handler: Subscriber): () => void {
+  subscribers.add(handler);
+  return () => {
+    subscribers.delete(handler);
+  };
+}
+
+function writeStructuredLog(
+  level: Level,
+  component: string,
+  message: string,
+  data?: Record<string, unknown>,
+): void {
+  if (LEVEL_RANK[level] < LEVEL_RANK[minLevel]) return;
+  const entry: LogEntry = {
+    ts: new Date().toISOString(),
+    level,
+    component,
+    msg: message,
+    ...(data ? { data } : {}),
+  };
+  // Push to ring + drop oldest when over budget.
+  logBuffer.push(entry);
+  if (logBuffer.length > LOG_BUFFER_SIZE) logBuffer.shift();
+  // Fan out to subscribers; isolate failures.
+  for (const sub of subscribers) {
+    try {
+      sub(entry);
+    } catch (err) {
+      // Avoid recursion via the logger; write directly to stderr.
+      process.stderr.write(
+        `[log.ts] subscriber threw: ${err instanceof Error ? err.message : String(err)}\n`,
+      );
+    }
+  }
+  // Stream form for humans tailing the process. The data field is
+  // serialized inline (matches the previous wire shape).
+  const wire: Record<string, unknown> = {
+    ts: entry.ts,
+    level: entry.level,
+    component: entry.component,
+    msg: entry.msg,
+  };
+  if (data) Object.assign(wire, data);
+  const out = level === "error" ? process.stderr : process.stdout;
+  out.write(JSON.stringify(wire) + "\n");
+}
+
+export const logger = {
+  debug: (component: string, msg: string, data?: Record<string, unknown>) =>
+    writeStructuredLog("debug", component, msg, data),
+  info: (component: string, msg: string, data?: Record<string, unknown>) =>
+    writeStructuredLog("info", component, msg, data),
+  warn: (component: string, msg: string, data?: Record<string, unknown>) =>
+    writeStructuredLog("warn", component, msg, data),
+  error: (component: string, msg: string, data?: Record<string, unknown>) =>
+    writeStructuredLog("error", component, msg, data),
+};
+
+/**
+ * Thin logger shim compatible with VibeTunnel's module logger API (`createLogger`-style methods).
+ * Wraps `console.*` (distinct from structured JSON `logger` above).
+ */
+export type LogMethod = (...args: unknown[]) => void;
+
+export const log = {
+  /** Alias for `info` / console.log (VibeTunnel `createLogger` compatibility). */
+  log: (...args: unknown[]) => {
+    console.log(...args);
+  },
+  info: (...args: unknown[]) => {
+    console.log(...args);
+  },
+  warn: (...args: unknown[]) => {
+    console.warn(...args);
+  },
+  error: (...args: unknown[]) => {
+    console.error(...args);
+  },
+  debug: (...args: unknown[]) => {
+    console.debug(...args);
+  },
+} satisfies {
+  log: LogMethod;
+  info: LogMethod;
+  warn: LogMethod;
+  error: LogMethod;
+  debug: LogMethod;
+};

package/packages/daemon/src/lib/output.ts

@@ -0,0 +1,76 @@
+import { IdeError, TmuxError } from "./errors.ts";
+import type { IdeConfig } from "../types.ts";
+
+export function printLayout(config: IdeConfig): void {
+  const INNER = 40;
+  const rows = config.rows ?? [];
+  if (rows.length === 0) return;
+
+  for (let r = 0; r < rows.length; r++) {
+    const panes = rows[r]!.panes ?? [];
+    const count = panes.length || 1;
+    const widths: number[] = [];
+    let remaining = INNER;
+    for (let i = 0; i < count; i++) {
+      const w = i < count - 1 ? Math.floor(INNER / count) : remaining;
+      widths.push(w);
+      remaining -= w;
+    }
+
+    // Top border or mid divider
+    if (r === 0) {
+      let top = "  \u250c";
+      for (let i = 0; i < count; i++) {
+        top += "\u2500".repeat(widths[i]!);
+        top += i < count - 1 ? "\u252c" : "\u2510";
+      }
+      console.log(top);
+    } else {
+      console.log("  \u251c" + "\u2500".repeat(INNER + count - 1) + "\u2524");
+    }
+
+    // Content line
+    const sizeLabel = rows[r]!.size ?? "";
+    let line = "  \u2502";
+    for (let i = 0; i < count; i++) {
+      const title = panes[i]?.title ?? "";
+      const w = widths[i]!;
+      const pad = Math.max(0, w - title.length);
+      const left = Math.floor(pad / 2);
+      const right = pad - left;
+      line += " ".repeat(left) + title + " ".repeat(right) + "\u2502";
+    }
+    if (sizeLabel) line += "  " + sizeLabel;
+    console.log(line);
+
+    // Bottom border (last row only)
+    if (r === rows.length - 1) {
+      let bot = "  \u2514";
+      for (let i = 0; i < count; i++) {
+        bot += "\u2500".repeat(widths[i]!);
+        bot += i < count - 1 ? "\u2534" : "\u2518";
+      }
+      console.log(bot);
+    }
+  }
+}
+
+export function outputError(
+  message: string,
+  code: string,
+  { exitCode = 1 }: { exitCode?: number } = {},
+): never {
+  throw new IdeError(message, { code, exitCode });
+}
+
+export function printCommandError(
+  error: IdeError | TmuxError,
+  { json = false }: { json?: boolean } = {},
+): never {
+  if (json) {
+    console.error(JSON.stringify(error.toJSON(), null, 2));
+  } else {
+    console.error(error.message);
+  }
+  process.exit(error.exitCode ?? 1);
+}

package/packages/daemon/src/lib/project-init-runner.ts

@@ -0,0 +1,150 @@
+/**
+ * Run `tmux-ide init [--template <id>]` in a target directory and stream the
+ * output line-by-line. Used by `POST /api/projects/init` so the dashboard can
+ * scaffold new projects from the UI.
+ *
+ * The spawn helper is pluggable so tests can drive the runner without
+ * actually shelling out.
+ */
+
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+/**
+ * The minimal contract of `child_process.spawn` we depend on. Tests pass in
+ * a synthetic implementation that emits lines deterministically.
+ */
+export type SpawnFn = (
+  command: string,
+  args: string[],
+  options: { cwd: string },
+) => ChildProcessWithoutNullStreams;
+
+export interface InitRunnerOptions {
+  template?: string;
+  cwd: string;
+  onChunk: (chunk: string) => void;
+  /** Override for tests. */
+  spawnFn?: SpawnFn;
+  /** Defaults to 30s. */
+  timeoutMs?: number;
+  /** The binary to run. Defaults to `tmux-ide`; tests pin to a no-op. */
+  command?: string;
+}
+
+export class ProjectInitTimeoutError extends Error {
+  readonly timeoutMs: number;
+  constructor(timeoutMs: number) {
+    super(`tmux-ide init timed out after ${timeoutMs}ms`);
+    this.name = "ProjectInitTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+export class ProjectInitFailedError extends Error {
+  readonly exitCode: number | null;
+  readonly stderr: string;
+  constructor(exitCode: number | null, stderr: string) {
+    super(`tmux-ide init exited with code ${exitCode ?? "(killed)"}: ${stderr || "no stderr"}`);
+    this.name = "ProjectInitFailedError";
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+  }
+}
+
+/**
+ * Buffer stream chunks into newline-delimited lines, emit each line through
+ * `onChunk`. Returns a `flush()` to drain any trailing partial line on close.
+ */
+function lineStreamer(onChunk: (chunk: string) => void): {
+  push: (text: string) => void;
+  flush: () => void;
+} {
+  let pending = "";
+  return {
+    push(text: string): void {
+      pending += text;
+      let newline = pending.indexOf("\n");
+      while (newline >= 0) {
+        const line = pending.slice(0, newline).replace(/\r$/, "");
+        pending = pending.slice(newline + 1);
+        onChunk(line);
+        newline = pending.indexOf("\n");
+      }
+    },
+    flush(): void {
+      if (pending.length === 0) return;
+      onChunk(pending.replace(/\r$/, ""));
+      pending = "";
+    },
+  };
+}
+
+/**
+ * Spawn `tmux-ide init` and resolve when it exits. Streams stdout+stderr
+ * through `onChunk` line-by-line so callers can fan them out over WebSocket.
+ *
+ * Resolves with `{ ok: true }` on exit code 0, rejects with
+ * `ProjectInitFailedError` (non-zero) or `ProjectInitTimeoutError` (>30s).
+ */
+export async function runInit(options: InitRunnerOptions): Promise<{ ok: true }> {
+  const spawnFn = options.spawnFn ?? (spawn as unknown as SpawnFn);
+  const command = options.command ?? "tmux-ide";
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const args = ["init"];
+  if (options.template) args.push("--template", options.template);
+
+  const child = spawnFn(command, args, { cwd: options.cwd });
+  const stderrStreamer = lineStreamer(options.onChunk);
+  const stdoutStreamer = lineStreamer(options.onChunk);
+  let stderrBuffer = "";
+
+  child.stdout.setEncoding?.("utf-8");
+  child.stderr.setEncoding?.("utf-8");
+
+  child.stdout.on("data", (data: string | Buffer) => {
+    stdoutStreamer.push(typeof data === "string" ? data : data.toString("utf-8"));
+  });
+  child.stderr.on("data", (data: string | Buffer) => {
+    const text = typeof data === "string" ? data : data.toString("utf-8");
+    stderrBuffer += text;
+    stderrStreamer.push(text);
+  });
+
+  return new Promise<{ ok: true }>((resolveResult, reject) => {
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    let settled = false;
+
+    const settle = (fn: () => void): void => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      stdoutStreamer.flush();
+      stderrStreamer.flush();
+      fn();
+    };
+
+    timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // child may already be gone
+      }
+      settle(() => reject(new ProjectInitTimeoutError(timeoutMs)));
+    }, timeoutMs);
+    timer.unref?.();
+
+    child.on("error", (err: Error) => {
+      settle(() => reject(err));
+    });
+
+    child.on("close", (code: number | null) => {
+      if (code === 0) {
+        settle(() => resolveResult({ ok: true }));
+      } else {
+        settle(() => reject(new ProjectInitFailedError(code, stderrBuffer.trim())));
+      }
+    });
+  });
+}

package/packages/daemon/src/lib/project-inspect.ts

@@ -0,0 +1,80 @@
+/**
+ * Project inspect — looks at an arbitrary directory and reports whether it
+ * has an `ide.yml`, basic git identity, and the detected stack signals from
+ * `src/detect.ts`. Crucially, this is registry-agnostic: it never touches
+ * `~/.tmux-ide/projects.json`, so the dashboard can probe directories the
+ * user is just considering before deciding to register them.
+ *
+ * The git + ide.yml bits delegate to `probeProject` so we don't duplicate
+ * the timeout-bounded git invocations. The stack detection delegates to
+ * `detectStack` from `src/detect.ts` so the wire format stays in sync with
+ * `tmux-ide detect`.
+ */
+
+import { existsSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { detectStack } from "../detect.ts";
+import type { ProjectInspect, ProjectInspectDetected } from "../schemas/inspect.ts";
+import { probeProject, type ProbeIo } from "./project-probe.ts";
+
+export class InspectDirNotFoundError extends Error {
+  readonly code = "DIR_NOT_FOUND";
+  constructor(dir: string) {
+    super(`Directory "${dir}" does not exist`);
+    this.name = "InspectDirNotFoundError";
+  }
+}
+
+const KNOWN_PACKAGE_MANAGERS = new Set(["pnpm", "npm", "yarn", "bun"] as const);
+
+function narrowPackageManager(raw: string | null): ProjectInspectDetected["packageManager"] {
+  if (!raw) return null;
+  return KNOWN_PACKAGE_MANAGERS.has(raw as "pnpm") ? (raw as "pnpm") : null;
+}
+
+/**
+ * Compute a sensible test command from the detected stack. We don't have a
+ * dedicated test detector in `detectStack`, so we compose one from the
+ * package manager — best-effort, can be edited by the user in the wizard.
+ */
+function inferTestCommand(packageManager: string | null): string | null {
+  if (!packageManager) return null;
+  return packageManager === "npm" ? "npm test" : `${packageManager} test`;
+}
+
+export interface InspectIo {
+  exists?: (path: string) => boolean;
+  probeIo?: ProbeIo;
+}
+
+/**
+ * Inspect a directory and return identity + detected stack. Throws
+ * `InspectDirNotFoundError` if the directory doesn't exist; otherwise
+ * never throws (probe + detect both swallow internal failures).
+ */
+export async function inspectProject(dir: string, io: InspectIo = {}): Promise<ProjectInspect> {
+  const exists = io.exists ?? existsSync;
+  const absoluteDir = isAbsolute(dir) ? dir : resolve(dir);
+  if (!exists(absoluteDir)) {
+    throw new InspectDirNotFoundError(absoluteDir);
+  }
+
+  const probe = await probeProject(absoluteDir, io.probeIo);
+  const stack = detectStack(absoluteDir);
+
+  const detected: ProjectInspectDetected = {
+    packageManager: narrowPackageManager(stack.packageManager),
+    frameworks: stack.frameworks,
+    devCommand: stack.devCommand,
+    testCommand: inferTestCommand(stack.packageManager),
+  };
+
+  return {
+    name: probe.name,
+    dir: probe.dir,
+    hasIdeYml: probe.hasIdeYml,
+    gitOrigin: probe.gitOrigin,
+    gitBranch: probe.gitBranch,
+    detected,
+  };
+}

package/packages/daemon/src/lib/project-onboard.ts

@@ -0,0 +1,149 @@
+/**
+ * Project onboard — composes a sensible `ide.yml` from a small set of
+ * inputs (project name, agent count, optional dev/test commands) and
+ * writes it to disk so the project can be registered.
+ *
+ * `composeIdeYml` is the pure-logic bit (string in → string out) so the
+ * shape of the generated config is exhaustively unit-tested without
+ * touching the filesystem. The wrapper around `writeConfig` lives in the
+ * server route, which calls this function and then `registerProject`.
+ */
+
+import yaml from "js-yaml";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { Pane, Row, IdeConfig } from "../schemas/ide-config.ts";
+
+export class OnboardConflictError extends Error {
+  readonly code = "IDE_YML_EXISTS";
+  constructor(path: string) {
+    super(`ide.yml already exists at ${path}`);
+    this.name = "OnboardConflictError";
+  }
+}
+
+export class OnboardInvalidInputError extends Error {
+  readonly code = "INVALID_INPUT";
+  constructor(message: string) {
+    super(message);
+    this.name = "OnboardInvalidInputError";
+  }
+}
+
+export interface ComposeIdeYmlInput {
+  /** Final project name written to the `name:` field. */
+  name: string;
+  /** 1, 2, or 3 — how many Claude panes to put in the top row. */
+  agents: number;
+  /**
+   * Optional per-agent pane titles. When provided, length must equal
+   * `agents`; otherwise it's ignored and the canonical defaults are used
+   * (`Lead`/`Teammate N` for team layouts, `Claude N` for solo).
+   */
+  agentNames?: string[];
+  /** Dev server command. `null` / undefined → no dev pane. */
+  devCommand?: string | null;
+  /** Test command. Currently unused in the generated layout but kept for future. */
+  testCommand?: string | null;
+  /** Lint command. Currently unused in the generated layout but kept for future. */
+  lintCommand?: string | null;
+}
+
+/**
+ * Build the `IdeConfig` value the wizard should write. Pure: same input →
+ * same output, no io.
+ *
+ * Layout shape:
+ *   - Row 0 (70%): N Claude panes, first focused. When `agents > 1`, the
+ *     `team:` block is added so Claude Code launches with team mode.
+ *   - Row 1 (30%): Dev pane (if `devCommand` set) + Shell pane.
+ */
+export function composeIdeYmlConfig(input: ComposeIdeYmlInput): IdeConfig {
+  if (!Number.isInteger(input.agents) || input.agents < 1 || input.agents > 3) {
+    throw new OnboardInvalidInputError(
+      `agents must be an integer between 1 and 3 (got ${input.agents})`,
+    );
+  }
+  const cleanName = input.name.trim();
+  if (!cleanName) {
+    throw new OnboardInvalidInputError("name must be a non-empty string");
+  }
+
+  const agentsCount = input.agents;
+  const useTeam = agentsCount > 1;
+
+  const customNames = input.agentNames;
+  if (customNames !== undefined) {
+    if (customNames.length !== agentsCount) {
+      throw new OnboardInvalidInputError(
+        `agentNames length (${customNames.length}) must equal agents (${agentsCount})`,
+      );
+    }
+    for (const name of customNames) {
+      if (typeof name !== "string" || name.trim() === "") {
+        throw new OnboardInvalidInputError("agentNames entries must be non-empty strings");
+      }
+    }
+  }
+
+  const topPanes: Pane[] = [];
+  for (let i = 0; i < agentsCount; i++) {
+    const fallback = useTeam ? (i === 0 ? "Lead" : `Teammate ${i}`) : `Claude ${i + 1}`;
+    const customTitle = customNames?.[i]?.trim();
+    const pane: Pane = {
+      title: customTitle && customTitle.length > 0 ? customTitle : fallback,
+      command: "claude",
+    };
+    if (useTeam) {
+      pane.role = i === 0 ? "lead" : "teammate";
+    }
+    if (i === 0) {
+      pane.focus = true;
+    }
+    topPanes.push(pane);
+  }
+
+  const bottomPanes: Pane[] = [];
+  const devCommand = input.devCommand?.trim();
+  if (devCommand) {
+    bottomPanes.push({ title: "Dev", command: devCommand });
+  }
+  bottomPanes.push({ title: "Shell" });
+
+  const rows: Row[] = [{ size: "70%", panes: topPanes }, { panes: bottomPanes }];
+
+  const config: IdeConfig = {
+    name: cleanName,
+    rows,
+  };
+
+  if (useTeam) {
+    config.team = { name: cleanName };
+  }
+
+  return config;
+}
+
+/**
+ * Render a composed `IdeConfig` as YAML. Wrapper over `js-yaml` with the
+ * same options used elsewhere so the output shape is identical.
+ */
+export function composeIdeYml(input: ComposeIdeYmlInput): string {
+  const config = composeIdeYmlConfig(input);
+  return yaml.dump(config, { lineWidth: -1, noRefs: true, quotingType: '"' });
+}
+
+/**
+ * Reject onboarding when `ide.yml` already exists. The caller writes the
+ * file separately via `writeConfig`; this helper exists so the route can
+ * 409 cleanly without ever overwriting user content.
+ */
+export function assertNoExistingIdeYml(
+  dir: string,
+  exists: (path: string) => boolean = existsSync,
+): void {
+  const path = join(dir, "ide.yml");
+  if (exists(path)) {
+    throw new OnboardConflictError(path);
+  }
+}

package/packages/daemon/src/lib/project-probe.ts

@@ -0,0 +1,92 @@
+/**
+ * Project probe — inspects a directory and returns identity facts (name from
+ * basename, ide.yml presence, git origin/branch). Pure-ish wrapper over a few
+ * filesystem and git child-process calls; the io functions are pluggable for
+ * tests so we don't need a full mock filesystem.
+ *
+ * All git invocations are hard-bounded by a 2s timeout — we never want a
+ * single misbehaving repo to hang an HTTP request.
+ */
+
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename, isAbsolute, resolve } from "node:path";
+
+const GIT_TIMEOUT_MS = 2_000;
+
+export interface ProjectProbe {
+  name: string;
+  dir: string;
+  hasIdeYml: boolean;
+  gitOrigin: string | null;
+  gitBranch: string | null;
+}
+
+/**
+ * Pluggable io for tests. The defaults are real fs/child_process calls — pass
+ * `io` overrides to drive the probe deterministically in unit tests.
+ */
+export interface ProbeIo {
+  exists(path: string): boolean;
+  runGit(args: string[], cwd: string): Promise<string | null>;
+}
+
+const realIo: ProbeIo = {
+  exists: existsSync,
+  runGit: (args, cwd) =>
+    new Promise((resolveResult) => {
+      execFile(
+        "git",
+        ["-C", cwd, ...args],
+        { timeout: GIT_TIMEOUT_MS, encoding: "utf-8" },
+        (err, stdout) => {
+          if (err) {
+            resolveResult(null);
+            return;
+          }
+          resolveResult(stdout.trim());
+        },
+      );
+    }),
+};
+
+/**
+ * Replace dangerous filename characters and collapse whitespace so the
+ * default `name` is safe to use as a tmux session name and a registry key.
+ */
+export function sanitizeName(raw: string): string {
+  return raw
+    .trim()
+    .replace(/\s+/g, "-")
+    .replace(/[^A-Za-z0-9._-]/g, "")
+    .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Probe a directory and return its identity. Never throws — returns nulls for
+ * any field that can't be determined. The caller decides what's a hard error
+ * (e.g. dir doesn't exist).
+ */
+export async function probeProject(dir: string, io: ProbeIo = realIo): Promise<ProjectProbe> {
+  const absoluteDir = isAbsolute(dir) ? dir : resolve(dir);
+  const rawName = basename(absoluteDir);
+  const sanitized = sanitizeName(rawName);
+  const name = sanitized.length > 0 ? sanitized : "project";
+
+  const hasIdeYml = io.exists(`${absoluteDir}/ide.yml`);
+
+  const [gitOrigin, gitBranch] = await Promise.all([
+    io.runGit(["config", "--get", "remote.origin.url"], absoluteDir),
+    io.runGit(["branch", "--show-current"], absoluteDir),
+  ]);
+
+  return {
+    name,
+    dir: absoluteDir,
+    hasIdeYml,
+    // Treat empty string as null — branch --show-current returns "" on a
+    // detached HEAD.
+    gitOrigin: gitOrigin && gitOrigin.length > 0 ? gitOrigin : null,
+    gitBranch: gitBranch && gitBranch.length > 0 ? gitBranch : null,
+  };
+}