@polderlabs/bizar-plugin 0.5.4 → 0.6.1

package/tests/state.test.ts

@@ -9,6 +9,7 @@ import { describe, test, expect, beforeEach, afterEach } from "bun:test";
 import { StateStore, SessionState, EMPTY_STATE } from "../src/state";
 import { mkdirSync, rmSync, writeFileSync, existsSync, utimesSync } from "node:fs";
 import path from "node:path";
+import os from "node:os";
 
 // Minimal mock logger that collects all messages
 class MockLogger {
@@ -18,7 +19,7 @@ class MockLogger {
   }
 }
 
-const TEST_DIR = "/tmp/bizar-state-test";
+const TEST_DIR = path.join(os.tmpdir(), "bizar-state-test");
 const TEST_SESSION_A = "session-a-123";
 const TEST_SESSION_B = "session-b-456";
 

package/tests/tools/bg-get-comments.test.ts

@@ -31,7 +31,7 @@ import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { readPlanComments } from "../../src/tools/bg-get-comments.ts";
+import { readPlanComments } from "../../src/tools/bg-get-comments.js";
 
 // ---------------------------------------------------------------------------
 // Fixtures / helpers
@@ -482,4 +482,4 @@ describe("readPlanComments — thread replies", () => {
       expect(result.comments[0]?.thread).toBeUndefined();
     }
   });
-});
+});

package/tests/tools/bg-kill.test.ts

@@ -121,16 +121,20 @@ describe("bizar_kill — POST /session/{id}/abort (HIGH-4)", () => {
     const instances = makeInstances();
     bizar_kill({ instanceId: "bgr_running" }, instances);
     expect(httpCalls).toHaveLength(1);
-    expect(httpCalls[0].method).toBe("POST");
-    expect(httpCalls[0].path).toContain("/abort");
+    const first = httpCalls[0];
+    expect(first).toBeDefined();
+    expect(first?.method).toBe("POST");
+    expect(first?.path).toContain("/abort");
   });
 
   it("calls POST /session/{id}/abort for pending instance", () => {
     const instances = makeInstances();
     bizar_kill({ instanceId: "bgr_pending" }, instances);
     expect(httpCalls).toHaveLength(1);
-    expect(httpCalls[0].method).toBe("POST");
-    expect(httpCalls[0].path).toContain("/abort");
+    const first = httpCalls[0];
+    expect(first).toBeDefined();
+    expect(first?.method).toBe("POST");
+    expect(first?.path).toContain("/abort");
   });
 
   it("does NOT call DELETE /session/{id} (HIGH-4)", () => {
@@ -228,4 +232,4 @@ describe("bizar_kill — unknown instance", () => {
     expect(result).toHaveProperty("error");
     expect((result as { error: string }).error).toContain("not found");
   });
-});
+});

package/tests/tools/bg-spawn.test.ts

@@ -27,13 +27,13 @@ function parseModel(model: string | undefined): { providerID: string; modelID: s
   const parts = model.split("/");
   if (parts.length !== 2) {
     throw new Error(
-      `model must be in "providerID/modelID" format (e.g. "minimax/MiniMax-M3"). Omit to use the agent's default.`,
+      `model must be in "providerID/modelID" format (e.g. "openrouter/minimax-m3"). Omit to use the agent's default.`,
     );
   }
   const [providerID, modelID] = parts;
   if (!providerID || !modelID) {
     throw new Error(
-      `model must be in "providerID/modelID" format (e.g. "minimax/MiniMax-M3"). Omit to use the agent's default.`,
+      `model must be in "providerID/modelID" format (e.g. "openrouter/minimax-m3"). Omit to use the agent's default.`,
     );
   }
   return { providerID, modelID };
@@ -132,9 +132,9 @@ describe("bizar_spawn_background — Odin-only", () => {
 // ---------------------------------------------------------------------------
 
 describe("bizar_spawn_background — model parsing (HIGH-3, LOW-34)", () => {
-  it('"minimax/MiniMax-M3" parses to { providerID: "minimax", modelID: "MiniMax-M3" }', () => {
-    const result = parseModel("minimax/MiniMax-M3");
-    expect(result).toEqual({ providerID: "minimax", modelID: "MiniMax-M3" });
+  it('"openrouter/minimax-m3" parses to { providerID: "openrouter", modelID: "minimax-m3" }', () => {
+    const result = parseModel("openrouter/minimax-m3");
+    expect(result).toEqual({ providerID: "openrouter", modelID: "minimax-m3" });
   });
 
   it('"opencode/deepseek-v4-flash-free" parses correctly', () => {
@@ -142,20 +142,20 @@ describe("bizar_spawn_background — model parsing (HIGH-3, LOW-34)", () => {
     expect(result).toEqual({ providerID: "opencode", modelID: "deepseek-v4-flash-free" });
   });
 
-  it('"MiniMax-M3" (no /) is rejected', () => {
-    expect(() => parseModel("MiniMax-M3")).toThrow();
+  it('"minimax-m3" (no /) is rejected', () => {
+    expect(() => parseModel("minimax-m3")).toThrow();
   });
 
   it('"a/b/c" (multiple /) is rejected', () => {
     expect(() => parseModel("a/b/c")).toThrow();
   });
 
-  it('"minimax/" (empty modelID) is rejected', () => {
-    expect(() => parseModel("minimax/")).toThrow();
+  it('"openrouter/" (empty modelID) is rejected', () => {
+    expect(() => parseModel("openrouter/")).toThrow();
   });
 
-  it('"/MiniMax-M3" (empty providerID) is rejected', () => {
-    expect(() => parseModel("/MiniMax-M3")).toThrow();
+  it('"/minimax-m3" (empty providerID) is rejected', () => {
+    expect(() => parseModel("/minimax-m3")).toThrow();
   });
 
   it("undefined model returns undefined (agent uses its default)", () => {
@@ -168,7 +168,7 @@ describe("bizar_spawn_background — model parsing (HIGH-3, LOW-34)", () => {
 
   it("spawn tool includes parsed model in POST /session body", () => {
     const result = bizarre_spawn_background(
-      { agent: "mimir", prompt: "Do X", model: "minimax/MiniMax-M3" },
+      { agent: "mimir", prompt: "Do X", model: "openrouter/minimax-m3" },
       { agent: "odin", sessionID: "sess_parent", worktree: "/tmp" },
     );
     expect(result).not.toHaveProperty("error");

package/tests/tools/bg-status.test.ts

@@ -16,6 +16,7 @@ interface BackgroundState {
   agent: string;
   status: "pending" | "running" | "done" | "failed" | "killed" | "timed_out";
   startedAt: number;
+  completedAt?: number;
   toolCallCount: number;
   promptPreview: string;
   resultPreview?: string;
@@ -213,4 +214,4 @@ describe("bizar_status — durationMs", () => {
     const expectedDuration = completedAt - startedAt;
     expect(expectedDuration).toBe(30_000);
   });
-});
+});

package/tests/tools/plan-action.test.ts

@@ -36,7 +36,7 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { planAction } from "../../src/tools/plan-action.ts";
+import { planAction } from "../../src/tools/plan-action.js";
 
 // ---------------------------------------------------------------------------
 // Fixtures
@@ -596,4 +596,4 @@ describe("planAction — unknown action", () => {
     expect(r.ok).toBe(false);
     if (!r.ok) expect(r.error).toMatch(/Unknown action/);
   });
-});
+});

package/tests/tools/wait-for-feedback.test.ts

@@ -28,7 +28,7 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { waitForFeedback } from "../../src/tools/wait-for-feedback.ts";
+import { waitForFeedback } from "../../src/tools/wait-for-feedback.js";
 
 // ---------------------------------------------------------------------------
 // Fixtures
@@ -387,4 +387,4 @@ describe("waitForFeedback — missing plan", () => {
       expect(r.error).toMatch(/Plan not found/);
     }
   });
-});
+});

package/tests/update-deadlock.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Regression tests for the background-state mutex.
+ *
+ * BUG: `InstanceManager.update()` acquired the per-instance lock and then
+ * called `BackgroundStateStore.save()`, which tried to acquire the same lock
+ * again. That nested re-entry never resolved, so startup deadlocked while
+ * `rebuildInMemoryMap()` tried to mark pending/running instances failed.
+ */
+
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { InstanceManager, type AddDraft } from "../src/background.js";
+import {
+  BackgroundStateStore,
+  type BackgroundState,
+} from "../src/background-state.js";
+
+const TEST_DIRS: string[] = [];
+
+const logger = {
+  log: () => {},
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+};
+
+class FakeEventStream {
+  onSessionEvent(): () => void {
+    return () => {};
+  }
+}
+
+function makeTempStateDir(): string {
+  const dir = mkdtempSync(path.join(os.tmpdir(), "bizar-update-deadlock-"));
+  TEST_DIRS.push(dir);
+  return dir;
+}
+
+function makeDraft(overrides: Partial<AddDraft> = {}): AddDraft {
+  return {
+    instanceId: "bgr_deadlock_test",
+    sessionId: "",
+    agent: "odin",
+    model: "agent-default",
+    promptPreview: "Investigate startup deadlock",
+    resultPreview: undefined,
+    resultMessageIds: undefined,
+    error: undefined,
+    parentAgent: "odin",
+    parentInstanceId: undefined,
+    logPath: path.join(os.tmpdir(), "bgr_deadlock_test.log"),
+    timeoutMs: 30_000,
+    toolCallCount: 0,
+    loopGuardTool: undefined,
+    lastEventAt: undefined,
+    lastToolOrTextAt: undefined,
+    interventionCount: undefined,
+    interventionAt: undefined,
+    interventionReason: undefined,
+    ...overrides,
+  };
+}
+
+function createManager(stateDir: string): {
+  manager: InstanceManager;
+  stateStore: BackgroundStateStore;
+} {
+  const stateStore = new BackgroundStateStore(stateDir, logger);
+  const manager = new InstanceManager({
+    stateStore,
+    maxConcurrent: 8,
+    toolCallCap: 250,
+    logger,
+    serve: { worktree: "/tmp" } as never,
+    http: {} as never,
+    stream: new FakeEventStream() as never,
+    stallTimeoutMs: 180_000,
+    thinkingLoopTimeoutMs: 300_000,
+    maxInterventions: 1,
+  });
+  manager.disablePeriodicChecks();
+  return { manager, stateStore };
+}
+
+async function settleWithin<T>(promise: Promise<T>, timeoutMs: number): Promise<T | "timeout"> {
+  return await Promise.race([
+    promise,
+    new Promise<"timeout">((resolve) => {
+      setTimeout(() => resolve("timeout"), timeoutMs);
+    }),
+  ]);
+}
+
+afterEach(() => {
+  for (const dir of TEST_DIRS.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("InstanceManager.update mutex regression", () => {
+  it("resolves and persists instead of deadlocking on nested save", async () => {
+    const stateDir = makeTempStateDir();
+    const { manager, stateStore } = createManager(stateDir);
+    const draft = makeDraft();
+
+    await manager.add(draft);
+
+    const result = await settleWithin(
+      manager.update(draft.instanceId, {
+        status: "failed",
+        error: "plugin restarted while instance was pending",
+      }),
+      250,
+    );
+
+    expect(result).not.toBe("timeout");
+
+    const stored = await stateStore.load(draft.instanceId);
+    expect(stored?.status).toBe("failed");
+  });
+
+  it("rebuildInMemoryMap marks a pending instance failed without hanging", async () => {
+    const stateDir = makeTempStateDir();
+    const { manager, stateStore } = createManager(stateDir);
+    const pendingState: BackgroundState = {
+      ...makeDraft(),
+      status: "pending",
+      startedAt: Date.now(),
+    };
+
+    await stateStore.save(pendingState);
+
+    const result = await settleWithin(manager.rebuildInMemoryMap(), 250);
+
+    expect(result).not.toBe("timeout");
+
+    const stored = await stateStore.load(pendingState.instanceId);
+    expect(stored?.error).toBe("plugin restarted while instance was pending");
+  });
+});