tmux-ide 1.3.1 → 2.0.0

package/src/lib/tmux.ts

@@ -0,0 +1,372 @@
+import { execFileSync, spawn, type ExecFileSyncOptions } from "node:child_process";
+import { TmuxError } from "./errors.ts";
+import type { SessionState } from "../types.ts";
+
+const DEBUG = process.env.TMUX_IDE_DEBUG === "1";
+
+const SESSION_NOT_FOUND_PATTERNS = ["can't find session", "can't find window", "unknown target"];
+
+const TMUX_UNAVAILABLE_PATTERNS = [
+  "failed to connect to server",
+  "no server running",
+  "error connecting to",
+  "connection refused",
+];
+
+export { TmuxError };
+
+export function getSessionState(session: string): SessionState {
+  try {
+    runTmux(["has-session", "-t", session]);
+    return { running: true, reason: null };
+  } catch (error) {
+    if (error instanceof TmuxError) {
+      if (error.code === "SESSION_NOT_FOUND") {
+        return { running: false, reason: "SESSION_NOT_FOUND" };
+      }
+      if (error.code === "TMUX_UNAVAILABLE") {
+        return { running: false, reason: "TMUX_UNAVAILABLE" };
+      }
+    }
+    throw error;
+  }
+}
+
+export function attachSession(session: string): void {
+  runTmux(["attach", "-t", session], { stdio: "inherit" });
+}
+
+export function hasSession(session: string): boolean {
+  try {
+    runTmux(["has-session", "-t", session]);
+    return true;
+  } catch (error) {
+    if (
+      error instanceof TmuxError &&
+      (error.code === "SESSION_NOT_FOUND" || error.code === "TMUX_UNAVAILABLE")
+    ) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+export function killSession(session: string): { stopped: boolean; reason: string | null } {
+  try {
+    runTmux(["kill-session", "-t", session]);
+    return { stopped: true, reason: null };
+  } catch (error) {
+    if (error instanceof TmuxError) {
+      if (error.code === "SESSION_NOT_FOUND") {
+        return { stopped: false, reason: "SESSION_NOT_FOUND" };
+      }
+      if (error.code === "TMUX_UNAVAILABLE") {
+        return { stopped: false, reason: "TMUX_UNAVAILABLE" };
+      }
+    }
+    throw error;
+  }
+}
+
+export function listPanes(session: string) {
+  const raw = (
+    runTmux(
+      [
+        "list-panes",
+        "-t",
+        session,
+        "-F",
+        "#{pane_index}|#{pane_title}|#{pane_width}|#{pane_height}|#{pane_active}",
+      ],
+      { encoding: "utf-8" },
+    ) as string
+  ).trim();
+
+  if (!raw) return [];
+
+  return raw.split("\n").map((line) => {
+    const [index, title, width, height, active] = line.split("|");
+    return {
+      index: Number.parseInt(index!, 10),
+      title,
+      width: Number.parseInt(width!, 10),
+      height: Number.parseInt(height!, 10),
+      active: active === "1",
+    };
+  });
+}
+
+export function createDetachedSession(
+  session: string,
+  cwd: string,
+  { cols, lines }: { cols?: number; lines?: number } = {},
+): string {
+  return (
+    runTmux(
+      [
+        "new-session",
+        "-d",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "-s",
+        session,
+        "-c",
+        cwd,
+        "-x",
+        String(cols ?? 200),
+        "-y",
+        String(lines ?? 50),
+      ],
+      { encoding: "utf-8" },
+    ) as string
+  ).trim();
+}
+
+export function setSessionEnvironment(session: string, key: string, value: string | number): void {
+  runTmux(["set-environment", "-t", session, key, String(value)]);
+}
+
+export function splitPane(
+  targetPane: string,
+  direction: string,
+  cwd: string,
+  percent: number,
+): string {
+  return (
+    runTmux(
+      [
+        "split-window",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "-t",
+        targetPane,
+        direction === "vertical" ? "-v" : "-h",
+        "-c",
+        cwd,
+        "-p",
+        String(percent),
+      ],
+      { encoding: "utf-8" },
+    ) as string
+  ).trim();
+}
+
+export function sendLiteral(targetPane: string, text: string): void {
+  runTmux(["send-keys", "-t", targetPane, "-l", "--", text], { stdio: "inherit" });
+  runTmux(["send-keys", "-t", targetPane, "Enter"], { stdio: "inherit" });
+}
+
+export function getPaneCurrentCommand(targetPane: string): string {
+  return (
+    runTmux(["display-message", "-p", "-t", targetPane, "#{pane_current_command}"], {
+      encoding: "utf-8",
+    }) as string
+  ).trim();
+}
+
+export function selectPane(targetPane: string): void {
+  runTmux(["select-pane", "-t", targetPane], { stdio: "inherit" });
+}
+
+export function setPaneTitle(targetPane: string, title: string): void {
+  runTmux(["select-pane", "-t", targetPane, "-T", title], { stdio: "inherit" });
+}
+
+export function setPaneOption(targetPane: string, option: string, value: string): void {
+  runTmux(["set-option", "-pqt", targetPane, option, value]);
+}
+
+export function runSessionCommand(args: string[]): void {
+  runTmux(args, { stdio: "inherit" });
+}
+
+/**
+ * Check if a process is still alive.
+ */
+export function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0); // signal 0 = check existence
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function startSessionMonitor(session: string, monitorScript: string, port?: number): void {
+  // Check if an existing monitor is already alive for this session.
+  // This prevents duplicate monitors on rapid restart cycles.
+  try {
+    const existingPid = (
+      runTmux(["show-option", "-qvt", session, "@monitor_pid"], {
+        encoding: "utf-8",
+      }) as string
+    ).trim();
+    if (existingPid) {
+      const pid = parseInt(existingPid, 10);
+      if (isProcessAlive(pid)) {
+        // Monitor is still running — kill it first for a clean handoff
+        stopSessionMonitor(session);
+        // Brief wait for graceful shutdown
+        let attempts = 0;
+        while (isProcessAlive(pid) && attempts < 10) {
+          const { Atomics, SharedArrayBuffer } = globalThis;
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+          attempts++;
+        }
+      }
+    }
+  } catch {
+    // Session variable not readable — continue with fresh start
+  }
+
+  // Spawn the daemon via bun (runs TypeScript source directly).
+  // Use a process group so we can kill the entire tree on stop.
+  const child = _spawner("bun", [monitorScript, session, String(port ?? 0)], {
+    detached: true,
+    stdio: "ignore",
+    cwd: process.cwd(),
+  });
+  child.unref();
+  // Store PID as tmux session variable for later cleanup.
+  // This is the actual node process PID (not a shell wrapper).
+  runTmux(["set-option", "-t", session, "@monitor_pid", String(child.pid)]);
+}
+
+export function stopSessionMonitor(session: string): void {
+  try {
+    const pid = (
+      runTmux(["show-option", "-qvt", session, "@monitor_pid"], {
+        encoding: "utf-8",
+      }) as string
+    ).trim();
+    if (pid) {
+      const numPid = parseInt(pid, 10);
+      // Kill the process group (negative PID) to catch any children
+      try {
+        process.kill(-numPid, "SIGTERM");
+      } catch {
+        // Process group kill failed — try direct kill
+        try {
+          process.kill(numPid, "SIGTERM");
+        } catch {
+          /* already gone */
+        }
+      }
+    }
+  } catch {
+    /* session or process already gone */
+  }
+}
+
+export function getDaemonPort(session: string): number | null {
+  try {
+    const raw = runTmux(["show-option", "-qvt", session, "@command_center_port"], {
+      encoding: "utf-8",
+    }) as string;
+    const port = parseInt(raw.trim(), 10);
+    return isNaN(port) ? null : port;
+  } catch {
+    return null;
+  }
+}
+
+export async function isDaemonHealthy(session: string): Promise<boolean> {
+  const port = getDaemonPort(session);
+  if (!port) return false;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2000);
+    const res = await fetch(`http://localhost:${port}/health`, { signal: controller.signal });
+    clearTimeout(timeout);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+export function getSessionVariable(session: string, name: string): string | null {
+  try {
+    const raw = runTmux(["show-option", "-qvt", session, name], {
+      encoding: "utf-8",
+    }) as string;
+    return raw.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export function setSessionVariable(session: string, name: string, value: string): void {
+  runTmux(["set-option", "-t", session, name, value]);
+}
+
+type Executor = typeof execFileSync;
+type Spawner = typeof spawn;
+
+let _executor: Executor = execFileSync;
+let _spawner: Spawner = spawn;
+
+/** @internal Replace the executor for testing. Returns a restore function. */
+export function _setExecutor(fn: Executor): () => void {
+  const prev = _executor;
+  _executor = fn;
+  return () => {
+    _executor = prev;
+  };
+}
+
+/** @internal Replace the spawner for testing. Returns a restore function. */
+export function _setSpawner(fn: Spawner): () => void {
+  const prev = _spawner;
+  _spawner = fn;
+  return () => {
+    _spawner = prev;
+  };
+}
+
+declare global {
+  var __tmuxIdeVerbose: boolean | undefined;
+}
+
+function runTmux(args: string[], options: ExecFileSyncOptions = {}) {
+  if (DEBUG || globalThis.__tmuxIdeVerbose) {
+    console.error(`  [tmux] ${args.join(" ")}`);
+  }
+
+  const execOptions: ExecFileSyncOptions = {
+    stdio: ["ignore", "pipe", "pipe"],
+    ...options,
+  };
+
+  try {
+    return _executor("tmux", args, execOptions);
+  } catch (error) {
+    throw classifyTmuxError(error);
+  }
+}
+
+function classifyTmuxError(error: unknown): TmuxError {
+  const detail = getErrorDetail(error).toLowerCase();
+
+  if (SESSION_NOT_FOUND_PATTERNS.some((pattern) => detail.includes(pattern))) {
+    return new TmuxError("tmux session was not found", "SESSION_NOT_FOUND", {
+      cause: error as Error,
+    });
+  }
+
+  if (TMUX_UNAVAILABLE_PATTERNS.some((pattern) => detail.includes(pattern))) {
+    return new TmuxError("tmux is unavailable or its socket is inaccessible", "TMUX_UNAVAILABLE", {
+      cause: error as Error,
+    });
+  }
+
+  return new TmuxError("tmux command failed", "TMUX_ERROR", { cause: error as Error });
+}
+
+function getErrorDetail(error: unknown): string {
+  const stderr = (error as { stderr?: string | Buffer })?.stderr;
+  if (typeof stderr === "string" && stderr.length > 0) return stderr;
+  if (Buffer.isBuffer(stderr) && stderr.length > 0) return stderr.toString("utf-8");
+  return (error as Error)?.message ?? "";
+}

package/src/lib/token-tracker.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, rmSync, existsSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  loadAccounting,
+  saveAccounting,
+  recordTaskTime,
+  formatDuration,
+  type AccountingData,
+} from "./token-tracker.ts";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-tracker-test-"));
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("loadAccounting", () => {
+  it("returns empty data when no file exists", () => {
+    const data = loadAccounting(tmpDir);
+    expect(data.agents).toEqual({});
+    expect(data.sessionStart).toBeTruthy();
+    expect(data.updated).toBeTruthy();
+  });
+
+  it("loads existing accounting data", () => {
+    mkdirSync(join(tmpDir, ".tasks"), { recursive: true });
+    const saved: AccountingData = {
+      agents: { "Agent 1": { totalTimeMs: 60000, taskCount: 2, lastTaskId: "002" } },
+      sessionStart: "2026-01-01T00:00:00Z",
+      updated: "2026-01-01T00:01:00Z",
+    };
+    saveAccounting(tmpDir, saved);
+    const loaded = loadAccounting(tmpDir);
+    expect(loaded.agents["Agent 1"]!.totalTimeMs).toBe(60000);
+    expect(loaded.agents["Agent 1"]!.taskCount).toBe(2);
+  });
+});
+
+describe("saveAccounting", () => {
+  it("creates .tasks/ directory if needed", () => {
+    const data: AccountingData = {
+      agents: {},
+      sessionStart: new Date().toISOString(),
+      updated: new Date().toISOString(),
+    };
+    saveAccounting(tmpDir, data);
+    expect(existsSync(join(tmpDir, ".tasks", "accounting.json"))).toBeTruthy();
+  });
+});
+
+describe("recordTaskTime", () => {
+  it("creates agent entry on first recording", () => {
+    mkdirSync(join(tmpDir, ".tasks"), { recursive: true });
+    recordTaskTime(tmpDir, "Agent 1", "001", 30000);
+    const data = loadAccounting(tmpDir);
+    expect(data.agents["Agent 1"]!.totalTimeMs).toBe(30000);
+    expect(data.agents["Agent 1"]!.taskCount).toBe(1);
+    expect(data.agents["Agent 1"]!.lastTaskId).toBe("001");
+  });
+
+  it("accumulates time across multiple tasks", () => {
+    mkdirSync(join(tmpDir, ".tasks"), { recursive: true });
+    recordTaskTime(tmpDir, "Agent 1", "001", 30000);
+    recordTaskTime(tmpDir, "Agent 1", "002", 45000);
+    const data = loadAccounting(tmpDir);
+    expect(data.agents["Agent 1"]!.totalTimeMs).toBe(75000);
+    expect(data.agents["Agent 1"]!.taskCount).toBe(2);
+    expect(data.agents["Agent 1"]!.lastTaskId).toBe("002");
+  });
+
+  it("tracks multiple agents independently", () => {
+    mkdirSync(join(tmpDir, ".tasks"), { recursive: true });
+    recordTaskTime(tmpDir, "Agent 1", "001", 30000);
+    recordTaskTime(tmpDir, "Agent 2", "002", 60000);
+    const data = loadAccounting(tmpDir);
+    expect(data.agents["Agent 1"]!.totalTimeMs).toBe(30000);
+    expect(data.agents["Agent 2"]!.totalTimeMs).toBe(60000);
+  });
+});
+
+describe("formatDuration", () => {
+  it("formats seconds", () => {
+    expect(formatDuration(5000)).toBe("5s");
+    expect(formatDuration(45000)).toBe("45s");
+  });
+
+  it("formats minutes and seconds", () => {
+    expect(formatDuration(90000)).toBe("1m 30s");
+    expect(formatDuration(300000)).toBe("5m 0s");
+  });
+
+  it("formats hours and minutes", () => {
+    expect(formatDuration(3600000)).toBe("1h 0m");
+    expect(formatDuration(5400000)).toBe("1h 30m");
+  });
+});

package/src/lib/token-tracker.ts

@@ -0,0 +1,70 @@
+import { join } from "node:path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "node:fs";
+
+export interface AgentAccounting {
+  totalTimeMs: number;
+  taskCount: number;
+  lastTaskId: string | null;
+}
+
+export interface AccountingData {
+  agents: Record<string, AgentAccounting>;
+  sessionStart: string;
+  updated: string;
+}
+
+function accountingPath(dir: string): string {
+  return join(dir, ".tasks", "accounting.json");
+}
+
+export function loadAccounting(dir: string): AccountingData {
+  const path = accountingPath(dir);
+  if (existsSync(path)) {
+    try {
+      return JSON.parse(readFileSync(path, "utf-8")) as AccountingData;
+    } catch {
+      // Corrupted file, start fresh
+    }
+  }
+  return {
+    agents: {},
+    sessionStart: new Date().toISOString(),
+    updated: new Date().toISOString(),
+  };
+}
+
+export function saveAccounting(dir: string, data: AccountingData): void {
+  const tasksDir = join(dir, ".tasks");
+  if (!existsSync(tasksDir)) mkdirSync(tasksDir, { recursive: true });
+  data.updated = new Date().toISOString();
+  const dest = accountingPath(dir);
+  const tmpPath = dest + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(data, null, 2) + "\n");
+  renameSync(tmpPath, dest);
+}
+
+export function recordTaskTime(
+  dir: string,
+  agentName: string,
+  taskId: string,
+  elapsedMs: number,
+): void {
+  const data = loadAccounting(dir);
+  if (!data.agents[agentName]) {
+    data.agents[agentName] = { totalTimeMs: 0, taskCount: 0, lastTaskId: null };
+  }
+  const agent = data.agents[agentName]!;
+  agent.totalTimeMs += elapsedMs;
+  agent.taskCount += 1;
+  agent.lastTaskId = taskId;
+  saveAccounting(dir, data);
+}
+
+export function formatDuration(ms: number): string {
+  const secs = Math.floor(ms / 1000);
+  if (secs < 60) return `${secs}s`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins}m ${secs % 60}s`;
+  const hrs = Math.floor(mins / 60);
+  return `${hrs}h ${mins % 60}m`;
+}

package/src/lib/tunnels/cloudflare.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, afterEach } from "bun:test";
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+import { CloudflareService, _setSpawnForTesting } from "./cloudflare.ts";
+
+function makeChild(hooks: {
+  onReady?: (stdout: EventEmitter, stderr: EventEmitter, proc: EventEmitter) => void;
+}): ChildProcess {
+  const stdout = new EventEmitter();
+  const stderr = new EventEmitter();
+  const proc = new EventEmitter() as EventEmitter & Partial<ChildProcess>;
+  proc.stdout = stdout as NodeJS.ReadableStream;
+  proc.stderr = stderr as NodeJS.ReadableStream;
+  proc.pid = 9002;
+  proc.killed = false;
+  proc.kill = () => {
+    proc.killed = true;
+    queueMicrotask(() => proc.emit("close", 0));
+    return true;
+  };
+  queueMicrotask(() => hooks.onReady?.(stdout, stderr, proc));
+  return proc as ChildProcess;
+}
+
+describe("CloudflareService", () => {
+  let restore: () => void = () => {};
+
+  afterEach(() => {
+    restore();
+    restore = () => {};
+  });
+
+  it("parses trycloudflare.com URL from stdout", async () => {
+    const mockSpawn = (_cmd: string, args: string[]) => {
+      if (args[0] === "--version") {
+        return makeChild({
+          onReady: (_o, _e, proc) => proc.emit("close", 0),
+        });
+      }
+      if (args[0] === "tunnel") {
+        return makeChild({
+          onReady: (stdout) => {
+            const msg =
+              "Your quick Tunnel has been created! Visit https://random-words-abc123.trycloudflare.com\n";
+            stdout.emit("data", Buffer.from(msg, "utf8"));
+          },
+        });
+      }
+      return makeChild({ onReady: (_o, _e, proc) => proc.emit("close", 0) });
+    };
+    restore = _setSpawnForTesting(mockSpawn as typeof import("node:child_process").spawn);
+
+    const svc = new CloudflareService(7777, { startupTimeoutMs: 5000 });
+    const tunnel = await svc.start();
+    expect(tunnel.publicUrl).toBe("https://random-words-abc123.trycloudflare.com");
+    await svc.stop();
+  });
+
+  it("rejects when cloudflared is not installed", async () => {
+    const mockSpawn = (_cmd: string, args: string[]) => {
+      if (args[0] === "--version") {
+        return makeChild({
+          onReady: (_o, _e, proc) => proc.emit("close", 1),
+        });
+      }
+      return makeChild({ onReady: (_o, _e, proc) => proc.emit("close", 0) });
+    };
+    restore = _setSpawnForTesting(mockSpawn as typeof import("node:child_process").spawn);
+
+    const svc = new CloudflareService(7777);
+    await expect(svc.start()).rejects.toThrow(/cloudflared binary not found/);
+  });
+});