tmux-ide 2.1.5 → 2.6.1

package/src/lib/auth/auth-service.test.ts

@@ -1,178 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import * as crypto from "node:crypto";
-import { AuthService } from "./auth-service.ts";
-
-describe("AuthService", () => {
-  let auth: AuthService;
-  const SECRET = "test-secret-key-for-jwt";
-
-  beforeEach(() => {
-    auth = new AuthService(SECRET);
-  });
-
-  afterEach(() => {
-    auth.dispose();
-  });
-
-  // ---- JWT ----------------------------------------------------------------
-
-  describe("JWT sign/verify round-trip", () => {
-    it("generates and verifies a valid token", () => {
-      const token = auth.generateToken("alice");
-      const result = auth.verifyToken(token);
-      expect(result.valid).toBe(true);
-      expect(result.userId).toBe("alice");
-    });
-
-    it("works with different user IDs", () => {
-      const token = auth.generateToken("bob@example.com");
-      const result = auth.verifyToken(token);
-      expect(result.valid).toBe(true);
-      expect(result.userId).toBe("bob@example.com");
-    });
-  });
-
-  describe("expired token rejected", () => {
-    it("rejects a token with exp in the past", () => {
-      // Create a service with extremely short expiry by manipulating the token
-      // We'll manually craft a token with an expired timestamp
-      const header = Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" })).toString(
-        "base64url",
-      );
-      const payload = Buffer.from(
-        JSON.stringify({
-          userId: "alice",
-          iat: Math.floor(Date.now() / 1000) - 7200,
-          exp: Math.floor(Date.now() / 1000) - 3600, // expired 1 hour ago
-        }),
-      ).toString("base64url");
-      const sigInput = header + "." + payload;
-      const sig = crypto.createHmac("sha256", SECRET).update(sigInput).digest("base64url");
-      const expiredToken = `${header}.${payload}.${sig}`;
-
-      const result = auth.verifyToken(expiredToken);
-      expect(result.valid).toBe(false);
-    });
-  });
-
-  describe("tampered token rejected", () => {
-    it("rejects a token with modified payload", () => {
-      const token = auth.generateToken("alice");
-      const parts = token.split(".");
-
-      // Tamper with payload — change userId
-      const payload = JSON.parse(Buffer.from(parts[1]!, "base64url").toString());
-      payload.userId = "eve";
-      parts[1] = Buffer.from(JSON.stringify(payload)).toString("base64url");
-      const tampered = parts.join(".");
-
-      const result = auth.verifyToken(tampered);
-      expect(result.valid).toBe(false);
-    });
-
-    it("rejects a token with modified signature", () => {
-      const token = auth.generateToken("alice");
-      const parts = token.split(".");
-      // Flip a character in the signature
-      const sig = parts[2]!;
-      parts[2] = sig[0] === "A" ? "B" + sig.slice(1) : "A" + sig.slice(1);
-      const tampered = parts.join(".");
-
-      const result = auth.verifyToken(tampered);
-      expect(result.valid).toBe(false);
-    });
-
-    it("rejects a token signed with a different secret", () => {
-      const other = new AuthService("different-secret");
-      const token = other.generateToken("alice");
-      other.dispose();
-
-      const result = auth.verifyToken(token);
-      expect(result.valid).toBe(false);
-    });
-
-    it("rejects garbage strings", () => {
-      expect(auth.verifyToken("not.a.jwt").valid).toBe(false);
-      expect(auth.verifyToken("").valid).toBe(false);
-      expect(auth.verifyToken("only-one-part").valid).toBe(false);
-    });
-  });
-
-  // ---- SSH challenge-response -------------------------------------------
-
-  describe("SSH challenge with test keypair", () => {
-    // Generate an Ed25519 keypair for testing
-    function makeTestKey() {
-      const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
-
-      // Export raw 32-byte public key
-      const rawPub = publicKey.export({ type: "spki", format: "der" });
-      // Last 32 bytes of the DER encoding are the raw key
-      const raw32 = rawPub.subarray(rawPub.length - 32);
-
-      // Build SSH wire format: uint32(len) + "ssh-ed25519" + uint32(32) + raw32
-      const alg = Buffer.from("ssh-ed25519");
-      const algLenBuf = Buffer.alloc(4);
-      algLenBuf.writeUInt32BE(alg.length);
-      const keyLenBuf = Buffer.alloc(4);
-      keyLenBuf.writeUInt32BE(32);
-      const sshPubBuf = Buffer.concat([algLenBuf, alg, keyLenBuf, raw32]);
-      const sshPubStr = `ssh-ed25519 ${sshPubBuf.toString("base64")} test@test`;
-
-      return { publicKey, privateKey, sshPubStr };
-    }
-
-    it("creates a challenge and verifies a valid signature", async () => {
-      const { privateKey, sshPubStr } = makeTestKey();
-
-      // Create challenge
-      const { challengeId, challenge } = auth.createChallenge("testuser");
-      expect(challengeId).toBeTruthy();
-      expect(challenge).toBeTruthy();
-
-      // Sign the challenge
-      const challengeBuf = Buffer.from(challenge, "base64");
-      const signature = crypto.sign(null, challengeBuf, privateKey);
-
-      // authenticateWithSSHKey checks authorized_keys which won't exist in test,
-      // so we just verify the signature verification path works by checking
-      // that it gets past signature verification (fails at authorization)
-      const result = await auth.authenticateWithSSHKey({
-        publicKey: sshPubStr,
-        challengeId,
-        signature: signature.toString("base64"),
-      });
-
-      // Expect "not authorized" — which means signature verification passed
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("SSH key not authorized for this user");
-    });
-
-    it("rejects an invalid signature", async () => {
-      const { sshPubStr } = makeTestKey();
-
-      const { challengeId } = auth.createChallenge("testuser");
-
-      // Send garbage signature (wrong length for ed25519 = 64 bytes)
-      const result = await auth.authenticateWithSSHKey({
-        publicKey: sshPubStr,
-        challengeId,
-        signature: Buffer.alloc(64).toString("base64"),
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("Invalid SSH key signature");
-    });
-
-    it("rejects an expired/unknown challenge ID", async () => {
-      const result = await auth.authenticateWithSSHKey({
-        publicKey: "ssh-ed25519 AAAA test",
-        challengeId: "nonexistent-id",
-        signature: Buffer.alloc(64).toString("base64"),
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("Invalid or expired challenge");
-    });
-  });
-});

package/src/lib/auth/middleware.test.ts

@@ -1,119 +0,0 @@
-// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { Hono } from "hono";
-import { AuthService } from "./auth-service.ts";
-import { authMiddleware, validateWsToken } from "./middleware.ts";
-import type { AuthConfig } from "./types.ts";
-
-describe("authMiddleware", () => {
-  let auth: AuthService;
-  const SECRET = "test-middleware-secret";
-
-  beforeEach(() => {
-    auth = new AuthService(SECRET);
-  });
-
-  afterEach(() => {
-    auth.dispose();
-  });
-
-  function buildApp(config: AuthConfig): Hono {
-    const app = new Hono();
-    app.use("/*", authMiddleware(auth, config));
-    app.get("/health", (c) => c.json({ ok: true }));
-    app.get("/api/auth/challenge", (c) => c.json({ bypassed: true }));
-    app.get("/api/sessions", (c) => c.json({ sessions: [] }));
-    return app;
-  }
-
-  describe("method = none (backward compatible)", () => {
-    it("passes through all requests without auth", async () => {
-      const app = buildApp({ method: "none", token_expiry: 86400 });
-      const res = await app.request("/api/sessions");
-      expect(res.status).toBe(200);
-    });
-  });
-
-  describe("method = ssh", () => {
-    const config: AuthConfig = { method: "ssh", token_expiry: 86400 };
-
-    it("bypasses /health", async () => {
-      const app = buildApp(config);
-      const res = await app.request("/health");
-      expect(res.status).toBe(200);
-    });
-
-    it("bypasses /api/auth/* routes", async () => {
-      const app = buildApp(config);
-      const res = await app.request("/api/auth/challenge");
-      expect(res.status).toBe(200);
-      const body = await res.json();
-      expect(body.bypassed).toBe(true);
-    });
-
-    it("rejects requests without Authorization header", async () => {
-      const app = buildApp(config);
-      const res = await app.request("/api/sessions");
-      expect(res.status).toBe(401);
-    });
-
-    it("rejects requests with invalid token", async () => {
-      const app = buildApp(config);
-      const res = await app.request("/api/sessions", {
-        headers: { Authorization: "Bearer invalid-token" },
-      });
-      expect(res.status).toBe(401);
-    });
-
-    it("allows requests with valid token", async () => {
-      const app = buildApp(config);
-      const token = auth.generateToken("alice");
-      const res = await app.request("/api/sessions", {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-      expect(res.status).toBe(200);
-    });
-
-    it("rejects requests with non-Bearer auth", async () => {
-      const app = buildApp(config);
-      const res = await app.request("/api/sessions", {
-        headers: { Authorization: "Basic dXNlcjpwYXNz" },
-      });
-      expect(res.status).toBe(401);
-    });
-  });
-});
-
-describe("validateWsToken", () => {
-  let auth: AuthService;
-  const SECRET = "test-ws-secret";
-
-  beforeEach(() => {
-    auth = new AuthService(SECRET);
-  });
-
-  afterEach(() => {
-    auth.dispose();
-  });
-
-  it("returns 'anonymous' when method is none", () => {
-    const result = validateWsToken(auth, { method: "none", token_expiry: 86400 }, null);
-    expect(result).toBe("anonymous");
-  });
-
-  it("returns null when method is ssh and no token provided", () => {
-    const result = validateWsToken(auth, { method: "ssh", token_expiry: 86400 }, null);
-    expect(result).toBeNull();
-  });
-
-  it("returns userId for valid token", () => {
-    const token = auth.generateToken("bob");
-    const result = validateWsToken(auth, { method: "ssh", token_expiry: 86400 }, token);
-    expect(result).toBe("bob");
-  });
-
-  it("returns null for invalid token", () => {
-    const result = validateWsToken(auth, { method: "ssh", token_expiry: 86400 }, "bad-token");
-    expect(result).toBeNull();
-  });
-});

package/src/lib/authorship.test.ts

@@ -1,242 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import {
-  extractMarks,
-  embedMarks,
-  calculateStats,
-  createAuthored,
-  normalizeQuote,
-  reanchorMarks,
-  tagContent,
-  generateMarkId,
-  type Mark,
-  type MarksDocument,
-} from "./authorship.ts";
-
-describe("normalizeQuote", () => {
-  it("collapses whitespace", () => {
-    expect(normalizeQuote("  hello   world  ")).toBe("hello world");
-  });
-
-  it("handles newlines", () => {
-    expect(normalizeQuote("line1\n  line2\n")).toBe("line1 line2");
-  });
-});
-
-describe("generateMarkId", () => {
-  it("returns unique IDs", () => {
-    const a = generateMarkId();
-    const b = generateMarkId();
-    expect(a).not.toBe(b);
-    expect(a.startsWith("m")).toBeTruthy();
-  });
-});
-
-describe("createAuthored", () => {
-  it("creates a mark with correct fields", () => {
-    const mark = createAuthored("ai:François", { from: 0, to: 50 }, "some text");
-    expect(mark.kind).toBe("authored");
-    expect(mark.by).toBe("ai:François");
-    expect(mark.range.from).toBe(0);
-    expect(mark.range.to).toBe(50);
-    expect(mark.quote).toBe("some text");
-    expect(mark.id.startsWith("m")).toBeTruthy();
-    expect(mark.at.includes("T")).toBeTruthy(); // ISO timestamp
-  });
-});
-
-describe("extractMarks", () => {
-  it("extracts marks from markdown with comment block", () => {
-    const doc: MarksDocument = {
-      version: 2,
-      marks: {
-        m1: {
-          id: "m1",
-          kind: "authored",
-          by: "ai:François",
-          at: "2026-01-01T00:00:00Z",
-          range: { from: 0, to: 13 },
-          quote: "Hello world!",
-        },
-      },
-    };
-    const md = `Hello world!\n\n<!-- TMUX-IDE:MARKS\n${JSON.stringify(doc, null, 2)}\n-->\n`;
-
-    const result = extractMarks(md);
-    expect(result.marks).toBeTruthy();
-    expect(result.marks!.version).toBe(2);
-    expect(Object.keys(result.marks!.marks).length).toBe(1);
-    expect(result.marks!.marks["m1"]!.by).toBe("ai:François");
-    expect(result.content.includes("Hello world!")).toBeTruthy();
-    expect(!result.content.includes("TMUX-IDE:MARKS")).toBeTruthy();
-  });
-
-  it("returns null marks when no comment block", () => {
-    const md = "Just content.";
-    const result = extractMarks(md);
-    expect(result.marks).toBe(null);
-    expect(result.content).toBe(md);
-  });
-
-  it("handles malformed JSON gracefully", () => {
-    const md = "Content.\n\n<!-- TMUX-IDE:MARKS\nnot json\n-->\n";
-    const result = extractMarks(md);
-    expect(result.marks).toBe(null);
-  });
-});
-
-describe("embedMarks", () => {
-  it("appends marks comment to markdown", () => {
-    const md = "Hello world!";
-    const doc: MarksDocument = {
-      version: 2,
-      marks: {
-        m1: createAuthored("ai:François", { from: 0, to: 12 }, "Hello world!"),
-      },
-    };
-
-    const result = embedMarks(md, doc);
-    expect(result.includes("Hello world!")).toBeTruthy();
-    expect(result.includes("TMUX-IDE:MARKS")).toBeTruthy();
-    expect(result.includes("ai:François")).toBeTruthy();
-  });
-
-  it("replaces existing marks comment", () => {
-    const oldDoc: MarksDocument = { version: 2, marks: {} };
-    const md = `Content.\n\n<!-- TMUX-IDE:MARKS\n${JSON.stringify(oldDoc)}\n-->\n`;
-
-    const newDoc: MarksDocument = {
-      version: 2,
-      marks: {
-        m1: createAuthored("human:thijs", { from: 0, to: 8 }, "Content."),
-      },
-    };
-
-    const result = embedMarks(md, newDoc);
-    const count = (result.match(/TMUX-IDE:MARKS/g) || []).length;
-    expect(count).toBe(1);
-    expect(result.includes("human:thijs")).toBeTruthy();
-  });
-});
-
-describe("calculateStats", () => {
-  it("calculates AI vs human percentages from marks", () => {
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:François", { from: 0, to: 300 }, "ai text"),
-      m2: createAuthored("human:thijs", { from: 300, to: 500 }, "human text"),
-    };
-    const stats = calculateStats(marks);
-    expect(stats.totalChars).toBe(500);
-    expect(stats.aiPercent).toBe(60);
-    expect(stats.humanPercent).toBe(40);
-  });
-
-  it("returns 100% AI when all marks are AI", () => {
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:Amélie", { from: 0, to: 100 }, "text"),
-      m2: createAuthored("ai:Louis", { from: 100, to: 200 }, "more text"),
-    };
-    const stats = calculateStats(marks);
-    expect(stats.aiPercent).toBe(100);
-    expect(stats.humanPercent).toBe(0);
-  });
-
-  it("returns zeros for empty marks", () => {
-    const stats = calculateStats({});
-    expect(stats.totalChars).toBe(0);
-    expect(stats.aiPercent).toBe(0);
-  });
-
-  it("skips orphaned marks", () => {
-    const marks: Record<string, Mark> = {
-      m1: { ...createAuthored("ai:X", { from: 0, to: 100 }, "text"), orphaned: true },
-      m2: createAuthored("human:Y", { from: 0, to: 50 }, "text"),
-    };
-    const stats = calculateStats(marks);
-    expect(stats.totalChars).toBe(50);
-    expect(stats.humanPercent).toBe(100);
-  });
-
-  it("skips non-authored marks", () => {
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:X", { from: 0, to: 100 }, "text"),
-      m2: { ...createAuthored("human:Y", { from: 0, to: 50 }, "text"), kind: "comment" },
-    };
-    const stats = calculateStats(marks);
-    expect(stats.totalChars).toBe(100);
-    expect(stats.aiPercent).toBe(100);
-  });
-});
-
-describe("reanchorMarks", () => {
-  it("keeps marks with matching quotes at correct positions", () => {
-    const content = "Hello world!";
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:X", { from: 0, to: 12 }, "Hello world!"),
-    };
-    const result = reanchorMarks(content, marks);
-    expect(result["m1"]!.range.from).toBe(0);
-    expect(result["m1"]!.range.to).toBe(12);
-    expect(result["m1"]!.orphaned).toBe(undefined);
-  });
-
-  it("re-anchors marks when content shifts", () => {
-    // Content was "XHello" but now prefix was removed
-    const content = "Hello world!";
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:X", { from: 1, to: 13 }, "Hello world!"),
-    };
-    const result = reanchorMarks(content, marks);
-    expect(result["m1"]!.range.from).toBe(0);
-    expect(result["m1"]!.range.to).toBe(12);
-  });
-
-  it("orphans marks when quote not found", () => {
-    const content = "Completely different text.";
-    const marks: Record<string, Mark> = {
-      m1: createAuthored("ai:X", { from: 0, to: 12 }, "Hello world!"),
-    };
-    const result = reanchorMarks(content, marks);
-    expect(result["m1"]!.orphaned).toBe(true);
-  });
-});
-
-describe("tagContent", () => {
-  it("tags entire content as authored", () => {
-    const md = "Hello world!";
-    const result = tagContent(md, "ai:François");
-
-    const { marks } = extractMarks(result);
-    expect(marks).toBeTruthy();
-    const authored = Object.values(marks!.marks).filter((m) => m.kind === "authored");
-    expect(authored.length > 0).toBeTruthy();
-    expect(authored[0]!.by).toBe("ai:François");
-    expect(authored[0]!.range.from).toBe(0);
-    expect(authored[0]!.range.to).toBe(12);
-  });
-
-  it("preserves existing marks and only tags uncovered ranges", () => {
-    const existingMark = createAuthored("human:thijs", { from: 0, to: 5 }, "Hello");
-    const doc: MarksDocument = { version: 2, marks: { [existingMark.id]: existingMark } };
-    const md = embedMarks("Hello world!", doc);
-
-    const result = tagContent(md, "ai:Amélie");
-    const { marks } = extractMarks(result);
-    expect(marks).toBeTruthy();
-
-    const marksList = Object.values(marks!.marks).filter(
-      (m) => m.kind === "authored" && !m.orphaned,
-    );
-    // Should have human mark for "Hello" and AI mark for the rest
-    const humanMarks = marksList.filter((m) => m.by === "human:thijs");
-    const aiMarks = marksList.filter((m) => m.by === "ai:Amélie");
-    expect(humanMarks.length > 0).toBeTruthy();
-    expect(aiMarks.length > 0).toBeTruthy();
-  });
-
-  it("round-trips: extract after tag returns same content", () => {
-    const original = "Some plan content here.\n\n## Section Two\n\nMore content.";
-    const tagged = tagContent(original, "ai:Louis");
-    const { content } = extractMarks(tagged);
-    expect(content).toBe(original);
-  });
-});

package/src/lib/cast/recorder.test.ts

@@ -1,127 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { AsciicastRecorder } from "./recorder.ts";
-
-describe("AsciicastRecorder", () => {
-  let dir: string;
-
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "cast-test-"));
-  });
-
-  afterEach(() => {
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  it("creates recording directory", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "test-sess",
-      paneId: "%0",
-    });
-    // Starting will fail since no tmux is running, but the file should be created
-    try {
-      rec.start();
-      rec.stop();
-    } catch {
-      // expected in test environment
-    }
-
-    // The .tasks/recordings/ directory should have been created
-    // existsSync imported at top
-    expect(existsSync(join(dir, ".tasks", "recordings"))).toBe(true);
-  });
-
-  it("writes asciicast v2 header on start", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "test-sess",
-      paneId: "%0",
-      intervalMs: 60000, // long interval so timer doesn't fire
-    });
-
-    const filePath = rec.start();
-    rec.stop();
-
-    const content = readFileSync(filePath, "utf-8");
-    const lines = content.trim().split("\n");
-    expect(lines.length).toBeGreaterThanOrEqual(1);
-
-    const header = JSON.parse(lines[0]!);
-    expect(header.version).toBe(2);
-    expect(typeof header.width).toBe("number");
-    expect(typeof header.height).toBe("number");
-    expect(typeof header.timestamp).toBe("number");
-    expect(header.width).toBeGreaterThan(0);
-    expect(header.height).toBeGreaterThan(0);
-  });
-
-  it("getFilePath returns the .cast file path", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "my-session",
-      paneId: "%5",
-    });
-    const path = rec.start();
-    rec.stop();
-    expect(path).toBe(rec.getFilePath());
-    expect(path).toContain(".cast");
-    expect(path).toContain("my-session");
-    expect(path).toContain("5"); // %5 with % stripped
-  });
-
-  it("file is in .tasks/recordings/", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "s",
-      paneId: "%0",
-    });
-    const path = rec.start();
-    rec.stop();
-    expect(path).toContain(join(".tasks", "recordings"));
-  });
-
-  it("event lines follow asciicast v2 format", () => {
-    // We can't easily capture from a real tmux pane in tests, but we can
-    // verify the header format is correct and that stop doesn't throw.
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "fmt-test",
-      paneId: "%0",
-      intervalMs: 60000,
-    });
-    rec.start();
-    rec.stop();
-
-    const content = readFileSync(rec.getFilePath(), "utf-8");
-    const lines = content.trim().split("\n").filter(Boolean);
-
-    // First line is header
-    const header = JSON.parse(lines[0]!);
-    expect(header.version).toBe(2);
-
-    // Any subsequent lines should be [number, "o", string] arrays
-    for (const line of lines.slice(1)) {
-      const event = JSON.parse(line);
-      expect(Array.isArray(event)).toBe(true);
-      expect(event.length).toBe(3);
-      expect(typeof event[0]).toBe("number"); // elapsed seconds
-      expect(event[1]).toBe("o"); // output event type
-      expect(typeof event[2]).toBe("string"); // data
-    }
-  });
-
-  it("stop is idempotent", () => {
-    const rec = new AsciicastRecorder({
-      dir,
-      session: "s",
-      paneId: "%0",
-      intervalMs: 60000,
-    });
-    rec.start();
-    rec.stop();
-    rec.stop(); // should not throw
-  });
-});