tmux-ide 1.2.1 → 2.0.0

package/src/lib/workflow-store.ts

@@ -0,0 +1,209 @@
+import { join } from "node:path";
+import {
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  unlinkSync,
+  renameSync,
+} from "node:fs";
+import { getTasksRoot } from "./task-store.ts";
+
+const SCHEMA_VERSION = 1;
+
+function atomicWriteJSON(filePath: string, data: unknown): void {
+  const tmpPath = filePath + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(data, null, 2) + "\n");
+  renameSync(tmpPath, filePath);
+}
+
+// MARK: - Checkpoint
+
+export interface Checkpoint {
+  id: string;
+  taskId: string;
+  title: string;
+  description: string;
+  status: "pending" | "approved" | "rejected";
+  createdBy: string;
+  reviewedBy: string | null;
+  created: string;
+  updated: string;
+  diff: string | null;
+  files: string[];
+  comments: string[];
+}
+
+function checkpointsDir(dir: string): string {
+  return join(getTasksRoot(dir), "checkpoints");
+}
+
+function ensureCheckpointsDir(dir: string): void {
+  const d = checkpointsDir(dir);
+  if (!existsSync(d)) mkdirSync(d, { recursive: true });
+}
+
+export function nextCheckpointId(dir: string): string {
+  const d = checkpointsDir(dir);
+  if (!existsSync(d)) return "001";
+  const files = readdirSync(d).filter((f) => f.endsWith(".json"));
+  if (files.length === 0) return "001";
+  const maxId = Math.max(...files.map((f) => parseInt(f.split("-")[0]!, 10) || 0));
+  return String(maxId + 1).padStart(3, "0");
+}
+
+function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 50);
+}
+
+export function loadCheckpoints(dir: string): Checkpoint[] {
+  const d = checkpointsDir(dir);
+  if (!existsSync(d)) return [];
+  return readdirSync(d)
+    .filter((f) => f.endsWith(".json"))
+    .sort()
+    .map((f) => {
+      try {
+        return JSON.parse(readFileSync(join(d, f), "utf-8")) as Checkpoint;
+      } catch {
+        return null;
+      }
+    })
+    .filter((c): c is Checkpoint => c !== null);
+}
+
+export function loadCheckpoint(dir: string, id: string): Checkpoint | null {
+  const d = checkpointsDir(dir);
+  if (!existsSync(d)) return null;
+  const file = readdirSync(d).find((f) => f.startsWith(id + "-") || f === id + ".json");
+  if (!file) return null;
+  try {
+    return JSON.parse(readFileSync(join(d, file), "utf-8")) as Checkpoint;
+  } catch {
+    return null;
+  }
+}
+
+export function loadCheckpointsForTask(dir: string, taskId: string): Checkpoint[] {
+  return loadCheckpoints(dir).filter((c) => c.taskId === taskId);
+}
+
+export function saveCheckpoint(dir: string, checkpoint: Checkpoint): void {
+  ensureCheckpointsDir(dir);
+  const d = checkpointsDir(dir);
+  const filename = `${checkpoint.id}-${slugify(checkpoint.title)}.json`;
+  const newPath = join(d, filename);
+  // Remove old file if slug changed
+  const existing = readdirSync(d).find(
+    (f) => f.startsWith(checkpoint.id + "-") || f === checkpoint.id + ".json",
+  );
+  atomicWriteJSON(newPath, { _version: SCHEMA_VERSION, ...checkpoint });
+  if (existing && join(d, existing) !== newPath) unlinkSync(join(d, existing));
+}
+
+export function deleteCheckpoint(dir: string, id: string): boolean {
+  const d = checkpointsDir(dir);
+  if (!existsSync(d)) return false;
+  const file = readdirSync(d).find((f) => f.startsWith(id + "-") || f === id + ".json");
+  if (!file) return false;
+  unlinkSync(join(d, file));
+  return true;
+}
+
+// MARK: - Review Request
+
+export interface ReviewRequest {
+  id: string;
+  taskId: string;
+  checkpointId: string | null;
+  title: string;
+  description: string;
+  status: "open" | "approved" | "changes-requested" | "closed";
+  requestedBy: string;
+  reviewer: string | null;
+  created: string;
+  updated: string;
+  comments: ReviewComment[];
+}
+
+export interface ReviewComment {
+  author: string;
+  body: string;
+  created: string;
+}
+
+function reviewsDir(dir: string): string {
+  return join(getTasksRoot(dir), "reviews");
+}
+
+function ensureReviewsDir(dir: string): void {
+  const d = reviewsDir(dir);
+  if (!existsSync(d)) mkdirSync(d, { recursive: true });
+}
+
+export function nextReviewId(dir: string): string {
+  const d = reviewsDir(dir);
+  if (!existsSync(d)) return "001";
+  const files = readdirSync(d).filter((f) => f.endsWith(".json"));
+  if (files.length === 0) return "001";
+  const maxId = Math.max(...files.map((f) => parseInt(f.split("-")[0]!, 10) || 0));
+  return String(maxId + 1).padStart(3, "0");
+}
+
+export function loadReviews(dir: string): ReviewRequest[] {
+  const d = reviewsDir(dir);
+  if (!existsSync(d)) return [];
+  return readdirSync(d)
+    .filter((f) => f.endsWith(".json"))
+    .sort()
+    .map((f) => {
+      try {
+        return JSON.parse(readFileSync(join(d, f), "utf-8")) as ReviewRequest;
+      } catch {
+        return null;
+      }
+    })
+    .filter((r): r is ReviewRequest => r !== null);
+}
+
+export function loadReview(dir: string, id: string): ReviewRequest | null {
+  const d = reviewsDir(dir);
+  if (!existsSync(d)) return null;
+  const file = readdirSync(d).find((f) => f.startsWith(id + "-") || f === id + ".json");
+  if (!file) return null;
+  try {
+    return JSON.parse(readFileSync(join(d, file), "utf-8")) as ReviewRequest;
+  } catch {
+    return null;
+  }
+}
+
+export function loadReviewsForTask(dir: string, taskId: string): ReviewRequest[] {
+  return loadReviews(dir).filter((r) => r.taskId === taskId);
+}
+
+export function saveReview(dir: string, review: ReviewRequest): void {
+  ensureReviewsDir(dir);
+  const d = reviewsDir(dir);
+  const filename = `${review.id}-${slugify(review.title)}.json`;
+  const newPath = join(d, filename);
+  const existing = readdirSync(d).find(
+    (f) => f.startsWith(review.id + "-") || f === review.id + ".json",
+  );
+  atomicWriteJSON(newPath, { _version: SCHEMA_VERSION, ...review });
+  if (existing && join(d, existing) !== newPath) unlinkSync(join(d, existing));
+}
+
+export function deleteReview(dir: string, id: string): boolean {
+  const d = reviewsDir(dir);
+  if (!existsSync(d)) return false;
+  const file = readdirSync(d).find((f) => f.startsWith(id + "-") || f === id + ".json");
+  if (!file) return false;
+  unlinkSync(join(d, file));
+  return true;
+}

package/src/lib/ws-v3/protocol.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect } from "bun:test";
+import {
+  WS_V3_VERSION,
+  WsV3MessageType,
+  encodeWsV3Frame,
+  decodeWsV3Frame,
+  encodeWsV3SubscribePayload,
+  decodeWsV3SubscribePayload,
+  encodeWsV3ResizePayload,
+  decodeWsV3ResizePayload,
+} from "./protocol.ts";
+
+const allMessageTypes = Object.values(WsV3MessageType).filter(
+  (v): v is WsV3MessageType => typeof v === "number",
+);
+
+describe("ws-v3 protocol", () => {
+  it("encode/decode round-trip for each frame type with session + payload", () => {
+    const payload = new TextEncoder().encode("payload-bytes");
+    for (const type of allMessageTypes) {
+      const encoded = encodeWsV3Frame({
+        type,
+        sessionId: `sess-${type}`,
+        payload,
+      });
+      const decoded = decodeWsV3Frame(encoded);
+      expect(decoded).not.toBeNull();
+      expect(decoded!.type).toBe(type);
+      expect(decoded!.sessionId).toBe(`sess-${type}`);
+      expect(Buffer.from(decoded!.payload).equals(Buffer.from(payload))).toBe(true);
+    }
+  });
+
+  it("round-trip with empty session id and empty payload", () => {
+    const encoded = encodeWsV3Frame({
+      type: WsV3MessageType.PING,
+      sessionId: "",
+      payload: new Uint8Array(),
+    });
+    const decoded = decodeWsV3Frame(encoded);
+    expect(decoded).toEqual({
+      type: WsV3MessageType.PING,
+      sessionId: "",
+      payload: new Uint8Array(),
+    });
+  });
+
+  it("defaults sessionId and payload to empty", () => {
+    const encoded = encodeWsV3Frame({ type: WsV3MessageType.HELLO });
+    expect(decodeWsV3Frame(encoded)).toEqual({
+      type: WsV3MessageType.HELLO,
+      sessionId: "",
+      payload: new Uint8Array(),
+    });
+  });
+
+  it("returns null for invalid magic bytes", () => {
+    const buf = encodeWsV3Frame({ type: WsV3MessageType.HELLO });
+    buf[0] ^= 0xff;
+    expect(decodeWsV3Frame(buf)).toBeNull();
+  });
+
+  it("returns null for wrong version", () => {
+    const buf = encodeWsV3Frame({ type: WsV3MessageType.HELLO });
+    buf[2] = WS_V3_VERSION + 1;
+    expect(decodeWsV3Frame(buf)).toBeNull();
+  });
+
+  it("returns null when buffer is shorter than fixed header", () => {
+    expect(decodeWsV3Frame(new Uint8Array(10))).toBeNull();
+  });
+
+  it("returns null on truncated frame (fragmented input): missing sessionId bytes", () => {
+    const full = encodeWsV3Frame({
+      type: WsV3MessageType.STDOUT,
+      sessionId: "abc",
+      payload: new Uint8Array([1, 2]),
+    });
+    for (let len = 0; len < full.byteLength; len++) {
+      const partial = full.subarray(0, len);
+      const d = decodeWsV3Frame(partial);
+      if (len < full.byteLength) {
+        expect(d).toBeNull();
+      } else {
+        expect(d).not.toBeNull();
+      }
+    }
+  });
+
+  it("subscribe payload encode/decode round-trip", () => {
+    const p = encodeWsV3SubscribePayload({
+      flags: 7,
+      snapshotMinIntervalMs: 100,
+      snapshotMaxIntervalMs: 500,
+    });
+    expect(decodeWsV3SubscribePayload(p)).toEqual({
+      flags: 7,
+      snapshotMinIntervalMs: 100,
+      snapshotMaxIntervalMs: 500,
+    });
+  });
+
+  it("subscribe decode returns null when payload too short", () => {
+    expect(decodeWsV3SubscribePayload(new Uint8Array(11))).toBeNull();
+  });
+
+  it("resize payload encode/decode round-trip", () => {
+    const p = encodeWsV3ResizePayload(120, 40);
+    expect(decodeWsV3ResizePayload(p)).toEqual({ cols: 120, rows: 40 });
+  });
+
+  it("resize decode returns null when payload too short", () => {
+    expect(decodeWsV3ResizePayload(new Uint8Array(4))).toBeNull();
+  });
+
+  it("decode uses byteOffset/byteLength (subarray of larger buffer)", () => {
+    const inner = encodeWsV3Frame({
+      type: WsV3MessageType.PONG,
+      sessionId: "x",
+      payload: new Uint8Array(),
+    });
+    const padded = new Uint8Array(inner.byteLength + 4);
+    padded.set(inner, 2);
+    const slice = padded.subarray(2, 2 + inner.byteLength);
+    expect(decodeWsV3Frame(slice)).not.toBeNull();
+  });
+});

package/src/lib/ws-v3/protocol.ts

@@ -0,0 +1,160 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+
+/**
+ * WebSocket v3 framing for terminal transport.
+ *
+ * Frame:
+ *   u16  magic = 0x5654 ("VT") LE
+ *   u8   version = 3
+ *   u8   type
+ *   u32  sessionIdLen LE
+ *   u8[] sessionId UTF-8
+ *   u32  payloadLen LE
+ *   u8[] payload
+ */
+
+export const WS_V3_MAGIC = 0x5654;
+export const WS_V3_VERSION = 3;
+
+export enum WsV3MessageType {
+  HELLO = 1,
+  WELCOME = 2,
+
+  SUBSCRIBE = 10,
+  UNSUBSCRIBE = 11,
+
+  STDOUT = 20,
+  SNAPSHOT_VT = 21,
+  EVENT = 22,
+  ERROR = 23,
+
+  INPUT_TEXT = 30,
+  INPUT_KEY = 31,
+  RESIZE = 32,
+  KILL = 33,
+  RESET_SIZE = 34,
+
+  PING = 40,
+  PONG = 41,
+}
+
+export type WsV3DecodedFrame = {
+  type: WsV3MessageType;
+  sessionId: string;
+  payload: Uint8Array;
+};
+
+export function encodeWsV3Frame(params: {
+  type: WsV3MessageType;
+  sessionId?: string;
+  payload?: Uint8Array;
+}): Uint8Array {
+  const sessionId = params.sessionId ?? "";
+  const encoder = new TextEncoder();
+  const sessionIdBytes = encoder.encode(sessionId);
+  const payload = params.payload ?? new Uint8Array();
+
+  const headerLen = 2 + 1 + 1 + 4 + sessionIdBytes.length + 4;
+  const out = new Uint8Array(headerLen + payload.length);
+  const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+
+  let offset = 0;
+  view.setUint16(offset, WS_V3_MAGIC, true);
+  offset += 2;
+  view.setUint8(offset, WS_V3_VERSION);
+  offset += 1;
+  view.setUint8(offset, params.type);
+  offset += 1;
+
+  view.setUint32(offset, sessionIdBytes.length, true);
+  offset += 4;
+  out.set(sessionIdBytes, offset);
+  offset += sessionIdBytes.length;
+
+  view.setUint32(offset, payload.length, true);
+  offset += 4;
+  out.set(payload, offset);
+
+  return out;
+}
+
+export function decodeWsV3Frame(data: Uint8Array): WsV3DecodedFrame | null {
+  if (data.byteLength < 2 + 1 + 1 + 4 + 4) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 0;
+
+  const magic = view.getUint16(offset, true);
+  offset += 2;
+  if (magic !== WS_V3_MAGIC) return null;
+
+  const version = view.getUint8(offset);
+  offset += 1;
+  if (version !== WS_V3_VERSION) return null;
+
+  const type = view.getUint8(offset) as WsV3MessageType;
+  offset += 1;
+
+  const sessionIdLen = view.getUint32(offset, true);
+  offset += 4;
+  if (offset + sessionIdLen > data.byteLength) return null;
+  const sessionIdBytes = data.subarray(offset, offset + sessionIdLen);
+  const sessionId = new TextDecoder().decode(sessionIdBytes);
+  offset += sessionIdLen;
+
+  if (offset + 4 > data.byteLength) return null;
+  const payloadLen = view.getUint32(offset, true);
+  offset += 4;
+  if (offset + payloadLen > data.byteLength) return null;
+
+  const payload = data.subarray(offset, offset + payloadLen);
+  return { type, sessionId, payload };
+}
+
+export enum WsV3SubscribeFlags {
+  Stdout = 1 << 0,
+  Snapshots = 1 << 1,
+  Events = 1 << 2,
+}
+
+export function encodeWsV3SubscribePayload(params: {
+  flags: number;
+  snapshotMinIntervalMs?: number;
+  snapshotMaxIntervalMs?: number;
+}): Uint8Array {
+  const out = new Uint8Array(12);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, params.flags >>> 0, true);
+  view.setUint32(4, (params.snapshotMinIntervalMs ?? 0) >>> 0, true);
+  view.setUint32(8, (params.snapshotMaxIntervalMs ?? 0) >>> 0, true);
+  return out;
+}
+
+export function decodeWsV3SubscribePayload(payload: Uint8Array): {
+  flags: number;
+  snapshotMinIntervalMs: number;
+  snapshotMaxIntervalMs: number;
+} | null {
+  if (payload.byteLength < 12) return null;
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  return {
+    flags: view.getUint32(0, true),
+    snapshotMinIntervalMs: view.getUint32(4, true),
+    snapshotMaxIntervalMs: view.getUint32(8, true),
+  };
+}
+
+export function encodeWsV3ResizePayload(cols: number, rows: number): Uint8Array {
+  const out = new Uint8Array(8);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, cols >>> 0, true);
+  view.setUint32(4, rows >>> 0, true);
+  return out;
+}
+
+export function decodeWsV3ResizePayload(
+  payload: Uint8Array,
+): { cols: number; rows: number } | null {
+  if (payload.byteLength < 8) return null;
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  return { cols: view.getUint32(0, true), rows: view.getUint32(4, true) };
+}

package/src/lib/yaml-io.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, basename } from "node:path";
+import { readConfig, writeConfig, getSessionName } from "./yaml-io.ts";
+import type { IdeConfig } from "../types.ts";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-yaml-test-"));
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("writeConfig + readConfig", () => {
+  it("round-trips a config object", () => {
+    const config: IdeConfig = {
+      name: "test-project",
+      rows: [
+        {
+          size: "70%",
+          panes: [
+            { title: "Claude", command: "claude", role: "lead", focus: true },
+            { title: "Shell", command: "zsh" },
+          ],
+        },
+        {
+          panes: [{ title: "Dev", command: "pnpm dev" }],
+        },
+      ],
+    };
+
+    writeConfig(tmpDir, config);
+    const { config: loaded, configPath } = readConfig(tmpDir);
+
+    expect(loaded.name).toBe("test-project");
+    expect(loaded.rows.length).toBe(2);
+    expect(loaded.rows[0]!.size).toBe("70%");
+    expect(loaded.rows[0]!.panes.length).toBe(2);
+    expect(loaded.rows[0]!.panes[0]!.title).toBe("Claude");
+    expect(loaded.rows[0]!.panes[0]!.role).toBe("lead");
+    expect(loaded.rows[0]!.panes[0]!.focus).toBe(true);
+    expect(configPath.endsWith("ide.yml")).toBeTruthy();
+  });
+
+  it("preserves theme config", () => {
+    const config: IdeConfig = {
+      rows: [{ panes: [{}] }],
+      theme: { accent: "colour75", border: "colour238" },
+    };
+
+    writeConfig(tmpDir, config);
+    const { config: loaded } = readConfig(tmpDir);
+    expect(loaded.theme?.accent).toBe("colour75");
+    expect(loaded.theme?.border).toBe("colour238");
+  });
+
+  it("preserves orchestrator config", () => {
+    const config: IdeConfig = {
+      rows: [{ panes: [{}] }],
+      orchestrator: {
+        enabled: true,
+        auto_dispatch: true,
+        stall_timeout: 300000,
+        dispatch_mode: "goals",
+      },
+    };
+
+    writeConfig(tmpDir, config);
+    const { config: loaded } = readConfig(tmpDir);
+    expect(loaded.orchestrator?.enabled).toBe(true);
+    expect(loaded.orchestrator?.dispatch_mode).toBe("goals");
+  });
+
+  it("preserves team config", () => {
+    const config: IdeConfig = {
+      rows: [{ panes: [{}] }],
+      team: { name: "my-team", model: "opus", permissions: ["read", "write"] },
+    };
+
+    writeConfig(tmpDir, config);
+    const { config: loaded } = readConfig(tmpDir);
+    expect(loaded.team?.name).toBe("my-team");
+    expect(loaded.team?.model).toBe("opus");
+    expect(loaded.team?.permissions).toEqual(["read", "write"]);
+  });
+});
+
+describe("readConfig", () => {
+  it("throws when no ide.yml exists", () => {
+    expect(() => readConfig(tmpDir)).toThrow();
+  });
+
+  it("throws on malformed YAML", () => {
+    writeFileSync(join(tmpDir, "ide.yml"), ": invalid: yaml: [");
+    expect(() => readConfig(tmpDir)).toThrow();
+  });
+});
+
+describe("getSessionName", () => {
+  it("returns name from config", () => {
+    const config: IdeConfig = { name: "my-project", rows: [{ panes: [{}] }] };
+    writeConfig(tmpDir, config);
+    const result = getSessionName(tmpDir);
+    expect(result.name).toBe("my-project");
+    expect(result.source).toBe("config");
+  });
+
+  it("falls back to directory basename when no name in config", () => {
+    const config: IdeConfig = { rows: [{ panes: [{}] }] };
+    writeConfig(tmpDir, config);
+    const result = getSessionName(tmpDir);
+    expect(result.name).toBe(basename(tmpDir));
+    expect(result.source).toBe("fallback");
+  });
+
+  it("falls back to directory basename when no config file", () => {
+    const result = getSessionName(tmpDir);
+    expect(result.name).toBe(basename(tmpDir));
+    expect(result.source).toBe("fallback");
+  });
+});

package/src/lib/{yaml-io.js → yaml-io.ts}

@@ -1,22 +1,23 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { resolve, basename } from "node:path";
 import yaml from "js-yaml";
+import type { IdeConfig } from "../types.ts";
 
-export function readConfig(dir) {
+export function readConfig(dir: string): { config: IdeConfig; configPath: string } {
   const configPath = resolve(dir, "ide.yml");
   const raw = readFileSync(configPath, "utf-8");
-  const config = yaml.load(raw);
+  const config = yaml.load(raw) as IdeConfig;
   return { config, configPath };
 }
 
-export function writeConfig(dir, config) {
+export function writeConfig(dir: string, config: IdeConfig): string {
   const configPath = resolve(dir, "ide.yml");
   const out = yaml.dump(config, { lineWidth: -1, noRefs: true, quotingType: '"' });
   writeFileSync(configPath, out);
   return configPath;
 }
 
-export function getSessionName(dir) {
+export function getSessionName(dir: string): { name: string; source: "config" | "fallback" } {
   try {
     const { config } = readConfig(dir);
     return { name: config.name ?? basename(dir), source: config.name ? "config" : "fallback" };