@polderlabs/bizar 6.2.4 → 6.3.0

package/plugins/bizar/tests/attach-handler-bug.test.ts

@@ -1,169 +0,0 @@
-/**
- * attachEventHandler regression test (BUGFIX v0.5.1).
- *
- * BUG: InstanceManager.add() called attachEventHandler() with the draft's
- * sessionId, which is "" at the moment of add() (it's filled in later by
- * POST /session). EventStream.onSessionEvent threw
- * "sessionId must be non-empty" and the spawn failed before any HTTP.
- *
- * FIX: add() no longer attaches. bg-spawn.ts calls attachEventHandler()
- * AFTER POST /session returns the real sessionId.
- *
- * This test exercises the REAL InstanceManager + a fake-but-real EventStream
- * stub that enforces the same empty-string rejection the real one does.
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import os from "node:os";
-import path from "node:path";
-
-// --- Real InstanceManager (the one under test) ----------------------------
-
-// We import the real module. The test stub below mirrors only the bits of
-// EventStream that the bug actually exercises.
-
-// Use a tiny shim so we don't pull in serve.ts (which tries to spawn a child
-// process). The InstanceManager constructor accepts deps; we pass a minimal
-// stream stub and noop state/serve.
-
-interface FakeStreamHandler {
-  (ev: { type: string; [k: string]: unknown }): void;
-}
-
-class FakeEventStream {
-  private handlers = new Map<string, Set<FakeStreamHandler>>();
-  private staticHandler: ((ev: unknown) => void) | null = null;
-
-  onSessionEvent(sessionId: string, handler: FakeStreamHandler): () => void {
-    if (typeof sessionId !== "string" || sessionId.length === 0) {
-      throw new Error("EventStream.onSessionEvent: sessionId must be non-empty");
-    }
-    let set = this.handlers.get(sessionId);
-    if (!set) {
-      set = new Set();
-      this.handlers.set(sessionId, set);
-    }
-    set.add(handler);
-    return () => {
-      const s = this.handlers.get(sessionId);
-      if (!s) return;
-      s.delete(handler);
-      if (s.size === 0) this.handlers.delete(sessionId);
-    };
-  }
-
-  applyEvent(sessionId: string, ev: { type: string; [k: string]: unknown }): void {
-    const set = this.handlers.get(sessionId);
-    if (!set) return;
-    for (const h of set) h(ev);
-  }
-}
-
-class InMemoryStateStore {
-  private map = new Map<string, unknown>();
-  async save(state: unknown): Promise<void> {
-    const s = state as { instanceId: string };
-    this.map.set(s.instanceId, state);
-  }
-  async load(instanceId: string): Promise<unknown> {
-    return this.map.get(instanceId) ?? null;
-  }
-  async delete(instanceId: string): Promise<void> {
-    this.map.delete(instanceId);
-  }
-  async cleanup(_maxAgeDays: number, _validIds?: Set<string>): Promise<number> {
-    return 0;
-  }
-}
-
-// We import the real InstanceManager after the stubs are defined so the
-// test file fails fast if the real signature changes.
-import { InstanceManager } from "../src/background.js";
-import type { BackgroundState } from "../src/background-state.js";
-
-function makeDraft(overrides: Partial<BackgroundState> = {}): BackgroundState {
-  return {
-    instanceId: `bgr_test_${Math.random().toString(36).slice(2, 10)}`,
-    sessionId: "", // CRITICAL: add() is called with empty sessionId
-    agent: "mimir",
-    status: "pending",
-    startedAt: Date.now(),
-    model: "minimax/minimax-m3",
-    promptPreview: "test",
-    resultPreview: undefined,
-    resultMessageIds: [],
-    error: undefined,
-    parentAgent: "odin",
-    parentInstanceId: undefined,
-    logPath: path.join(os.tmpdir(), "test.log"),
-    timeoutMs: 300_000,
-    toolCallCount: 0,
-    loopGuardTool: undefined,
-    ...overrides,
-  };
-}
-
-describe("InstanceManager.add — empty sessionId (BUGFIX v0.5.1)", () => {
-  let stream: FakeEventStream;
-  let stateStore: InMemoryStateStore;
-  let mgr: InstanceManager;
-
-  beforeEach(() => {
-    stream = new FakeEventStream();
-    stateStore = new InMemoryStateStore();
-    // The real InstanceManager constructor takes a complex dep object.
-    // We pass the minimum: stateStore, serve (a stub), stream, etc.
-    // Since the real ctor signature is tightly coupled, we use a cast.
-    mgr = new InstanceManager({
-      stateStore: stateStore as never,
-      maxConcurrent: 8,
-      toolCallCap: 250,
-      logger: {
-        debug: () => {},
-        info: () => {},
-        warn: () => {},
-        error: () => {},
-      } as never,
-      worktree: os.tmpdir(),
-      serve: { worktree: os.tmpdir() } as never,
-      http: {} as never,
-      stream: stream as never,
-      stallTimeoutMs: 180_000,
-      thinkingLoopTimeoutMs: 300_000,
-      maxInterventions: 1,
-    });
-  });
-
-  it("add() with empty sessionId does NOT throw (BUGFIX)", async () => {
-    // Before the fix: this threw "EventStream.onSessionEvent: sessionId must be non-empty"
-    // After the fix: add() succeeds and no event handler is registered for the empty key.
-    const draft = makeDraft();
-    const result = await mgr.add(draft);
-    expect(result).not.toBe("cap_reached");
-    // The instance is in the map (track-BEFORE-HTTP invariant preserved)
-    const stored = await mgr.get(draft.instanceId);
-    expect(stored).not.toBeNull();
-    expect(stored?.instanceId).toBe(draft.instanceId);
-  });
-
-  it("attachEventHandler() throws on empty sessionId (regression: same guard as upstream)", () => {
-    // This proves the upstream guard still works — bg-spawn.ts must
-    // call attachEventHandler() only AFTER sessionId is set.
-    const draft = makeDraft();
-    expect(() => mgr.attachEventHandler(draft)).toThrow(
-      /sessionId must be non-empty/,
-    );
-  });
-
-  it("attachEventHandler() succeeds when sessionId is non-empty, then receives events", async () => {
-    const draft = makeDraft({ sessionId: "sess_real_123" });
-    // Real sessionId — should NOT throw
-    mgr.attachEventHandler(draft);
-    // And the event subscription should actually fire
-    let received = 0;
-    mgr.attachEventHandler({ ...draft, instanceId: "bgr_other" });
-    stream.applyEvent("sess_real_123", { type: "message.part.updated" });
-    received += 1;
-    expect(received).toBe(1);
-  });
-});

package/plugins/bizar/tests/background-state.test.ts

@@ -1,277 +0,0 @@
-/**
- * BackgroundState store tests.
- *
- * Covers: BackgroundState schema (§3.2), per-instance mutex (§3.3),
- * resultPreview truncation, resultMessageIds accumulation, restart scan
- * marking running/pending as failed (MEDIUM-39), and the withLock API.
- *
- * Uses an in-memory tmpdir so tests are fully deterministic.
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import path from "node:path";
-import fs from "node:fs";
-import os from "node:os";
-
-// ---------------------------------------------------------------------------
-// Re-export the types and functions we're testing (unit-under-test pattern)
-// ---------------------------------------------------------------------------
-// We import the as-yet-nonexistent module; tests document the expected API.
-// When the module is implemented by Tyr, these imports will resolve.
-// For now we use a local inline copy of the schema + helpers to test the
-// logic independently of the implementation file.
-
-import type {
-  BackgroundStatus,
-  BackgroundState,
-} from "../src/background-state.ts";
-
-// ---------------------------------------------------------------------------
-// Inline test-doubles that mirror the expected API from §3.2 / §3.3
-// ---------------------------------------------------------------------------
-
-const BG_DIR = path.join(os.tmpdir(), `bizar-bg-state-test-${Date.now()}`);
-
-/** Minimal BackgroundState factory for testing */
-function makeState(overrides: Partial<BackgroundState> = {}): BackgroundState {
-  return {
-    instanceId: "bgr_01ARSH3J5V0000000000000000",
-    sessionId: "sess_abc123",
-    agent: "mimir",
-    status: "running",
-    startedAt: Date.now(),
-    model: "minimax/minimax-m3",
-    promptPreview: "Do the thing",
-    resultPreview: undefined,
-    resultMessageIds: [],
-    error: undefined,
-    parentAgent: "odin",
-    parentInstanceId: undefined,
-    logPath: "~/.cache/bizar/logs/sess_abc123.log",
-    timeoutMs: 300_000,
-    toolCallCount: 0,
-    loopGuardTool: undefined,
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Schema validation tests (§3.2)
-// ---------------------------------------------------------------------------
-
-describe("BackgroundState schema", () => {
-  it("contains all required fields per §3.2", () => {
-    const s = makeState();
-    expect(typeof s.instanceId).toBe("string");
-    expect(typeof s.sessionId).toBe("string");
-    expect(typeof s.agent).toBe("string");
-    expect(typeof s.status).toBe("string");
-    expect(typeof s.startedAt).toBe("number");
-    expect(typeof s.model).toBe("string");
-    expect(typeof s.promptPreview).toBe("string");
-    expect(s.logPath).toBeTruthy();
-    expect(typeof s.timeoutMs).toBe("number");
-    expect(typeof s.toolCallCount).toBe("number");
-  });
-
-  it("accepts all six BackgroundStatus values", () => {
-    const statuses: BackgroundStatus[] = [
-      "pending",
-      "running",
-      "done",
-      "failed",
-      "killed",
-      "timed_out",
-    ];
-    for (const status of statuses) {
-      const s = makeState({ status });
-      expect(s.status).toBe(status);
-    }
-  });
-
-  it("resultPreview is truncated to last 200 chars", () => {
-    const long = "x".repeat(500);
-    const state = makeState({ resultPreview: long });
-    // The truncation happens in the SSE handler on EventMessagePartUpdated.
-    // Here we verify the rule: if resultPreview would be stored > 200 chars,
-    // only the last 200 are kept.
-    const stored = (state.resultPreview ?? "").slice(-200);
-    expect(stored.length).toBe(200);
-    expect(stored[0]).toBe("x"); // last 200 of 500 x's
-  });
-
-  it("resultMessageIds is the only full-text field — full text is NOT in JSON", () => {
-    const state = makeState({
-      resultMessageIds: ["msg_01", "msg_02"],
-      // resultPreview stores only last 200 chars, not full text
-      resultPreview: "partial...",
-    });
-    // Verify resultMessageIds exists and is an array
-    expect(Array.isArray(state.resultMessageIds)).toBe(true);
-    expect(state.resultMessageIds!.length).toBe(2);
-  });
-
-  it("error is set on terminal failure; cleared on retry (not yet implemented)", () => {
-    const failed = makeState({ status: "failed", error: "serve child exited unexpectedly" });
-    expect(failed.error).toBe("serve child exited unexpectedly");
-    // Clearing on retry is a future concern; v0.4.1 does not retry
-  });
-
-  it("parentInstanceId is undefined in v0.4.1 (nested spawn not exposed)", () => {
-    const s = makeState();
-    expect(s.parentInstanceId).toBeUndefined();
-  });
-
-  it("loopGuardTool is undefined until threshold-12 is captured", () => {
-    const s = makeState();
-    expect(s.loopGuardTool).toBeUndefined();
-    const withLoop = makeState({
-      loopGuardTool: "read",
-      error: "Loop protection: 12 identical calls to read",
-      status: "failed",
-    });
-    expect(withLoop.loopGuardTool).toBe("read");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Restart scan tests (MEDIUM-39) — mocking the rebuildInMemoryMap logic
-// ---------------------------------------------------------------------------
-
-describe("restart scan", () => {
-  it("running instance is marked failed on restart", () => {
-    const running = makeState({ status: "running" });
-    // Simulate the restart scan logic from §5.4
-    const scanned =
-      running.status === "running" || running.status === "pending"
-        ? { ...running, status: "failed" as BackgroundStatus, error: "plugin restarted; serve child is new", completedAt: Date.now() }
-        : running;
-    expect(scanned.status).toBe("failed");
-    expect(scanned.error).toContain("plugin restarted");
-  });
-
-  it("pending instance is marked failed on restart", () => {
-    const pending = makeState({ status: "pending" });
-    const scanned =
-      pending.status === "running" || pending.status === "pending"
-        ? { ...pending, status: "failed" as BackgroundStatus, error: "plugin restarted while instance was pending", completedAt: Date.now() }
-        : pending;
-    expect(scanned.status).toBe("failed");
-    expect(scanned.error).toContain("pending");
-  });
-
-  it("done instance is preserved as-is on restart", () => {
-    const done = makeState({ status: "done", completedAt: Date.now() });
-    const scanned =
-      done.status === "running" || done.status === "pending"
-        ? { ...done, status: "failed" as BackgroundStatus, error: "plugin restarted", completedAt: Date.now() }
-        : done;
-    expect(scanned.status).toBe("done");
-  });
-
-  it("failed instance is preserved as-is on restart", () => {
-    const failed = makeState({ status: "failed", error: "something went wrong", completedAt: Date.now() });
-    const scanned =
-      failed.status === "running" || failed.status === "pending"
-        ? { ...failed, status: "failed" as BackgroundStatus, error: "plugin restarted", completedAt: Date.now() }
-        : failed;
-    expect(scanned.status).toBe("failed");
-    expect(scanned.error).toBe("something went wrong");
-  });
-
-  it("killed instance is preserved as-is on restart", () => {
-    const killed = makeState({ status: "killed", completedAt: Date.now() });
-    const scanned =
-      killed.status === "running" || killed.status === "pending"
-        ? { ...killed, status: "failed" as BackgroundStatus, error: "plugin restarted", completedAt: Date.now() }
-        : killed;
-    expect(scanned.status).toBe("killed");
-  });
-
-  it("timed_out instance is preserved as-is on restart", () => {
-    const timed = makeState({ status: "timed_out", completedAt: Date.now() });
-    const scanned =
-      timed.status === "running" || timed.status === "pending"
-        ? { ...timed, status: "failed" as BackgroundStatus, error: "plugin restarted", completedAt: Date.now() }
-        : timed;
-    expect(scanned.status).toBe("timed_out");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Per-instance mutex tests (§3.3) — 10 concurrent writes preserve all changes
-// ---------------------------------------------------------------------------
-
-describe("per-instance mutex serialisation", () => {
-  // Simulate the withInstanceLock pattern from §3.3
-  const locks = new Map<string, Promise<unknown>>();
-
-  async function withInstanceLock<T>(instanceId: string, fn: () => Promise<T>): Promise<T> {
-    const prev = locks.get(instanceId) ?? Promise.resolve();
-    const next = prev.then(fn, fn);
-    locks.set(instanceId, next.catch(() => {}));
-    return next;
-  }
-
-  it("serialises writes per instanceId", async () => {
-    const instanceId = "bgr_mutex_test";
-    const results: number[] = [];
-
-    const writes = Array.from({ length: 10 }, (_, i) =>
-      withInstanceLock(instanceId, async () => {
-        await Bun.sleep(1); // tiny delay to increase chance of race if not locked
-        results.push(i);
-        return i;
-      }),
-    );
-
-    const all = await Promise.all(writes);
-    expect(all).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-    // Results are accumulated in order because the mutex serialises them
-    expect(results).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-  });
-
-  it("different instanceIds do not block each other", async () => {
-    const results: string[] = [];
-
-    await Promise.all(
-      ["a", "b", "c"].map((id) =>
-        withInstanceLock(id, async () => {
-          await Bun.sleep(5);
-          results.push(id);
-          return id;
-        }),
-      ),
-    );
-
-    // All three should complete in roughly the same time (no cross-instance blocking)
-    expect(results.length).toBe(3);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Status translation table tests (§1.6)
-// ---------------------------------------------------------------------------
-
-describe("status translation", () => {
-  it("maps EventSessionIdle → done", () => {
-    expect("done").toBeTruthy(); // placeholder — real mapping tested in SSE tests
-  });
-
-  it("maps busy/retry → running", () => {
-    const runningStatuses = ["running"];
-    expect(runningStatuses).toContain("running");
-  });
-
-  it("maps EventSessionError → failed", () => {
-    expect("failed").toBeTruthy();
-  });
-
-  it("bizar_kill → killed", () => {
-    expect("killed").toBeTruthy();
-  });
-
-  it("timeoutMs reached → timed_out", () => {
-    expect("timed_out").toBeTruthy();
-  });
-});