@polderlabs/bizar-plugin 0.5.4

package/tests/init-helpers.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Init-helpers regression tests (v0.5.2).
+ *
+ * Covers the postmortem-2026-06-18 Layer 1 fix: `client.session.list()`
+ * is now raced against a 1-second timeout. Without this, a slow or
+ * broken session store would hang the plugin's `init()` forever and
+ * stall the UI on a blank screen.
+ *
+ * Two layers of test:
+ *   1) `withTimeout` — pure unit tests on the timeout helper itself.
+ *   2) `readValidSessionIds` — integration-style test that passes a
+ *      fake `PluginInput` whose `client.session.list()` never resolves
+ *      and verifies that the function returns within ~1.1s.
+ *
+ * The second test is what would have caught the original bug: the
+ * function must NOT block forever on a slow session store.
+ */
+
+import { describe, test, expect } from "bun:test";
+
+import {
+  withTimeout,
+  readValidSessionIds,
+} from "../index.js";
+
+// ---------------------------------------------------------------------------
+// `withTimeout` — pure unit tests
+// ---------------------------------------------------------------------------
+
+describe("withTimeout", () => {
+  test("resolves with the promise's value when it completes in time", async () => {
+    const result = await withTimeout(
+      Promise.resolve("ok"),
+      1000,
+      "test",
+    );
+    expect(result).toBe("ok");
+  });
+
+  test("rejects with a labeled error when the promise takes too long", async () => {
+    const hanging = new Promise<string>(() => {
+      // never resolves
+    });
+    const start = Date.now();
+    let caught: Error | null = null;
+    try {
+      await withTimeout(hanging, 100, "hanging-promise");
+    } catch (err) {
+      caught = err as Error;
+    }
+    const elapsed = Date.now() - start;
+    expect(caught).not.toBeNull();
+    expect(caught?.message).toContain("hanging-promise");
+    expect(caught?.message).toContain("100ms");
+    // Should fire within ~100ms (allow 50ms of slack for event-loop jitter).
+    expect(elapsed).toBeGreaterThanOrEqual(95);
+    expect(elapsed).toBeLessThan(500);
+  });
+
+  test("propagates rejections from the underlying promise", async () => {
+    const failing = Promise.reject(new Error("underlying failure"));
+    let caught: Error | null = null;
+    try {
+      await withTimeout(failing, 1000, "test");
+    } catch (err) {
+      caught = err as Error;
+    }
+    expect(caught).not.toBeNull();
+    expect(caught?.message).toBe("underlying failure");
+  });
+
+  test("clears the timer on success (no late rejection)", async () => {
+    // Resolve after 50ms, well within the 1000ms timeout. The timer
+    // should be cleared; we can't directly observe the cleanup, but
+    // the test verifies the function returns the value without ever
+    // throwing (the cleared timer's callback never fires).
+    const result = await withTimeout(
+      new Promise((resolve) => setTimeout(() => resolve("late"), 50)),
+      1000,
+      "test",
+    );
+    expect(result).toBe("late");
+    // Wait long enough that a leaked timer would have fired.
+    await new Promise((r) => setTimeout(r, 100));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// `readValidSessionIds` — the postmortem Layer 1 fix
+// ---------------------------------------------------------------------------
+
+/**
+ * Minimal `PluginInput` shape for testing `readValidSessionIds`. We
+ * only need `client`; the other fields are never read by the
+ * function under test.
+ */
+function makeInput(client: unknown): { client: unknown } {
+  return { client } as never;
+}
+
+describe("readValidSessionIds — postmortem Layer 1 fix (v0.5.2)", () => {
+  test("returns the session IDs when client.session.list() resolves", async () => {
+    const input = makeInput({
+      session: {
+        list: async () => ({
+          data: [
+            { id: "ses_a" },
+            { id: "ses_b" },
+          ],
+        }),
+      },
+    });
+    const ids = await readValidSessionIds(input as never);
+    expect(ids).toBeInstanceOf(Set);
+    expect([...ids].sort()).toEqual(["ses_a", "ses_b"]);
+  });
+
+  test("returns the session IDs when client.session.list() returns an array directly", async () => {
+    const input = makeInput({
+      session: {
+        list: async () => [{ id: "ses_x" }, { id: "ses_y" }],
+      },
+    });
+    const ids = await readValidSessionIds(input as never);
+    expect([...ids].sort()).toEqual(["ses_x", "ses_y"]);
+  });
+
+  test("returns empty set when client.session is missing", async () => {
+    const input = makeInput({});
+    const ids = await readValidSessionIds(input as never);
+    expect(ids.size).toBe(0);
+  });
+
+  test("returns empty set when client.session.list is not a function", async () => {
+    const input = makeInput({ session: { list: "not-a-function" } });
+    const ids = await readValidSessionIds(input as never);
+    expect(ids.size).toBe(0);
+  });
+
+  test("returns empty set when client.session.list() rejects", async () => {
+    const input = makeInput({
+      session: {
+        list: async () => {
+          throw new Error("session store down");
+        },
+      },
+    });
+    const ids = await readValidSessionIds(input as never);
+    expect(ids.size).toBe(0);
+  });
+
+  test(
+    "REGRESSION: returns within 1.5s when client.session.list() hangs forever (postmortem Layer 1)",
+    async () => {
+      // This is the actual bug from the 2026-06-18 postmortem. Before
+      // the fix, the call would hang forever and the plugin's `init()`
+      // would never resolve.
+      const input = makeInput({
+        session: {
+          list: () => new Promise(() => {
+            // never resolves — simulates a stuck session store
+          }),
+        },
+      });
+      const start = Date.now();
+      const ids = await readValidSessionIds(input as never);
+      const elapsed = Date.now() - start;
+      // The function should return within ~1s (the timeout). We allow
+      // 500ms of slack for event-loop jitter.
+      expect(elapsed).toBeLessThan(1500);
+      // The fallback is an empty set — the age-based cleanup still
+      // runs (spec §4.6).
+      expect(ids.size).toBe(0);
+    },
+  );
+
+  test(
+    "REGRESSION: late rejection from hanging list() does not crash the process",
+    async () => {
+      // After the 1s timeout fires, the original `list()` call may
+      // eventually reject (or it may never). The function attaches a
+      // no-op `.catch(() => undefined)` to suppress the unhandled-
+      // rejection. We can't directly observe unhandled rejections in
+      // bun:test, but we can verify the function returns cleanly.
+      let rejectFn: ((err: Error) => void) | null = null;
+      const input = makeInput({
+        session: {
+          list: () => new Promise((_, reject) => {
+            rejectFn = reject;
+          }),
+        },
+      });
+      const ids = await readValidSessionIds(input as never);
+      expect(ids.size).toBe(0);
+      // Now reject the hanging promise AFTER the function returned.
+      // If the no-op catch is missing, this would be an unhandled
+      // rejection. With it, the process keeps running.
+      if (rejectFn) rejectFn(new Error("late rejection"));
+      // Give the microtask queue a chance to run.
+      await new Promise((r) => setTimeout(r, 10));
+    },
+  );
+});

package/tests/integration/slash-command.test.ts

@@ -0,0 +1,348 @@
+/**
+ * slash-command.test.ts — Integration tests for the full slash-command
+ * hook → parser → side-effect → file-I/O path.
+ *
+ * Exercises:
+ *   - `/plan new foo` → `plans/foo/meta.json` + `plans/foo/plan.json` on disk
+ *   - `/plan list` → response contains slugs of seeded plans
+ *   - `/plan add foo --title X --type task` → element written to `plan.json`
+ *   - `/plan status foo approved` → `meta.json` status updated
+ *   - `/plan delete foo <elementId>` → element removed from `plan.json`
+ *   - `/plan wait foo` → deferred response (< 100 ms, no blocking)
+ *   - `/plan new foo` on existing slug → refusal, no clobber
+ *   - `/plan comment foo "text"` → comment written to `plan.json`
+ *   - `/plan comments foo` → response lists the comment
+ */
+
+import { describe, test, expect, beforeEach, afterEach, afterAll } from "bun:test";
+import {
+  mkdtempSync,
+  rmSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { parseSlashCommand } from "../../src/commands";
+import {
+  executeSideEffect,
+  type ExecutorContext,
+  type ExecuteOptions,
+} from "../../src/commands-impl";
+import { createPlanActionTool } from "../../src/tools/plan-action";
+import { createBgGetCommentsTool } from "../../src/tools/bg-get-comments";
+import { createWaitForFeedbackTool } from "../../src/tools/wait-for-feedback";
+import { DEFAULT_PLAN_SETTINGS, type PlanSettings } from "../../src/settings";
+
+// ---------------------------------------------------------------------------
+// Mock logger
+// ---------------------------------------------------------------------------
+
+class MockLogger {
+  messages: Array<{ level: string; message: string }> = [];
+  log(opts: { level: string; message: string }) { this.messages.push(opts); }
+  debug(m: string) { this.messages.push({ level: "debug", message: m }); }
+  info(m: string) { this.messages.push({ level: "info", message: m }); }
+  warn(m: string) { this.messages.push({ level: "warn", message: m }); }
+  error(m: string) { this.messages.push({ level: "error", message: m }); }
+}
+
+// ---------------------------------------------------------------------------
+// Per-test temp worktree
+// ---------------------------------------------------------------------------
+
+let worktree: string;
+let logger: MockLogger;
+
+beforeEach(() => {
+  worktree = mkdtempSync(join(tmpdir(), "bizar-integration-"));
+  logger = new MockLogger();
+});
+
+afterEach(() => {
+  if (worktree) rmSync(worktree, { recursive: true, force: true });
+});
+
+afterAll(() => {
+  // already cleaned in afterEach, but keep for safety
+  if (worktree) rmSync(worktree, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// Helper: build minimal ExecutorContext + ExecuteOptions
+// ---------------------------------------------------------------------------
+
+function makeCtx(): ExecutorContext {
+  return { worktree, directory: worktree, logger };
+}
+
+function makeOpts(): ExecuteOptions {
+  return {
+    tools: {
+      bizar_plan_action: createPlanActionTool({ worktree, logger }),
+      bizar_get_plan_comments: createBgGetCommentsTool({ worktree, logger }),
+      bizar_wait_for_feedback: createWaitForFeedbackTool({ worktree, logger }),
+    },
+    defaultTemplate: "blank",
+    defaultPort: 4321,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Test cases
+// ---------------------------------------------------------------------------
+
+describe("integration: /plan new", () => {
+  test("/plan new foo → creates plans/foo/meta.json and plan.json with correct content", async () => {
+    const result = parseSlashCommand("/plan new foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: [],
+      defaultPort: 4321,
+    });
+    expect(result).not.toBeNull();
+    expect(result!.sideEffect!.kind).toBe("create_plan");
+
+    await executeSideEffect(result!.sideEffect!, makeCtx(), makeOpts());
+
+    const metaPath = join(worktree, "plans", "foo", "meta.json");
+    const planPath = join(worktree, "plans", "foo", "plan.json");
+    expect(existsSync(metaPath)).toBe(true);
+    expect(existsSync(planPath)).toBe(true);
+
+    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    expect(meta.status).toBe("draft");
+    expect(meta.slug).toBeUndefined(); // slug not stored, title is titleCase
+    expect(typeof meta.lastEdited).toBe("string");
+
+    const canvas = JSON.parse(readFileSync(planPath, "utf-8"));
+    expect(canvas.schemaVersion).toBe(2);
+    expect(canvas.elements).toEqual([]);
+    expect(canvas.connections).toEqual([]);
+    expect(canvas.comments).toEqual([]);
+  });
+});
+
+describe("integration: /plan list", () => {
+  test("/plan list after creating foo and bar → response contains both slugs", async () => {
+    // Seed two plans
+    for (const slug of ["foo", "bar"]) {
+      const r = parseSlashCommand(`/plan new ${slug}`, {
+        currentSettings: DEFAULT_PLAN_SETTINGS,
+        availablePlanSlugs: [],
+        defaultPort: 4321,
+      });
+      await executeSideEffect(r!.sideEffect!, makeCtx(), makeOpts());
+    }
+
+    const listResult = parseSlashCommand("/plan list", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo", "bar"],
+      defaultPort: 4321,
+    });
+    expect(listResult).not.toBeNull();
+    const execResult = await executeSideEffect(listResult!.sideEffect!, makeCtx(), makeOpts());
+    const response = execResult.responseOverride ?? listResult!.response;
+    expect(response).toMatch(/foo/);
+    expect(response).toMatch(/bar/);
+  });
+});
+
+describe("integration: /plan add", () => {
+  test("/plan add foo --title X --type task → plan.json contains the element", async () => {
+    // First create the plan
+    const newR = parseSlashCommand("/plan new foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: [],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
+
+    // Now add an element
+    const addR = parseSlashCommand('/plan add foo --title X --type task', {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo"],
+      defaultPort: 4321,
+    });
+    expect(addR).not.toBeNull();
+    expect(addR!.sideEffect!.kind).toBe("tool_invocation");
+    const execR = await executeSideEffect(addR!.sideEffect!, makeCtx(), makeOpts());
+
+    const planPath = join(worktree, "plans", "foo", "plan.json");
+    const canvas = JSON.parse(readFileSync(planPath, "utf-8"));
+    expect(canvas.elements).toHaveLength(1);
+    expect(canvas.elements[0]!.title).toBe("X");
+    expect(canvas.elements[0]!.type).toBe("task");
+  });
+});
+
+describe("integration: /plan status", () => {
+  test("/plan status foo approved → meta.json status is approved", async () => {
+    // Create the plan first
+    const newR = parseSlashCommand("/plan new foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: [],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
+
+    const statusR = parseSlashCommand("/plan status foo approved", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo"],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(statusR!.sideEffect!, makeCtx(), makeOpts());
+
+    const metaPath = join(worktree, "plans", "foo", "meta.json");
+    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    expect(meta.status).toBe("approved");
+  });
+});
+
+describe("integration: /plan delete", () => {
+  test("/plan delete foo <elementId> → element removed from plan.json", async () => {
+    // Create plan and add an element
+    const newR = parseSlashCommand("/plan new foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: [],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
+
+    const addR = parseSlashCommand('/plan add foo --title Elem1 --type task', {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo"],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(addR!.sideEffect!, makeCtx(), makeOpts());
+
+    // Read back to get element id
+    const planPath = join(worktree, "plans", "foo", "plan.json");
+    let canvas = JSON.parse(readFileSync(planPath, "utf-8")) as {
+      elements: Array<{ id: string; title: string }>;
+    };
+    expect(canvas.elements).toHaveLength(1);
+    const elementId = canvas.elements[0]!.id;
+
+    // Now delete it
+    const delR = parseSlashCommand(`/plan delete foo ${elementId}`, {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo"],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(delR!.sideEffect!, makeCtx(), makeOpts());
+
+    canvas = JSON.parse(readFileSync(planPath, "utf-8"));
+    expect(canvas.elements).toHaveLength(0);
+  });
+});
+
+describe("integration: /plan wait", () => {
+  test("/plan wait foo → returns deferred response, does NOT block hook (< 100ms)", async () => {
+    const r = parseSlashCommand("/plan wait foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo"],
+      defaultPort: 4321,
+    });
+    expect(r).not.toBeNull();
+    expect(r!.response).toMatch(/deferred/i);
+    expect(r!.response).toMatch(/bizar_wait_for_feedback/);
+    expect(r!.sideEffect).toBeUndefined(); // wait is NOT a tool_invocation
+
+    // Verify it returns instantly (no async I/O)
+    const start = Date.now();
+    await executeSideEffect({ kind: "list_plans" }, makeCtx(), makeOpts()); // no-op
+    const elapsed = Date.now() - start;
+    expect(elapsed).toBeLessThan(100);
+  });
+});
+
+describe("integration: /plan new on existing slug", () => {
+  test("/plan new foo on existing slug → refusal response, existing files intact", async () => {
+    // Create the plan
+    const r1 = parseSlashCommand("/plan new foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: [],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(r1!.sideEffect!, makeCtx(), makeOpts());
+
+    const planDir = join(worktree, "plans", "foo");
+    const metaBefore = readFileSync(join(planDir, "meta.json"), "utf-8");
+    const planBefore = readFileSync(join(planDir, "plan.json"), "utf-8");
+
+    // Try to create again
+    const r2 = parseSlashCommand("/plan new foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo"],
+      defaultPort: 4321,
+    });
+    const execR = await executeSideEffect(r2!.sideEffect!, makeCtx(), makeOpts());
+
+    // Should have refused
+    expect(execR.responseOverride).toMatch(/already exists/);
+
+    // Files should be unchanged
+    expect(readFileSync(join(planDir, "meta.json"), "utf-8")).toBe(metaBefore);
+    expect(readFileSync(join(planDir, "plan.json"), "utf-8")).toBe(planBefore);
+  });
+});
+
+describe("integration: /plan comment", () => {
+  test('/plan comment foo "first comment" → plan.json contains the comment', async () => {
+    // Create the plan first
+    const newR = parseSlashCommand("/plan new foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: [],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
+
+    const commentR = parseSlashCommand('/plan comment foo "first comment"', {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo"],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(commentR!.sideEffect!, makeCtx(), makeOpts());
+
+    const planPath = join(worktree, "plans", "foo", "plan.json");
+    const canvas = JSON.parse(readFileSync(planPath, "utf-8")) as {
+      comments: Array<{ id: string; text: string; author: string }>;
+    };
+    expect(canvas.comments).toHaveLength(1);
+    expect(canvas.comments[0]!.text).toBe("first comment");
+    expect(canvas.comments[0]!.author).toBe("user");
+  });
+});
+
+describe("integration: /plan comments", () => {
+  test("/plan comments foo → response lists the comment", async () => {
+    // Create the plan first
+    const newR = parseSlashCommand("/plan new foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: [],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
+
+    // Add a comment
+    const commentR = parseSlashCommand('/plan comment foo "Hello world"', {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo"],
+      defaultPort: 4321,
+    });
+    await executeSideEffect(commentR!.sideEffect!, makeCtx(), makeOpts());
+
+    // Now list comments
+    const listR = parseSlashCommand("/plan comments foo", {
+      currentSettings: DEFAULT_PLAN_SETTINGS,
+      availablePlanSlugs: ["foo"],
+      defaultPort: 4321,
+    });
+    const execR = await executeSideEffect(listR!.sideEffect!, makeCtx(), makeOpts());
+    const response = execR.responseOverride ?? listR!.response;
+    expect(response).toMatch(/Hello world/);
+  });
+});