@selesai/code 0.3.0 → 0.3.1

package/dist/extensions/pi-subagents/test/integration/detect-error.test.ts

@@ -0,0 +1,242 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+interface DetectErrorResult {
+	hasError: boolean;
+	errorType?: string;
+	details?: string;
+	exitCode?: number;
+}
+
+type DetectSubagentError = (messages: unknown[]) => DetectErrorResult;
+
+let detectSubagentError: DetectSubagentError | undefined;
+let available = true;
+try {
+	({ detectSubagentError } = await import("../../src/shared/utils.ts"));
+} catch {
+	// Skip in lean unit mode when runtime-only imports are unavailable.
+	available = false;
+}
+
+/**
+ * Helper to create a tool result message (success or error).
+ */
+function toolResult(toolName: string, text: string, isError = false): Record<string, unknown> {
+	return {
+		role: "toolResult",
+		toolCallId: `call-${Math.random().toString(36).slice(2, 8)}`,
+		toolName,
+		content: [{ type: "text", text }],
+		isError,
+	};
+}
+
+function assistantMsg(text: string): Record<string, unknown> {
+	return {
+		role: "assistant",
+		content: [{ type: "text", text }],
+		api: "test",
+		provider: "test",
+		model: "test",
+	};
+}
+
+/** Assistant message with only a tool call, no text content */
+function assistantToolCall(toolName: string): Record<string, unknown> {
+	return {
+		role: "assistant",
+		content: [{ type: "toolCall", name: toolName, input: {} }],
+		api: "test",
+		provider: "test",
+		model: "test",
+	};
+}
+
+describe("detectSubagentError", { skip: !available ? "utils not importable" : undefined }, () => {
+	// ---- Basic detection (must still work) ----
+
+	it("returns no error for empty messages", () => {
+		assert.equal(detectSubagentError([]).hasError, false);
+	});
+
+	it("returns no error when all tool results succeed", () => {
+		const messages = [
+			toolResult("read", "file contents here"),
+			toolResult("bash", "ls output"),
+			toolResult("read", "more contents"),
+		];
+		assert.equal(detectSubagentError(messages).hasError, false);
+	});
+
+	it("detects isError tool result as failure (no assistant response)", () => {
+		const messages = [
+			toolResult("read", "file contents"),
+			toolResult("read", "EISDIR: illegal operation on a directory, read", true),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true);
+		assert.equal(result.errorType, "read");
+		assert.match(result.details!, /EISDIR/);
+	});
+
+	it("detects bash fatal pattern (permission denied, no assistant response)", () => {
+		const messages = [
+			toolResult("bash", "ls: permission denied: /root/secret"),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true);
+		assert.equal(result.errorType, "bash");
+	});
+
+	it("detects bash exit code in output", () => {
+		const messages = [
+			toolResult("bash", "error: process exited with code 127"),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true);
+		assert.equal(result.exitCode, 127);
+	});
+
+	// ---- Recovery: errors before the agent's final response are forgiven ----
+
+	it("ignores error when agent recovered and continued", () => {
+		const messages = [
+			toolResult("read", "file contents"),
+			toolResult("bash", "ok"),
+			toolResult("read", "EISDIR: illegal operation on a directory", true),
+			toolResult("bash", "directory listing via bash"),
+			assistantMsg("Here is my complete review..."),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, false,
+			"error before agent's final text response should be ignored");
+	});
+
+	it("ignores error as final tool result when agent produced text response after", () => {
+		// The exact scenario from our review run: agent did all work, last tool
+		// call was read on directory → EISDIR, but agent produced 13.5KB review.
+		const messages = [
+			toolResult("read", "file contents of index.ts"),
+			toolResult("read", "file contents of utils.ts"),
+			toolResult("bash", "npm test output: 46 pass"),
+			toolResult("read", "file contents of settings.ts"),
+			toolResult("read", "EISDIR: illegal operation on a directory, read", true),
+			assistantMsg("## Complete Review\n\nHere are all my findings..."),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, false,
+			"agent produced substantive output after error — not a failure");
+	});
+
+	it("ignores bash fatal pattern when agent responded after", () => {
+		const messages = [
+			toolResult("bash", "ls: permission denied: /root/secret"),
+			assistantMsg("I couldn't access /root/secret, but I found the data elsewhere."),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, false,
+			"fatal pattern before agent's text response = recovered");
+	});
+
+	// ---- Errors AFTER the last assistant text response are still caught ----
+
+	it("detects error after agent's last text response", () => {
+		const messages = [
+			assistantMsg("Here is my analysis..."),
+			toolResult("bash", "rm -rf /important", false),
+			toolResult("bash", "error: process exited with code 1", false),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true);
+		assert.equal(result.exitCode, 1);
+	});
+
+	it("detects isError after agent's last text response", () => {
+		const messages = [
+			toolResult("read", "file ok"),
+			assistantMsg("Let me try one more thing..."),
+			toolResult("write", "Permission denied", true),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true);
+		assert.equal(result.errorType, "write");
+	});
+
+	// ---- Edge cases ----
+
+	it("flags error when no assistant messages at all", () => {
+		const messages = [
+			toolResult("read", "ok"),
+			toolResult("bash", "segmentation fault"),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true,
+			"no assistant response = no recovery evidence");
+	});
+
+	it("does not treat tool-call-only assistant message as recovery", () => {
+		// Assistant message that only contains a tool call, no text.
+		// The error at index 0 should still be detected because the tool-call-only
+		// assistant message doesn't count as recovery. The final tool result is
+		// successful to ensure this test actually distinguishes correct behavior.
+		const messages = [
+			toolResult("bash", "permission denied: /etc/shadow"),
+			assistantToolCall("bash"),
+			toolResult("bash", "command succeeded"),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true,
+			"tool-call assistant message without text is not a recovery");
+	});
+
+	it("does not treat empty/whitespace assistant message as recovery", () => {
+		const messages = [
+			toolResult("read", "EISDIR: illegal operation on a directory", true),
+			assistantMsg("   "),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true,
+			"whitespace-only assistant message is not a recovery");
+	});
+
+	it("returns no error when only assistant messages (no tool results)", () => {
+		const messages = [
+			assistantMsg("Hello, I'm ready to help."),
+			assistantMsg("Here's my analysis."),
+		];
+		assert.equal(detectSubagentError(messages).hasError, false);
+	});
+
+	it("handles multiple errors with recovery between them", () => {
+		// Error → recovery → error → recovery
+		const messages = [
+			toolResult("read", "ENOENT: no such file", true),
+			assistantMsg("File not found, trying alternative..."),
+			toolResult("read", "file contents"),
+			toolResult("read", "EISDIR: illegal operation on a directory", true),
+			assistantMsg("Got what I needed. Here's the full review."),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, false,
+			"all errors have recovery — agent completed successfully");
+	});
+
+	// ---- Real-world regression test ----
+
+	it("real-world: 19-read review run with trailing EISDIR", () => {
+		// Simulate the actual _impl-reviewer run that produced a false positive
+		const readResults = Array.from({ length: 18 }, (_, i) =>
+			toolResult("read", `contents of file ${i + 1}`),
+		);
+		const messages = [
+			...readResults,
+			toolResult("bash", "npm test\n46 pass\n2 fail\nTests 48"),
+			toolResult("read", "EISDIR: illegal operation on a directory, read", true),
+			assistantMsg("## Implementation Review\n\n" + "x".repeat(13000)),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, false,
+			"complete review with trailing EISDIR must not be flagged as failure");
+	});
+});

package/dist/extensions/pi-subagents/test/integration/doctor-executor.test.ts

@@ -0,0 +1,128 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { createEventBus, createTempDir, makeMinimalCtx, removeTempDir, tryImport } from "../support/helpers.ts";
+
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+const importHome = createTempDir("pi-doctor-executor-import-home-");
+process.env.HOME = importHome;
+process.env.USERPROFILE = importHome;
+let executorMod: any;
+try {
+	executorMod = await tryImport<any>("./src/runs/foreground/subagent-executor.ts");
+} finally {
+	if (originalHome === undefined) delete process.env.HOME;
+	else process.env.HOME = originalHome;
+	if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+	else process.env.USERPROFILE = originalUserProfile;
+	removeTempDir(importHome);
+}
+const createSubagentExecutor = executorMod?.createSubagentExecutor;
+
+function makeState(cwd: string) {
+	return {
+		baseCwd: cwd,
+		currentSessionId: null,
+		asyncJobs: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
+describe("doctor action executor routing", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, () => {
+	let tempDir = "";
+	let tempHome = "";
+
+	beforeEach(() => {
+		tempDir = createTempDir("pi-doctor-executor-project-");
+		tempHome = createTempDir("pi-doctor-executor-home-");
+		process.env.HOME = tempHome;
+		process.env.USERPROFILE = tempHome;
+	});
+
+	afterEach(() => {
+		if (originalHome === undefined) delete process.env.HOME;
+		else process.env.HOME = originalHome;
+		if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = originalUserProfile;
+		removeTempDir(tempDir);
+		removeTempDir(tempHome);
+	});
+
+	it("returns a doctor report for the tool action", async () => {
+		const sessionFile = path.join(tempDir, "sessions", "parent.jsonl");
+		fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+		fs.writeFileSync(sessionFile, "");
+		const executor = createSubagentExecutor({
+			pi: { events: createEventBus(), getSessionName: () => undefined },
+			state: makeState(tempDir),
+			config: { defaultSessionDir: path.join(tempDir, "configured-sessions") },
+			asyncByDefault: false,
+			tempArtifactsDir: tempDir,
+			getSubagentSessionRoot: () => tempDir,
+			expandTilde: (value: string) => value,
+			discoverAgents: () => ({ agents: [] }),
+		});
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionFile = () => sessionFile;
+		ctx.sessionManager.getSessionId = () => "session-doctor";
+
+		const result = await executor.execute(
+			"doctor-id",
+			{ action: "doctor" },
+			new AbortController().signal,
+			undefined,
+			ctx,
+		);
+
+		assert.equal(result.isError, undefined);
+		const text = result.content[0]?.text ?? "";
+		assert.match(text, /^Subagents doctor report/);
+		assert.match(text, /- configured session dir: .*configured-sessions/);
+		assert.match(text, /- supervisor channel: available \(native:pi-subagents-supervisor-channel\)/);
+	});
+
+	it("reports session manager failures without failing the doctor action", async () => {
+		const executor = createSubagentExecutor({
+			pi: { events: createEventBus(), getSessionName: () => undefined },
+			state: makeState(tempDir),
+			config: {},
+			asyncByDefault: false,
+			tempArtifactsDir: tempDir,
+			getSubagentSessionRoot: () => tempDir,
+			expandTilde: (value: string) => value,
+			discoverAgents: () => ({ agents: [] }),
+		});
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionFile = () => {
+			throw new Error("session unavailable");
+		};
+		ctx.sessionManager.getSessionId = () => {
+			throw new Error("session unavailable");
+		};
+
+		const result = await executor.execute(
+			"doctor-id",
+			{ action: "doctor" },
+			new AbortController().signal,
+			undefined,
+			ctx,
+		);
+
+		assert.equal(result.isError, undefined);
+		const text = result.content[0]?.text ?? "";
+		assert.match(text, /^Subagents doctor report/);
+		assert.match(text, /- session manager: failed — Error: session unavailable/);
+		assert.match(text, /- current session file: not available/);
+	});
+});

package/dist/extensions/pi-subagents/test/integration/error-handling.test.ts

@@ -0,0 +1,252 @@
+/**
+ * Integration tests for error handling across execution modes.
+ *
+ * Tests: agent crashes, stderr capture, detectSubagentError override,
+ * signal/abort handling, and error propagation in chains.
+ *
+ * Requires pi packages for execution tests. Skips gracefully if unavailable.
+ */
+
+import { describe, it, before, after, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import * as path from "node:path";
+import type { MockPi } from "../support/helpers.ts";
+import {
+	createMockPi,
+	createTempDir,
+	removeTempDir,
+	makeAgentConfigs,
+	makeAgent,
+	makeMinimalCtx,
+	events,
+	tryImport,
+} from "../support/helpers.ts";
+
+// Top-level await
+const utils = await tryImport<any>("./src/shared/utils.ts");
+const execution = await tryImport<any>("./src/runs/foreground/execution.ts");
+const chainMod = await tryImport<any>("./src/runs/foreground/chain-execution.ts");
+
+const piAvailable = !!(execution && utils);
+const chainAvailable = !!chainMod;
+
+const runSync = execution?.runSync;
+const detectSubagentError = utils?.detectSubagentError;
+const executeChain = chainMod?.executeChain;
+
+// ---------------------------------------------------------------------------
+// detectSubagentError
+// ---------------------------------------------------------------------------
+
+describe("detectSubagentError", { skip: !detectSubagentError ? "utils not importable" : undefined }, () => {
+	it("returns no error for successful messages", () => {
+		const messages = [
+			{ role: "assistant", content: [{ type: "text", text: "Let me check..." }] },
+			{ role: "toolResult", toolName: "bash", isError: false, content: [{ type: "text", text: "OK" }] },
+			{ role: "assistant", content: [{ type: "text", text: "All good!" }] },
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, false);
+	});
+
+	it("detects fatal bash error in last tool result", () => {
+		const messages = [
+			{ role: "assistant", content: [{ type: "text", text: "Running..." }] },
+			{
+				role: "toolResult",
+				toolName: "bash",
+				isError: false,
+				content: [{ type: "text", text: "command not found" }],
+			},
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true);
+		assert.equal(result.errorType, "bash");
+	});
+
+	it("detects non-zero exit code in bash output", () => {
+		const messages = [
+			{ role: "assistant", content: [{ type: "text", text: "Running..." }] },
+			{
+				role: "toolResult",
+				toolName: "bash",
+				isError: false,
+				content: [{ type: "text", text: "Error: process exited with code 127" }],
+			},
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true);
+		assert.equal(result.exitCode, 127);
+	});
+
+	it("ignores errors before last successful tool result", () => {
+		const messages = [
+			{ role: "assistant", content: [{ type: "text", text: "Trying..." }] },
+			{ role: "toolResult", toolName: "bash", isError: true, content: [{ type: "text", text: "EISDIR" }] },
+			{ role: "assistant", content: [{ type: "text", text: "Let me fix that..." }] },
+			{ role: "toolResult", toolName: "bash", isError: false, content: [{ type: "text", text: "OK" }] },
+			{ role: "assistant", content: [{ type: "text", text: "Fixed!" }] },
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, false);
+	});
+
+	it("detects isError on tool result", () => {
+		const messages = [
+			{ role: "assistant", content: [{ type: "text", text: "Running..." }] },
+			{
+				role: "toolResult",
+				toolName: "write",
+				isError: true,
+				content: [{ type: "text", text: "Permission denied" }],
+			},
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true);
+		assert.equal(result.errorType, "write");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// runSync error handling
+// ---------------------------------------------------------------------------
+
+describe("runSync error handling", { skip: !piAvailable ? "pi packages not available" : undefined }, () => {
+	let tempDir: string;
+	let mockPi: MockPi;
+
+	before(() => {
+		mockPi = createMockPi();
+		mockPi.install();
+	});
+
+	after(() => {
+		mockPi.uninstall();
+	});
+
+	beforeEach(() => {
+		tempDir = createTempDir();
+		mockPi.reset();
+	});
+
+	afterEach(() => {
+		removeTempDir(tempDir);
+	});
+
+	it("captures stderr on non-zero exit", async () => {
+		mockPi.onCall({ exitCode: 2, stderr: "Fatal: out of memory" });
+		const agents = makeAgentConfigs(["crash"]);
+
+		const result = await runSync(tempDir, agents, "crash", "Do heavy work", {});
+
+		assert.equal(result.exitCode, 2);
+		assert.ok(result.error?.includes("out of memory"));
+	});
+
+	it("detectSubagentError overrides exit 0 on hidden failure", async () => {
+		mockPi.onCall({
+			jsonl: [
+				events.toolStart("bash", { command: "deploy" }),
+				events.toolEnd("bash"),
+				events.toolResult("bash", "connection refused"),
+			],
+		});
+		const agents = makeAgentConfigs(["deployer"]);
+
+		const result = await runSync(tempDir, agents, "deployer", "Deploy app", {});
+
+		assert.notEqual(result.exitCode, 0, "should detect hidden failure");
+		assert.ok(result.error?.includes("connection refused"));
+	});
+
+	it("handles abort signal (completes faster than delay)", async () => {
+		mockPi.onCall({ delay: 10000 });
+		const agents = makeAgentConfigs(["slow"]);
+		const controller = new AbortController();
+
+		const start = Date.now();
+		setTimeout(() => controller.abort(), 200);
+
+		const result = await runSync(tempDir, agents, "slow", "Slow task", {
+			signal: controller.signal,
+		});
+		const elapsed = Date.now() - start;
+
+		// Key: should complete much faster than the 10s delay
+		assert.ok(elapsed < 5000, `should abort early, took ${elapsed}ms`);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Chain error propagation
+// ---------------------------------------------------------------------------
+
+describe("chain error propagation", { skip: !chainAvailable ? "chain module not available" : undefined }, () => {
+	let tempDir: string;
+	let mockPi: MockPi;
+
+	before(() => {
+		mockPi = createMockPi();
+		mockPi.install();
+	});
+
+	after(() => {
+		mockPi.uninstall();
+	});
+
+	beforeEach(() => {
+		tempDir = createTempDir();
+		mockPi.reset();
+	});
+
+	afterEach(() => {
+		removeTempDir(tempDir);
+	});
+
+	function makeChainParams(chain: any[], agents: any[]) {
+		return {
+			chain,
+			agents,
+			ctx: makeMinimalCtx(tempDir),
+			runId: "test-err",
+			shareEnabled: false,
+			sessionDirForIndex: () => undefined,
+			artifactsDir: path.join(tempDir, "artifacts"),
+			artifactConfig: { enabled: false },
+			clarify: false,
+		};
+	}
+
+	it("preserves error context from failed step", async () => {
+		mockPi.onCall({ exitCode: 1, stderr: "Step 1 exploded" });
+		const agents = [makeAgent("step1"), makeAgent("step2")];
+
+		const result = await executeChain(
+			makeChainParams(
+				[{ agent: "step1", task: "Fail here" }, { agent: "step2" }],
+				agents,
+			),
+		);
+
+		assert.ok(result.isError);
+		const failedResult = result.details.results[0];
+		assert.equal(failedResult.exitCode, 1);
+		assert.ok(failedResult.error?.includes("exploded"));
+	});
+
+	it("reports currentStepIndex on failure", async () => {
+		mockPi.onCall({ exitCode: 1 });
+		const agents = [makeAgent("a"), makeAgent("b"), makeAgent("c")];
+
+		const result = await executeChain(
+			makeChainParams(
+				[{ agent: "a", task: "First" }, { agent: "b" }, { agent: "c" }],
+				agents,
+			),
+		);
+
+		assert.ok(result.isError);
+		assert.equal(result.details.currentStepIndex, 0);
+		assert.equal(result.details.results.length, 1);
+	});
+});