tmux-ide 2.1.4 → 2.6.0

package/src/lib/tmux.ts

@@ -1,372 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

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