tmux-ide 1.2.1 → 2.0.0

package/src/config-cli.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "bun:test";
+import { mkdtempSync, writeFileSync, 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 cli = join(__dirname, "..", "bin", "cli.js");
+
+function makeProject(config) {
+  const dir = mkdtempSync(join(tmpdir(), "tmux-ide-config-test-"));
+  writeFileSync(join(dir, "ide.yml"), config);
+  return dir;
+}
+
+function runCli(args, cwd) {
+  return spawnSync("node", [cli, ...args], {
+    cwd,
+    encoding: "utf-8",
+  });
+}
+
+describe("config command hardening", () => {
+  it("rejects config set when the YAML root is not an object", () => {
+    const dir = makeProject("null\n");
+
+    try {
+      const result = runCli(["config", "set", "rows.0.title", "Shell"], dir);
+
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toMatch(/config root must be an object/);
+      expect(result.stderr).not.toMatch(/TypeError/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects add-pane when row panes is not an array", () => {
+    const dir = makeProject("rows:\n  - panes: nope\n");
+
+    try {
+      const result = runCli(["config", "add-pane", "--row", "0", "--title", "Shell"], dir);
+
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toMatch(/row 0 panes must be an array/);
+      expect(result.stderr).not.toMatch(/TypeError/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("refuses enable-team when there are no Claude panes to assign", () => {
+    const dir = makeProject("name: my-app\nrows:\n  - panes:\n      - title: Shell\n");
+
+    try {
+      const result = runCli(["config", "enable-team"], dir);
+
+      expect(result.status).not.toBe(0);
+      expect(result.stderr).toMatch(/no Claude panes found/i);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("assigns team metadata and Claude pane roles when enable-team succeeds", () => {
+    const dir = makeProject(
+      "name: my-app\nrows:\n  - panes:\n      - title: Lead\n        command: claude\n      - title: Reviewer\n        command: claude\n",
+    );
+
+    try {
+      const result = runCli(["config", "enable-team", "--json"], dir);
+
+      expect(result.status).toBe(0);
+
+      const payload = JSON.parse(result.stdout);
+      expect(payload.team).toEqual({ name: "my-app" });
+      expect(payload.roles).toEqual([
+        { row: 0, pane: 0, title: "Lead", role: "lead" },
+        { row: 0, pane: 1, title: "Reviewer", role: "teammate" },
+      ]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/config.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import yaml from "js-yaml";
+import { config } from "./config.ts";
+
+let tmpDir;
+let origLog;
+let logged;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-config-test-"));
+  logged = [];
+  origLog = console.log;
+  console.log = (...a) => logged.push(a.join(" "));
+});
+
+afterEach(() => {
+  console.log = origLog;
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function writeIdeYml(obj) {
+  writeFileSync(
+    join(tmpDir, "ide.yml"),
+    yaml.dump(obj, { lineWidth: -1, noRefs: true, quotingType: '"' }),
+  );
+}
+
+function readIdeYml() {
+  return yaml.load(readFileSync(join(tmpDir, "ide.yml"), "utf-8"));
+}
+
+describe("config dump", () => {
+  it("outputs config as JSON", async () => {
+    const cfg = { name: "test", rows: [{ panes: [{ title: "Shell" }] }] };
+    writeIdeYml(cfg);
+    await config(tmpDir, { json: true, action: "dump", args: [] });
+    const output = JSON.parse(logged[0]);
+    expect(output.name).toBe("test");
+    expect(output.rows[0].panes[0].title).toBe("Shell");
+  });
+});
+
+describe("config set", () => {
+  it("updates a top-level value", async () => {
+    writeIdeYml({ name: "old", rows: [{ panes: [{ title: "Shell" }] }] });
+    await config(tmpDir, { json: true, action: "set", args: ["name", "new-name"] });
+    const output = JSON.parse(logged[0]);
+    expect(output.ok).toBe(true);
+    expect(output.value).toBe("new-name");
+    const saved = readIdeYml();
+    expect(saved.name).toBe("new-name");
+  });
+
+  it("updates a nested value", async () => {
+    writeIdeYml({ name: "test", rows: [{ panes: [{ title: "Shell" }] }] });
+    await config(tmpDir, { json: true, action: "set", args: ["rows.0.panes.0.title", "Editor"] });
+    const saved = readIdeYml();
+    expect(saved.rows[0].panes[0].title).toBe("Editor");
+  });
+
+  it("coerces boolean strings", async () => {
+    writeIdeYml({ name: "test", rows: [{ panes: [{ title: "Shell" }] }] });
+    await config(tmpDir, { json: true, action: "set", args: ["rows.0.panes.0.focus", "true"] });
+    const saved = readIdeYml();
+    expect(saved.rows[0].panes[0].focus).toBe(true);
+  });
+
+  it("coerces numeric strings", async () => {
+    writeIdeYml({ name: "test", rows: [{ panes: [{ title: "Shell" }] }] });
+    await config(tmpDir, { json: true, action: "set", args: ["rows.0.panes.0.width", "120"] });
+    const saved = readIdeYml();
+    expect(saved.rows[0].panes[0].width).toBe(120);
+  });
+});
+
+describe("config add-pane", () => {
+  it("adds pane to existing row", async () => {
+    writeIdeYml({ name: "test", rows: [{ panes: [{ title: "Shell" }] }] });
+    await config(tmpDir, {
+      json: true,
+      action: "add-pane",
+      args: ["--row", "0", "--title", "Tests", "--command", "pnpm test"],
+    });
+    const output = JSON.parse(logged[0]);
+    expect(output.ok).toBe(true);
+    expect(output.pane.title).toBe("Tests");
+    expect(output.pane.command).toBe("pnpm test");
+    const saved = readIdeYml();
+    expect(saved.rows[0].panes.length).toBe(2);
+    expect(saved.rows[0].panes[1].title).toBe("Tests");
+  });
+
+  it("adds pane with size", async () => {
+    writeIdeYml({ name: "test", rows: [{ panes: [{ title: "Shell" }] }] });
+    await config(tmpDir, {
+      json: true,
+      action: "add-pane",
+      args: ["--row", "0", "--title", "Wide", "--size", "60%"],
+    });
+    const saved = readIdeYml();
+    expect(saved.rows[0].panes[1].size).toBe("60%");
+  });
+});
+
+describe("config remove-pane", () => {
+  it("removes pane by index", async () => {
+    writeIdeYml({
+      name: "test",
+      rows: [{ panes: [{ title: "A" }, { title: "B" }, { title: "C" }] }],
+    });
+    await config(tmpDir, {
+      json: true,
+      action: "remove-pane",
+      args: ["--row", "0", "--pane", "1"],
+    });
+    const output = JSON.parse(logged[0]);
+    expect(output.ok).toBe(true);
+    expect(output.removed.title).toBe("B");
+    const saved = readIdeYml();
+    expect(saved.rows[0].panes.length).toBe(2);
+    expect(saved.rows[0].panes[0].title).toBe("A");
+    expect(saved.rows[0].panes[1].title).toBe("C");
+  });
+});
+
+describe("config add-row", () => {
+  it("creates row with default Shell pane", async () => {
+    writeIdeYml({ name: "test", rows: [{ panes: [{ title: "Shell" }] }] });
+    await config(tmpDir, { json: true, action: "add-row", args: [] });
+    const output = JSON.parse(logged[0]);
+    expect(output.ok).toBe(true);
+    expect(output.row).toBe(1);
+    const saved = readIdeYml();
+    expect(saved.rows.length).toBe(2);
+    expect(saved.rows[1].panes).toEqual([{ title: "Shell" }]);
+  });
+
+  it("creates row with size", async () => {
+    writeIdeYml({ name: "test", rows: [{ panes: [{ title: "Shell" }] }] });
+    await config(tmpDir, { json: true, action: "add-row", args: ["--size", "30%"] });
+    const saved = readIdeYml();
+    expect(saved.rows[1].size).toBe("30%");
+  });
+
+  it("initializes rows array when it doesn't exist", async () => {
+    writeIdeYml({ name: "test" });
+    await config(tmpDir, { json: true, action: "add-row", args: [] });
+    const saved = readIdeYml();
+    expect(saved.rows.length).toBe(1);
+  });
+});
+
+describe("config enable-team", () => {
+  it("assigns roles to Claude panes", async () => {
+    writeIdeYml({
+      name: "my-app",
+      rows: [
+        {
+          panes: [
+            { title: "Lead", command: "claude" },
+            { title: "Worker", command: "claude" },
+            { title: "Shell" },
+          ],
+        },
+      ],
+    });
+    await config(tmpDir, { json: true, action: "enable-team", args: [] });
+    const output = JSON.parse(logged[0]);
+    expect(output.ok).toBe(true);
+    expect(output.team.name).toBe("my-app");
+    const saved = readIdeYml();
+    expect(saved.rows[0].panes[0].role).toBe("lead");
+    expect(saved.rows[0].panes[1].role).toBe("teammate");
+    expect(saved.rows[0].panes[2].role).toBe(undefined);
+  });
+});
+
+describe("config disable-team", () => {
+  it("removes team and role/task fields", async () => {
+    writeIdeYml({
+      name: "my-app",
+      team: { name: "my-app" },
+      rows: [
+        {
+          panes: [
+            { title: "Lead", command: "claude", role: "lead" },
+            { title: "Worker", command: "claude", role: "teammate", task: "Build UI" },
+          ],
+        },
+      ],
+    });
+    await config(tmpDir, { json: true, action: "disable-team", args: [] });
+    const output = JSON.parse(logged[0]);
+    expect(output.ok).toBe(true);
+    expect(output.disabled).toBe(true);
+    const saved = readIdeYml();
+    expect(saved.team).toBe(undefined);
+    expect(saved.rows[0].panes[0].role).toBe(undefined);
+    expect(saved.rows[0].panes[1].role).toBe(undefined);
+    expect(saved.rows[0].panes[1].task).toBe(undefined);
+  });
+});

package/src/config.ts

@@ -0,0 +1,313 @@
+import { resolve } from "node:path";
+import { readConfig, writeConfig } from "./lib/yaml-io.ts";
+import { setByPath } from "./lib/dot-path.ts";
+import { outputError } from "./lib/output.ts";
+import { IdeConfigSchema } from "./schemas/ide-config.ts";
+import type { IdeConfig, Pane, Row } from "./types.ts";
+
+/**
+ * Read config safely (read-only, no write). Returns config or undefined on error.
+ */
+function readConfigSafe(dir: string): IdeConfig | undefined {
+  let cfg: IdeConfig;
+  try {
+    ({ config: cfg } = readConfig(dir));
+  } catch (e) {
+    outputError(`Cannot read ide.yml: ${(e as Error).message}`, "READ_ERROR");
+    return;
+  }
+  return cfg;
+}
+
+/**
+ * Read config, validate it's an object, run mutator, then write back.
+ * Returns the mutator's return value, or undefined on error.
+ */
+function withConfig<T>(dir: string, mutator: (cfg: IdeConfig) => T): T | undefined {
+  const cfg = readConfigSafe(dir);
+  if (cfg === undefined) return;
+
+  if (!isConfigObject(cfg)) {
+    outputError("Invalid ide.yml: config root must be an object", "INVALID_CONFIG");
+    return;
+  }
+
+  const result = mutator(cfg);
+
+  const validation = IdeConfigSchema.safeParse(cfg);
+  if (!validation.success) {
+    const issues = validation.error.issues
+      .map((i) => `  ${i.path.join(".")}: ${i.message}`)
+      .join("\n");
+    outputError(`Invalid config after mutation:\n${issues}`, "INVALID_CONFIG");
+    return;
+  }
+
+  writeConfig(dir, cfg);
+  return result;
+}
+
+export async function config(
+  targetDir: string | null,
+  { json, action, args }: { json?: boolean; action?: string; args?: string[] } = {},
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+
+  switch (action) {
+    case "dump":
+      return dumpConfig(dir, { json });
+    case "set":
+      return setConfig(dir, args ?? [], { json });
+    case "add-pane":
+      return addPane(dir, args ?? [], { json });
+    case "remove-pane":
+      return removePane(dir, args ?? [], { json });
+    case "add-row":
+      return addRow(dir, args ?? [], { json });
+    case "enable-team":
+      return enableTeam(dir, args ?? [], { json });
+    case "disable-team":
+      return disableTeam(dir, { json });
+    default:
+      return dumpConfig(dir, { json });
+  }
+}
+
+function dumpConfig(dir: string, { json }: { json?: boolean }): void {
+  const cfg = readConfigSafe(dir);
+  if (cfg === undefined) return;
+
+  if (json) {
+    console.log(JSON.stringify(cfg, null, 2));
+  } else {
+    console.log(JSON.stringify(cfg, null, 2));
+  }
+}
+
+function setConfig(dir: string, args: string[], { json }: { json?: boolean }): void {
+  const [dotpath, ...rest] = args;
+  if (!dotpath || rest.length === 0) {
+    outputError("Usage: tmux-ide config set <dotpath> <value>", "USAGE");
+    return;
+  }
+
+  let value: string | boolean | number = rest.join(" ");
+  if (value === "true") value = true;
+  else if (value === "false") value = false;
+  else if (/^\d+$/.test(value)) value = parseInt(value);
+
+  withConfig(dir, (cfg) => {
+    setByPath(cfg as unknown as Record<string, unknown>, dotpath, value);
+  });
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, path: dotpath, value }, null, 2));
+  } else {
+    console.log(`Set ${dotpath} = ${JSON.stringify(value)}`);
+  }
+}
+
+function addPane(dir: string, args: string[], { json }: { json?: boolean }): void {
+  const { row, title, command, size } = parseNamedArgs(args);
+  if (row === undefined) {
+    outputError(
+      "Usage: tmux-ide config add-pane --row <N> --title <T> [--command <C>] [--size <S>]",
+      "USAGE",
+    );
+    return;
+  }
+
+  const rowIdx = parseIndex(row);
+  if (rowIdx == null) {
+    outputError(`Invalid row index "${row}"`, "USAGE");
+    return;
+  }
+
+  const pane: Partial<Pane> = {};
+  if (title) pane.title = title;
+  if (command) pane.command = command;
+  if (size) pane.size = size;
+
+  withConfig(dir, (cfg) => {
+    if (!Array.isArray(cfg.rows)) {
+      outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+    }
+
+    if (!cfg.rows[rowIdx]) {
+      outputError(`Row ${rowIdx} does not exist`, "INVALID_ROW");
+    }
+
+    if (!Array.isArray(cfg.rows[rowIdx]!.panes)) {
+      outputError(`Invalid ide.yml: row ${rowIdx} panes must be an array`, "INVALID_CONFIG");
+    }
+
+    cfg.rows[rowIdx]!.panes.push(pane as Pane);
+  });
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, row: rowIdx, pane }, null, 2));
+  } else {
+    console.log(`Added pane "${title ?? "untitled"}" to row ${rowIdx}`);
+  }
+}
+
+function removePane(dir: string, args: string[], { json }: { json?: boolean }): void {
+  const { row, pane } = parseNamedArgs(args);
+  if (row === undefined || pane === undefined) {
+    outputError("Usage: tmux-ide config remove-pane --row <N> --pane <M>", "USAGE");
+    return;
+  }
+
+  const rowIdx = parseIndex(row);
+  const paneIdx = parseIndex(pane);
+  if (rowIdx == null || paneIdx == null) {
+    outputError("Usage: tmux-ide config remove-pane --row <N> --pane <M>", "USAGE");
+    return;
+  }
+
+  let removed: Pane | undefined;
+  withConfig(dir, (cfg) => {
+    if (!Array.isArray(cfg.rows)) {
+      outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+    }
+
+    if (!Array.isArray(cfg.rows[rowIdx]?.panes)) {
+      outputError(`Invalid ide.yml: row ${rowIdx} panes must be an array`, "INVALID_CONFIG");
+    }
+
+    if (!cfg.rows[rowIdx]!.panes[paneIdx]) {
+      outputError(`Pane ${paneIdx} in row ${rowIdx} does not exist`, "INVALID_PANE");
+    }
+
+    removed = cfg.rows[rowIdx]!.panes.splice(paneIdx, 1)[0];
+  });
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, row: rowIdx, pane: paneIdx, removed }, null, 2));
+  } else {
+    console.log(`Removed pane ${paneIdx} ("${removed?.title ?? "untitled"}") from row ${rowIdx}`);
+  }
+}
+
+function addRow(dir: string, args: string[], { json }: { json?: boolean }): void {
+  const { size } = parseNamedArgs(args);
+
+  let rowIdx: number | undefined;
+  withConfig(dir, (cfg) => {
+    if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
+      outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+    }
+
+    const row: Row = { panes: [{ title: "Shell" }] };
+    if (size) row.size = size;
+    cfg.rows = cfg.rows ?? [];
+    cfg.rows.push(row);
+    rowIdx = cfg.rows.length - 1;
+  });
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, row: rowIdx, size: size ?? null }, null, 2));
+  } else {
+    console.log(`Added row ${rowIdx}${size ? ` (${size})` : ""}`);
+  }
+}
+
+function enableTeam(dir: string, args: string[], { json }: { json?: boolean }): void {
+  const { name } = parseNamedArgs(args);
+
+  let teamName: string | undefined;
+  let result: { team: IdeConfig["team"]; roles: ReturnType<typeof summarizeRoles> } | undefined;
+  withConfig(dir, (cfg) => {
+    if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
+      outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+    }
+
+    teamName = name ?? cfg.name ?? "my-team";
+    cfg.team = { name: teamName };
+
+    let leadAssigned = false;
+    for (const row of cfg.rows ?? []) {
+      for (const pane of row.panes ?? []) {
+        if (pane.command === "claude" || pane.role === "lead" || pane.role === "teammate") {
+          if (!leadAssigned) {
+            pane.role = "lead";
+            leadAssigned = true;
+          } else {
+            pane.role = "teammate";
+          }
+        }
+      }
+    }
+    if (!leadAssigned) {
+      delete cfg.team;
+      outputError("Cannot enable agent team: no Claude panes found", "INVALID_CONFIG");
+    }
+
+    result = { team: cfg.team, roles: summarizeRoles(cfg) };
+  });
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+  } else {
+    console.log(`Enabled agent team "${teamName}"`);
+  }
+}
+
+function disableTeam(dir: string, { json }: { json?: boolean }): void {
+  withConfig(dir, (cfg) => {
+    if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
+      outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+    }
+
+    delete cfg.team;
+    for (const row of cfg.rows ?? []) {
+      if (!Array.isArray(row?.panes)) continue;
+      for (const pane of row.panes) {
+        delete pane.role;
+        delete pane.task;
+      }
+    }
+  });
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, disabled: true }, null, 2));
+  } else {
+    console.log("Disabled agent team");
+  }
+}
+
+function summarizeRoles(
+  cfg: IdeConfig,
+): { row: number; pane: number; title: string | null; role: string }[] {
+  const roles: { row: number; pane: number; title: string | null; role: string }[] = [];
+  for (let i = 0; i < (cfg.rows ?? []).length; i++) {
+    for (let j = 0; j < (cfg.rows[i]!.panes ?? []).length; j++) {
+      const p = cfg.rows[i]!.panes[j]!;
+      if (p.role) {
+        roles.push({ row: i, pane: j, title: p.title ?? null, role: p.role });
+      }
+    }
+  }
+  return roles;
+}
+
+function parseNamedArgs(args: string[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i]!.startsWith("--") && i + 1 < args.length) {
+      const key = args[i]!.slice(2);
+      result[key] = args[i + 1]!;
+      i++;
+    }
+  }
+  return result;
+}
+
+function isConfigObject(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+function parseIndex(value: string): number | null {
+  if (!/^\d+$/.test(String(value))) return null;
+  return Number.parseInt(value, 10);
+}