tmux-ide 1.2.1 → 2.0.0

package/src/plan.ts

@@ -0,0 +1,117 @@
+import { resolve } from "node:path";
+import { outputError } from "./lib/output.ts";
+import { listPlans, markPlanDone, getPlan, type PlanStatus } from "./lib/plan-store.ts";
+
+const STATUS_ICONS: Record<PlanStatus, string> = {
+  pending: "○",
+  "in-progress": "●",
+  done: "✓",
+  archived: "▪",
+};
+
+const STATUS_COLORS: Record<PlanStatus, string> = {
+  pending: "\x1b[2m", // dim
+  "in-progress": "\x1b[33m", // yellow
+  done: "\x1b[32m", // green
+  archived: "\x1b[2m", // dim
+};
+
+const RESET = "\x1b[0m";
+
+export async function planCommand(
+  targetDir: string | undefined,
+  {
+    json = false,
+    sub,
+    args = [],
+    values = {},
+  }: {
+    json?: boolean;
+    sub?: string;
+    args?: string[];
+    values?: { status?: string };
+  },
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+
+  switch (sub) {
+    case "list":
+    case undefined: {
+      const statusFilter = values.status as PlanStatus | undefined;
+      const plans = listPlans(dir, statusFilter ? { status: statusFilter } : undefined);
+
+      if (json) {
+        console.log(JSON.stringify(plans, null, 2));
+        return;
+      }
+
+      if (plans.length === 0) {
+        console.log("No plans found.");
+        return;
+      }
+
+      // Group by status
+      const groups: Record<string, typeof plans> = {};
+      for (const p of plans) {
+        (groups[p.status] ??= []).push(p);
+      }
+
+      for (const status of ["in-progress", "pending", "done", "archived"] as PlanStatus[]) {
+        const group = groups[status];
+        if (!group?.length) continue;
+        const color = STATUS_COLORS[status];
+        console.log(`\n${color}${status.toUpperCase()}${RESET}`);
+        for (const p of group) {
+          const icon = STATUS_ICONS[p.status];
+          const completed = p.completed ? ` (${p.completed})` : "";
+          console.log(`  ${color}${icon}${RESET} ${p.name}  ${p.title}${completed}`);
+        }
+      }
+      console.log();
+      break;
+    }
+
+    case "show": {
+      const name = args[0];
+      if (!name) outputError("Usage: tmux-ide plan show <name|number>", "USAGE");
+      const plan = getPlan(dir, name);
+      if (!plan) outputError(`Plan not found: ${name}`, "NOT_FOUND");
+
+      if (json) {
+        console.log(JSON.stringify(plan, null, 2));
+        return;
+      }
+
+      const icon = STATUS_ICONS[plan.status];
+      const color = STATUS_COLORS[plan.status];
+      console.log(`${color}${icon} ${plan.title}${RESET}`);
+      console.log(`  Status: ${plan.status}`);
+      if (plan.effort) console.log(`  Effort: ${plan.effort}`);
+      if (plan.gate) console.log(`  Gate: ${plan.gate}`);
+      if (plan.completed) console.log(`  Completed: ${plan.completed}`);
+      console.log(`  File: ${plan.path}`);
+      break;
+    }
+
+    case "done": {
+      const name = args[0];
+      if (!name) outputError("Usage: tmux-ide plan done <name|number>", "USAGE");
+      const result = markPlanDone(dir, name);
+      if (!result) outputError(`Plan not found: ${name}`, "NOT_FOUND");
+
+      if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+
+      console.log(`✓ Plan marked done: ${result.title} (${result.completed})`);
+      break;
+    }
+
+    default:
+      outputError(
+        `Unknown plan subcommand: ${sub}\nUsage: tmux-ide plan [list|show|done] [--status pending|in-progress|done]`,
+        "USAGE",
+      );
+  }
+}

package/src/postinstall.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "bun:test";
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const script = join(__dirname, "..", "scripts", "postinstall.js");
+
+function makeHome() {
+  const root = mkdtempSync(join(tmpdir(), "tmux-ide-postinstall-test-"));
+  const home = join(root, "home");
+  mkdirSync(home, { recursive: true });
+  return { root, home };
+}
+
+function runPostinstall({ home, env } = {}) {
+  return spawnSync("node", [script], {
+    env: {
+      ...process.env,
+      HOME: home,
+      ...env,
+    },
+    encoding: "utf-8",
+  });
+}
+
+describe("postinstall", () => {
+  it("does not create Claude config for non-global installs", () => {
+    const { root, home } = makeHome();
+
+    try {
+      const result = runPostinstall({ home, env: { npm_config_global: undefined } });
+
+      expect(result.status).toBe(0);
+      expect(existsSync(join(home, ".claude"))).toBe(false);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("does not create Claude config when Claude is not installed", () => {
+    const { root, home } = makeHome();
+
+    try {
+      const result = runPostinstall({ home, env: { npm_config_global: "true" } });
+
+      expect(result.status).toBe(0);
+      expect(existsSync(join(home, ".claude"))).toBe(false);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("updates existing Claude settings for global installs", () => {
+    const { root, home } = makeHome();
+    const claudeDir = join(home, ".claude");
+    const settingsPath = join(claudeDir, "settings.json");
+
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(settingsPath, `${JSON.stringify({ env: { KEEP_ME: "1" } }, null, 2)}\n`);
+
+    try {
+      const result = runPostinstall({ home, env: { npm_config_global: "true" } });
+
+      expect(result.status).toBe(0);
+      expect(existsSync(join(claudeDir, "skills", "tmux-ide", "SKILL.md"))).toBe(true);
+
+      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      expect(settings.env).toEqual({
+        KEEP_ME: "1",
+        CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1",
+      });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/src/remote.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from "bun:test";
+import { HQConfigSchema, RegistrationPayloadSchema } from "./lib/hq/types.ts";
+
+describe("remote CLI contracts", () => {
+  describe("HQConfigSchema", () => {
+    it("accepts valid HQ config", () => {
+      const result = HQConfigSchema.safeParse({
+        enabled: true,
+        role: "hq",
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("accepts valid remote config", () => {
+      const result = HQConfigSchema.safeParse({
+        enabled: true,
+        role: "remote",
+        hq_url: "https://hq.example.com",
+        secret: "s3cr3t",
+        heartbeat_interval: 10000,
+        machine_name: "dev-1",
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("rejects invalid role", () => {
+      const result = HQConfigSchema.safeParse({
+        enabled: true,
+        role: "invalid",
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it("rejects heartbeat_interval below 1000", () => {
+      const result = HQConfigSchema.safeParse({
+        enabled: true,
+        role: "hq",
+        heartbeat_interval: 500,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it("defaults heartbeat_interval to 15000", () => {
+      const result = HQConfigSchema.parse({
+        enabled: true,
+        role: "hq",
+      });
+      expect(result.heartbeat_interval).toBe(15000);
+    });
+
+    it("defaults enabled to false", () => {
+      const result = HQConfigSchema.parse({
+        role: "remote",
+      });
+      expect(result.enabled).toBe(false);
+    });
+  });
+
+  describe("RegistrationPayloadSchema", () => {
+    it("accepts valid registration payload", () => {
+      const result = RegistrationPayloadSchema.safeParse({
+        id: "abc-123",
+        name: "dev-box",
+        url: "https://dev.example.com",
+        token: "tok-xyz",
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("rejects empty id", () => {
+      const result = RegistrationPayloadSchema.safeParse({
+        id: "",
+        name: "dev",
+        url: "https://dev.example.com",
+        token: "tok",
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it("rejects invalid URL", () => {
+      const result = RegistrationPayloadSchema.safeParse({
+        id: "m1",
+        name: "dev",
+        url: "not-a-url",
+        token: "tok",
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("IdeConfigSchema with hq field", () => {
+    it("accepts hq config in ide.yml schema", async () => {
+      const { IdeConfigSchema } = await import("./schemas/ide-config.ts");
+      const result = IdeConfigSchema.safeParse({
+        rows: [{ panes: [{ title: "Shell" }] }],
+        hq: {
+          enabled: true,
+          role: "remote",
+          hq_url: "https://hq.example.com",
+          secret: "mykey",
+          machine_name: "laptop",
+        },
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("allows omitting hq", async () => {
+      const { IdeConfigSchema } = await import("./schemas/ide-config.ts");
+      const result = IdeConfigSchema.safeParse({
+        rows: [{ panes: [{ title: "Shell" }] }],
+      });
+      expect(result.success).toBe(true);
+    });
+  });
+});

package/src/remote.ts

@@ -0,0 +1,148 @@
+import { resolve } from "node:path";
+import { IdeError } from "./lib/errors.ts";
+import { HQClient } from "./lib/hq/client.ts";
+import { HQConfigSchema } from "./lib/hq/types.ts";
+
+interface RemoteOptions {
+  json?: boolean;
+  sub?: string;
+  args?: string[];
+  values?: Record<string, string | boolean | undefined>;
+}
+
+async function loadHQConfig(dir: string) {
+  try {
+    const { readConfig } = await import("./lib/yaml-io.ts");
+    const { config } = readConfig(dir);
+    if (config.hq) {
+      return HQConfigSchema.parse(config.hq);
+    }
+  } catch {
+    // config not readable
+  }
+  return null;
+}
+
+export async function remoteCommand(
+  targetDir: string | null | undefined,
+  opts: RemoteOptions,
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { json, sub } = opts;
+
+  switch (sub) {
+    case "register": {
+      const hqConfig = await loadHQConfig(dir);
+      if (!hqConfig || hqConfig.role !== "remote") {
+        throw new IdeError(
+          'HQ config not found or role is not "remote". Add hq section to ide.yml.',
+          {
+            code: "CONFIG_MISSING",
+          },
+        );
+      }
+      if (!hqConfig.hq_url) {
+        throw new IdeError("hq_url is required for remote registration", {
+          code: "CONFIG_MISSING",
+        });
+      }
+
+      const client = new HQClient({
+        hqUrl: hqConfig.hq_url,
+        secret: hqConfig.secret ?? "",
+        machineName: hqConfig.machine_name ?? (await import("node:os")).hostname(),
+        remoteUrl: (opts.values?.url as string) ?? `http://localhost:4000`,
+        heartbeatInterval: hqConfig.heartbeat_interval,
+      });
+
+      await client.register();
+
+      if (json) {
+        console.log(
+          JSON.stringify({
+            ok: true,
+            remoteId: client.getRemoteId(),
+            name: client.getName(),
+          }),
+        );
+      } else {
+        console.log(`Registered with HQ as ${client.getName()} (${client.getRemoteId()})`);
+      }
+
+      // Keep alive until SIGINT/SIGTERM
+      await new Promise<void>((resolve) => {
+        const shutdown = async () => {
+          await client.destroy();
+          resolve();
+        };
+        process.once("SIGINT", () => void shutdown());
+        process.once("SIGTERM", () => void shutdown());
+      });
+      break;
+    }
+
+    case "machines": {
+      const hqConfig = await loadHQConfig(dir);
+      const hqUrl =
+        (opts.values?.["hq-url"] as string) ?? hqConfig?.hq_url ?? "http://localhost:4000";
+
+      try {
+        const res = await fetch(`${hqUrl}/api/hq/machines`);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+
+        if (json) {
+          console.log(JSON.stringify(data));
+        } else {
+          const machines = (data as { machines: Array<{ id: string; name: string; url: string }> })
+            .machines;
+          if (machines.length === 0) {
+            console.log("No remote machines registered");
+          } else {
+            for (const m of machines) {
+              console.log(`  ${m.name} — ${m.url} (${m.id})`);
+            }
+          }
+        }
+      } catch (err) {
+        throw new IdeError(
+          `Failed to query HQ: ${err instanceof Error ? err.message : String(err)}`,
+          {
+            code: "HQ_ERROR",
+          },
+        );
+      }
+      break;
+    }
+
+    case "status": {
+      const hqConfig = await loadHQConfig(dir);
+
+      if (json) {
+        console.log(
+          JSON.stringify({
+            configured: !!hqConfig,
+            role: hqConfig?.role ?? null,
+            hq_url: hqConfig?.hq_url ?? null,
+            machine_name: hqConfig?.machine_name ?? null,
+          }),
+        );
+      } else {
+        if (!hqConfig) {
+          console.log("HQ: not configured");
+        } else {
+          console.log(`HQ role: ${hqConfig.role}`);
+          if (hqConfig.hq_url) console.log(`HQ URL: ${hqConfig.hq_url}`);
+          if (hqConfig.machine_name) console.log(`Machine: ${hqConfig.machine_name}`);
+        }
+      }
+      break;
+    }
+
+    default:
+      throw new IdeError(
+        `Unknown remote subcommand: ${sub ?? "(none)"}\nUsage: tmux-ide remote register|machines|status`,
+        { code: "USAGE" },
+      );
+  }
+}

package/src/restart.ts

@@ -0,0 +1,24 @@
+import { resolve } from "node:path";
+import { getSessionName } from "./lib/yaml-io.ts";
+import { launch } from "./launch.ts";
+import { killSession, stopSessionMonitor } from "./lib/tmux.ts";
+
+export async function restart(
+  targetDir: string | undefined,
+  { json, attach }: { json?: boolean; attach?: boolean } = {},
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { name: session } = getSessionName(dir);
+
+  // Stop the session monitor first — this triggers orchestrator graceful
+  // shutdown (release tasks, save state) before we kill the tmux session.
+  stopSessionMonitor(session);
+
+  const result = killSession(session);
+
+  if (result.stopped) {
+    console.log(`Stopped session "${session}"`);
+  }
+
+  await launch(dir, { json, attach });
+}