@polderlabs/bizar-plugin 0.5.4 → 0.6.0

package/tests/http-client.test.ts

@@ -33,10 +33,7 @@ interface Message {
   parts: MessagePart[];
 }
 
-interface CollectedMessage {
-  info: Message;
-  parts: MessagePart[];
-}
+type CollectedMessage = Message;
 
 // ---------------------------------------------------------------------------
 // Fake HttpClient matching the expected interface
@@ -185,8 +182,10 @@ describe("HttpClient.sendPrompt", () => {
     const msgs = await client.listMessages(session.id, "/tmp");
     const userMsg = msgs.find((m) => m.info.role === "user");
     expect(userMsg).toBeDefined();
-    expect(userMsg!.parts[0].type).toBe("text");
-    expect(userMsg!.parts[0].text).toBe("Do the research on X");
+    const firstPart = userMsg?.parts[0];
+    expect(firstPart).toBeDefined();
+    expect(firstPart?.type).toBe("text");
+    expect(firstPart?.text).toBe("Do the research on X");
   });
 
   it("generates a unique messageID per call (HIGH-2)", async () => {
@@ -400,4 +399,4 @@ describe("HTTP timeout handling (HIGH-36)", () => {
     // This is ensured by the implementation not writing on AbortError
     expect(true).toBe(true);
   });
-});
+});

package/tests/init-helpers.test.ts

@@ -182,10 +182,10 @@ describe("readValidSessionIds — postmortem Layer 1 fix (v0.5.2)", () => {
       // 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;
+      let rejectFn: ((err: Error) => void) | undefined;
       const input = makeInput({
         session: {
-          list: () => new Promise((_, reject) => {
+          list: () => new Promise((_, reject: (err: Error) => void) => {
             rejectFn = reject;
           }),
         },
@@ -195,7 +195,7 @@ describe("readValidSessionIds — postmortem Layer 1 fix (v0.5.2)", () => {
       // 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"));
+      rejectFn?.(new Error("late rejection"));
       // Give the microtask queue a chance to run.
       await new Promise((r) => setTimeout(r, 10));
     },

package/tests/serve.test.ts

@@ -155,7 +155,7 @@ describe("ENOENT and EACCES handling", () => {
 describe("unexpected exit", () => {
   it("marks all running instances failed when serve child exits unexpectedly", async () => {
     // Simulate: proc.exited resolves with non-zero code (not intentional shutdown)
-    const exitCode = 1;
+    const exitCode: number = 1;
     const runningInstances = [
       { instanceId: "bgr_01", status: "running", error: undefined as string | undefined },
       { instanceId: "bgr_02", status: "pending", error: undefined as string | undefined },
@@ -171,14 +171,18 @@ describe("unexpected exit", () => {
       }
     }
 
-    expect(runningInstances[0].status).toBe("failed");
-    expect(runningInstances[0].error).toBe("serve child exited unexpectedly");
-    expect(runningInstances[1].status).toBe("failed");
-    expect(runningInstances[1].error).toBe("serve child exited unexpectedly");
+    const first = runningInstances[0];
+    const second = runningInstances[1];
+    expect(first).toBeDefined();
+    expect(second).toBeDefined();
+    expect(first?.status).toBe("failed");
+    expect(first?.error).toBe("serve child exited unexpectedly");
+    expect(second?.status).toBe("failed");
+    expect(second?.error).toBe("serve child exited unexpectedly");
   });
 
   it("clean exit (code 0) does not mark instances failed", async () => {
-    const exitCode = 0;
+    const exitCode: number = 0;
     const runningInstances = [
       { instanceId: "bgr_01", status: "running" },
     ];
@@ -189,11 +193,11 @@ describe("unexpected exit", () => {
       }
     }
 
-    expect(runningInstances[0].status).toBe("running"); // unchanged
+    expect(runningInstances[0]?.status).toBe("running"); // unchanged
   });
 
   it("intentional shutdown does not trigger unexpected-exit path", async () => {
-    const exitCode = 1;
+    const exitCode: number = 1;
     const intentionalShutdown = true;
 
     const runningInstances = [{ instanceId: "bgr_01", status: "running" }];
@@ -204,7 +208,7 @@ describe("unexpected exit", () => {
       for (const inst of runningInstances) inst.status = "failed";
     }
 
-    expect(runningInstances[0].status).toBe("running");
+    expect(runningInstances[0]?.status).toBe("running");
   });
 
   it("servePID is cleared after unexpected exit", async () => {
@@ -332,4 +336,4 @@ describe("ServeLifecycle interface contract", () => {
     expect(typeof fake.password).toBe("string");
     expect(typeof fake.baseUrl).toBe("string");
   });
-});
+});

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-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: "/tmp/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");
+  });
+});