gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/packages/pi-coding-agent/src/core/resolve-config-value.test.ts

@@ -38,20 +38,21 @@ describe("resolveConfigValue — non-command values", () => {
 });
 
 describe("resolveConfigValue — command allowlist enforcement", () => {
-	it("blocks a disallowed command and returns undefined", (t) => {
+	it("blocks a disallowed command and returns undefined", () => {
 		const stderrChunks: string[] = [];
 		const originalWrite = process.stderr.write.bind(process.stderr);
 		process.stderr.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
 			stderrChunks.push(chunk.toString());
 			return true;
 		};
-		t.after(() => {
-			process.stderr.write = originalWrite;
-		});
 
-		const result = resolveConfigValue("!curl http://evil.com");
-		assert.equal(result, undefined);
-		assert.ok(stderrChunks.some((line) => line.includes("curl")));
+		try {
+			const result = resolveConfigValue("!curl http://evil.com");
+			assert.equal(result, undefined);
+			assert.ok(stderrChunks.some((line) => line.includes("curl")));
+		} finally {
+			process.stderr.write = originalWrite;
+		}
 	});
 
 	it("blocks another disallowed command (rm)", () => {
@@ -64,7 +65,7 @@ describe("resolveConfigValue — command allowlist enforcement", () => {
 		assert.equal(result, undefined);
 	});
 
-	it("allows a safe command prefix to proceed to execution", (t) => {
+	it("allows a safe command prefix to proceed to execution", () => {
 		// `pass` is unlikely to be installed in CI, so we just verify it does NOT
 		// return undefined due to the allowlist check — it may return undefined if
 		// the binary is absent, but the block path must not be taken.
@@ -75,15 +76,16 @@ describe("resolveConfigValue — command allowlist enforcement", () => {
 			stderrChunks.push(chunk.toString());
 			return true;
 		};
-		t.after(() => {
-			process.stderr.write = originalWrite;
-		});
 
-		resolveConfigValue("!pass show nonexistent-entry-for-test");
-		const blocked = stderrChunks.some((line) =>
-			line.includes("Blocked disallowed command")
-		);
-		assert.equal(blocked, false, "pass should not be blocked by the allowlist");
+		try {
+			resolveConfigValue("!pass show nonexistent-entry-for-test");
+			const blocked = stderrChunks.some((line) =>
+				line.includes("Blocked disallowed command")
+			);
+			assert.equal(blocked, false, "pass should not be blocked by the allowlist");
+		} finally {
+			process.stderr.write = originalWrite;
+		}
 	});
 });
 
@@ -128,58 +130,61 @@ describe("resolveConfigValue — shell operator bypass prevention", () => {
 		assert.equal(result, undefined);
 	});
 
-	it("writes stderr warning when shell operators detected", (t) => {
+	it("writes stderr warning when shell operators detected", () => {
 		const stderrChunks: string[] = [];
 		const originalWrite = process.stderr.write.bind(process.stderr);
 		process.stderr.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
 			stderrChunks.push(chunk.toString());
 			return true;
 		};
-		t.after(() => {
-			process.stderr.write = originalWrite;
-		});
 
-		resolveConfigValue("!pass show key; curl evil.com");
-		assert.ok(stderrChunks.some((line) => line.includes("shell operators")));
+		try {
+			resolveConfigValue("!pass show key; curl evil.com");
+			assert.ok(stderrChunks.some((line) => line.includes("shell operators")));
+		} finally {
+			process.stderr.write = originalWrite;
+		}
 	});
 });
 
 describe("resolveConfigValue — caching", () => {
-	it("caches the result of a blocked command", (t) => {
+	it("caches the result of a blocked command", () => {
 		const callCount = { n: 0 };
 		const originalWrite = process.stderr.write.bind(process.stderr);
 		process.stderr.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
 			callCount.n++;
 			return true;
 		};
-		t.after(() => {
-			process.stderr.write = originalWrite;
-		});
 
-		resolveConfigValue("!curl http://evil.com");
-		resolveConfigValue("!curl http://evil.com");
-		// The block warning should only fire once; the second call hits the cache
-		// before reaching the allowlist check, so stderr count is 1.
-		assert.equal(callCount.n, 1);
+		try {
+			resolveConfigValue("!curl http://evil.com");
+			resolveConfigValue("!curl http://evil.com");
+			// The block warning should only fire once; the second call hits the cache
+			// before reaching the allowlist check, so stderr count is 1.
+			assert.equal(callCount.n, 1);
+		} finally {
+			process.stderr.write = originalWrite;
+		}
 	});
 
-	it("clearConfigValueCache resets cached entries", (t) => {
+	it("clearConfigValueCache resets cached entries", () => {
 		const stderrChunks: string[] = [];
 		const originalWrite = process.stderr.write.bind(process.stderr);
 		process.stderr.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
 			stderrChunks.push(chunk.toString());
 			return true;
 		};
-		t.after(() => {
-			process.stderr.write = originalWrite;
-		});
 
-		resolveConfigValue("!curl http://evil.com");
-		assert.equal(stderrChunks.length, 1);
+		try {
+			resolveConfigValue("!curl http://evil.com");
+			assert.equal(stderrChunks.length, 1);
 
-		clearConfigValueCache();
+			clearConfigValueCache();
 
-		resolveConfigValue("!curl http://evil.com");
-		assert.equal(stderrChunks.length, 2);
+			resolveConfigValue("!curl http://evil.com");
+			assert.equal(stderrChunks.length, 2);
+		} finally {
+			process.stderr.write = originalWrite;
+		}
 	});
 });

package/packages/pi-coding-agent/src/core/session-manager.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { describe, it, afterEach } from "node:test";
+import { describe, it } from "node:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -22,44 +22,44 @@ function makeAssistantMessage(input: number, output: number, cacheRead = 0, cach
 }
 
 describe("SessionManager usage totals", () => {
-	let dir: string;
-
-	afterEach(() => {
-		if (dir) {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
 	it("tracks assistant usage incrementally without rescanning entries", () => {
-		dir = mkdtempSync(join(tmpdir(), "gsd-session-manager-test-"));
-		const manager = SessionManager.create(dir, dir);
+		const dir = mkdtempSync(join(tmpdir(), "gsd-session-manager-test-"));
+		try {
+			const manager = SessionManager.create(dir, dir);
 
-		manager.appendMessage({ role: "user", content: [{ type: "text", text: "hello" }] } as any);
-		manager.appendMessage(makeAssistantMessage(10, 5, 3, 2, 0.25));
-		manager.appendMessage(makeAssistantMessage(7, 4, 1, 0, 0.1));
+			manager.appendMessage({ role: "user", content: [{ type: "text", text: "hello" }] } as any);
+			manager.appendMessage(makeAssistantMessage(10, 5, 3, 2, 0.25));
+			manager.appendMessage(makeAssistantMessage(7, 4, 1, 0, 0.1));
 
-		assert.deepEqual(manager.getUsageTotals(), {
-			input: 17,
-			output: 9,
-			cacheRead: 4,
-			cacheWrite: 2,
-			cost: 0.35,
-		});
+			assert.deepEqual(manager.getUsageTotals(), {
+				input: 17,
+				output: 9,
+				cacheRead: 4,
+				cacheWrite: 2,
+				cost: 0.35,
+			});
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
 	});
 
 	it("resets totals when starting a new session", () => {
-		dir = mkdtempSync(join(tmpdir(), "gsd-session-manager-test-"));
-		const manager = SessionManager.create(dir, dir);
-		manager.appendMessage(makeAssistantMessage(5, 5, 0, 0, 0.05));
-		assert.equal(manager.getUsageTotals().input, 5);
+		const dir = mkdtempSync(join(tmpdir(), "gsd-session-manager-test-"));
+		try {
+			const manager = SessionManager.create(dir, dir);
+			manager.appendMessage(makeAssistantMessage(5, 5, 0, 0, 0.05));
+			assert.equal(manager.getUsageTotals().input, 5);
 
-		manager.newSession();
-		assert.deepEqual(manager.getUsageTotals(), {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			cost: 0,
-		});
+			manager.newSession();
+			assert.deepEqual(manager.getUsageTotals(), {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0,
+			});
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
 	});
 });

package/packages/pi-coding-agent/src/core/tools/edit-diff.test.ts

@@ -60,26 +60,26 @@ describe("edit-diff", () => {
 		assert.match(result.diff, /CHANGED/);
 	});
 
-	it("computes diffs for preview without native helpers", async (t) => {
+	it("computes diffs for preview without native helpers", async () => {
 		const dir = mkdtempSync(join(tmpdir(), "edit-diff-test-"));
-		t.after(() => {
-			rmSync(dir, { recursive: true, force: true });
-		});
-
-		const file = join(dir, "sample.ts");
-		writeFileSync(file, "const title = “Hello”;\n", "utf-8");
+		try {
+			const file = join(dir, "sample.ts");
+			writeFileSync(file, "const title = “Hello”;\n", "utf-8");
 
-		const result = await computeEditDiff(
-			file,
-			"const title = \"Hello\";\n",
-			"const title = \"Hi\";\n",
-			dir,
-		);
+			const result = await computeEditDiff(
+				file,
+				"const title = \"Hello\";\n",
+				"const title = \"Hi\";\n",
+				dir,
+			);
 
-		assert.ok(!("error" in result), "expected a diff result");
-		if (!("error" in result)) {
-			assert.equal(result.firstChangedLine, 1);
-			assert.match(result.diff, /\+1 const title = "Hi";/);
+			assert.ok(!("error" in result), "expected a diff result");
+			if (!("error" in result)) {
+				assert.equal(result.firstChangedLine, 1);
+				assert.match(result.diff, /\+1 const title = "Hi";/);
+			}
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
 		}
 	});
 });

package/packages/pi-coding-agent/src/resources/extensions/memory/storage.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { describe, it, afterEach } from "node:test";
+import { describe, it, mock } from "node:test";
 import { mkdtempSync, rmSync, readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -15,84 +15,84 @@ function wait(ms: number): Promise<void> {
 }
 
 describe("MemoryStorage debounced persistence", () => {
-	let dir: string;
-
-	afterEach(() => {
-		if (dir) {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
 	it("multiple rapid mutations only trigger one persist write", async () => {
-		dir = makeTmpDir();
+		const dir = makeTmpDir();
 		const dbPath = join(dir, "test.db");
-		const storage = await MemoryStorage.create(dbPath);
-
-		const initialStat = readFileSync(dbPath);
-		const initialMtime = initialStat.length;
-
-		storage.upsertThreads([
-			{ threadId: "t1", filePath: "/a.txt", fileSize: 100, fileMtime: 1000, cwd: "/proj" },
-		]);
-		storage.upsertThreads([
-			{ threadId: "t2", filePath: "/b.txt", fileSize: 200, fileMtime: 2000, cwd: "/proj" },
-		]);
-		storage.upsertThreads([
-			{ threadId: "t3", filePath: "/c.txt", fileSize: 300, fileMtime: 3000, cwd: "/proj" },
-		]);
-
-		const afterMutationsBuf = readFileSync(dbPath);
-		assert.deepEqual(
-			afterMutationsBuf,
-			initialStat,
-			"File should not have been written yet (debounce window has not elapsed)",
-		);
-
-		await wait(700);
-
-		const afterDebounceBuf = readFileSync(dbPath);
-		assert.notDeepEqual(
-			afterDebounceBuf,
-			initialStat,
-			"File should have been written after debounce window elapsed",
-		);
-
-		const stats = storage.getStats();
-		assert.equal(stats.totalThreads, 3);
-
-		storage.close();
+		try {
+			const storage = await MemoryStorage.create(dbPath);
+
+			const initialStat = readFileSync(dbPath);
+			const initialMtime = initialStat.length;
+
+			storage.upsertThreads([
+				{ threadId: "t1", filePath: "/a.txt", fileSize: 100, fileMtime: 1000, cwd: "/proj" },
+			]);
+			storage.upsertThreads([
+				{ threadId: "t2", filePath: "/b.txt", fileSize: 200, fileMtime: 2000, cwd: "/proj" },
+			]);
+			storage.upsertThreads([
+				{ threadId: "t3", filePath: "/c.txt", fileSize: 300, fileMtime: 3000, cwd: "/proj" },
+			]);
+
+			const afterMutationsBuf = readFileSync(dbPath);
+			assert.deepEqual(
+				afterMutationsBuf,
+				initialStat,
+				"File should not have been written yet (debounce window has not elapsed)",
+			);
+
+			await wait(700);
+
+			const afterDebounceBuf = readFileSync(dbPath);
+			assert.notDeepEqual(
+				afterDebounceBuf,
+				initialStat,
+				"File should have been written after debounce window elapsed",
+			);
+
+			const stats = storage.getStats();
+			assert.equal(stats.totalThreads, 3);
+
+			storage.close();
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
 	});
 
 	it("close() flushes pending changes immediately without waiting for debounce", async () => {
-		dir = makeTmpDir();
+		const dir = makeTmpDir();
 		const dbPath = join(dir, "test.db");
-		const storage = await MemoryStorage.create(dbPath);
-
-		const initialBuf = readFileSync(dbPath);
-
-		storage.upsertThreads([
-			{ threadId: "t1", filePath: "/a.txt", fileSize: 100, fileMtime: 1000, cwd: "/proj" },
-		]);
-
-		const beforeCloseBuf = readFileSync(dbPath);
-		assert.deepEqual(
-			beforeCloseBuf,
-			initialBuf,
-			"File should not have been written yet (debounce window has not elapsed)",
-		);
-
-		storage.close();
-
-		const afterCloseBuf = readFileSync(dbPath);
-		assert.notDeepEqual(
-			afterCloseBuf,
-			initialBuf,
-			"File should have been written immediately on close()",
-		);
-
-		const reopened = await MemoryStorage.create(dbPath);
-		const stats = reopened.getStats();
-		assert.equal(stats.totalThreads, 1, "Data should be persisted and readable after close");
-		reopened.close();
+		try {
+			const storage = await MemoryStorage.create(dbPath);
+
+			const initialBuf = readFileSync(dbPath);
+
+			storage.upsertThreads([
+				{ threadId: "t1", filePath: "/a.txt", fileSize: 100, fileMtime: 1000, cwd: "/proj" },
+			]);
+
+			const beforeCloseBuf = readFileSync(dbPath);
+			assert.deepEqual(
+				beforeCloseBuf,
+				initialBuf,
+				"File should not have been written yet (debounce window has not elapsed)",
+			);
+
+			storage.close();
+
+			const afterCloseBuf = readFileSync(dbPath);
+			assert.notDeepEqual(
+				afterCloseBuf,
+				initialBuf,
+				"File should have been written immediately on close()",
+			);
+
+			const reopened = await MemoryStorage.create(dbPath);
+			const stats = reopened.getStats();
+			assert.equal(stats.totalThreads, 1, "Data should be persisted and readable after close");
+			reopened.close();
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
 	});
 });

package/src/resources/extensions/gsd/auto-start.ts

@@ -551,20 +551,6 @@ export async function bootstrapAutoSession(
       }
     }
 
-    // Gate: abort bootstrap if the DB file exists but the provider is
-    // still unavailable after both open attempts above. Without this,
-    // auto-mode starts but every gsd_task_complete / gsd_slice_complete
-    // call returns "db_unavailable", triggering artifact-retry which
-    // re-dispatches the same task — producing an infinite loop (#2419).
-    if (existsSync(gsdDbPath) && !isDbAvailable()) {
-      ctx.ui.notify(
-        "SQLite database exists but failed to open. Auto-mode cannot proceed without a working database provider. " +
-          "Check for corrupt gsd.db or missing native SQLite bindings.",
-        "error",
-      );
-      return releaseLockAndReturn();
-    }
-
     // Initialize metrics
     initMetrics(s.basePath);
 

package/src/resources/extensions/gsd/commands/handlers/workflow.ts

@@ -188,14 +188,6 @@ export async function handleWorkflowCommand(trimmed: string, ctx: ExtensionComma
     return true;
   }
   if (trimmed === "quick" || trimmed.startsWith("quick ")) {
-    if (isAutoActive()) {
-      ctx.ui.notify(
-        "/gsd quick cannot run while auto-mode is active.\n" +
-        "Stop auto-mode first with /gsd stop, then run /gsd quick.",
-        "error",
-      );
-      return true;
-    }
     await handleQuick(trimmed.replace(/^quick\s*/, "").trim(), ctx, pi);
     return true;
   }