@selesai/code 0.13.11 → 0.13.13

package/dist/extensions/pi-subagents/test/unit/host-command.test.ts

@@ -1,157 +0,0 @@
-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, describe, it } from "node:test";
-import { executeWorkflowHostCommand, normalizeWorkflowHostCommandParams } from "../../src/workflows/host-command.ts";
-
-const roots: string[] = [];
-
-afterEach(() => {
-	for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
-});
-
-function commandFor(root: string, source: string): string {
-	const script = path.join(root, `command-${Math.random().toString(16).slice(2)}.cjs`);
-	fs.writeFileSync(script, source, "utf8");
-	return `${JSON.stringify(process.execPath)} ${JSON.stringify(script)}`;
-}
-
-describe("workflow host commands", () => {
-	it("validates the narrow command shape", () => {
-		assert.deepEqual(normalizeWorkflowHostCommandParams({ kind: "command", command: "npm test", timeoutMs: 1000, output: "reports/test.log", role: "ci", provider: "local" }), {
-			kind: "command",
-			command: "npm test",
-			timeoutMs: 1000,
-			output: "reports/test.log",
-			role: "ci",
-			provider: "local",
-		});
-		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "http", command: "true", timeoutMs: 1000 }), /kind must be 'command'/);
-		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true" }), /timeoutMs/);
-		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, output: "../outside.log" }), /relative path/);
-		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 86_400_001 }), /integer from 1/);
-		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, output: path.resolve("outside.log") }), /relative path/);
-		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, provider: "bad\nprovider" }), /single-line/);
-		assert.throws(() => normalizeWorkflowHostCommandParams({ kind: "command", command: "true", timeoutMs: 1000, cwd: "/tmp" }), /does not accept per-step cwd.*workflow cwd.*outer subagent request.*cd \/path\/to\/worktree/);
-	});
-
-	it("runs without stdin and saves bounded command evidence", async () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-"));
-		roots.push(root);
-		const outputPath = path.join(root, "reports", "command.log");
-		fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-		fs.writeFileSync(outputPath, "stale", "utf8");
-		const result = await executeWorkflowHostCommand({
-			key: "unit-tests",
-			params: { kind: "command", command: commandFor(root, `process.stdout.write("passed\\n"); process.stderr.write("warning\\n");`), timeoutMs: 5000, output: "reports/command.log" },
-			cwd: root,
-			defaultOutputPath: path.join(root, "fallback.log"),
-			signal: new AbortController().signal,
-		});
-		assert.equal(result.ok, true);
-		assert.equal(result.state, "passed");
-		assert.equal(result.exitCode, 0);
-		assert.match(result.stdout, /passed/);
-		assert.match(result.stderr, /warning/);
-		assert.equal(result.outputPath, outputPath);
-		assert.match(fs.readFileSync(outputPath, "utf8"), /passed/);
-		if (process.platform !== "win32") assert.equal(fs.statSync(outputPath).mode & 0o777, 0o600);
-		assert.deepEqual(fs.readdirSync(path.dirname(outputPath)), ["command.log"]);
-	});
-
-	it("returns failed and timed-out command evidence", async () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-failure-"));
-		roots.push(root);
-		const failed = await executeWorkflowHostCommand({
-			key: "failed",
-			params: { kind: "command", command: commandFor(root, `process.stderr.write("bad\\n"); process.exit(3);`), timeoutMs: 5000 },
-			cwd: root,
-			defaultOutputPath: path.join(root, "failed.log"),
-			signal: new AbortController().signal,
-		});
-		assert.equal(failed.state, "failed");
-		assert.equal(failed.exitCode, 3);
-		assert.match(failed.error ?? "", /code 3/);
-
-		const timedOut = await executeWorkflowHostCommand({
-			key: "timeout",
-			params: { kind: "command", command: commandFor(root, `setTimeout(() => {}, 10000);`), timeoutMs: 20 },
-			cwd: root,
-			defaultOutputPath: path.join(root, "timeout.log"),
-			signal: new AbortController().signal,
-		});
-		assert.equal(timedOut.state, "timed-out");
-		assert.match(timedOut.error ?? "", /timed out/);
-	});
-
-	it("rejects symlinked output parents before creating outside directories", { skip: process.platform === "win32" ? "symlink permissions vary on Windows" : undefined }, async () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-symlink-"));
-		const outside = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-outside-"));
-		roots.push(root, outside);
-		fs.symlinkSync(outside, path.join(root, "link-out"), "dir");
-
-		await assert.rejects(
-			executeWorkflowHostCommand({
-				key: "symlink-output",
-				params: { kind: "command", command: commandFor(root, `process.stdout.write("unused");`), timeoutMs: 5000, output: "link-out/sub/report.log" },
-				cwd: root,
-				defaultOutputPath: path.join(root, "fallback.log"),
-				signal: new AbortController().signal,
-			}),
-			/resolves outside the workflow cwd/,
-		);
-		assert.equal(fs.existsSync(path.join(outside, "sub")), false);
-	});
-
-	it("rejects an explicit output parent redirected while the command runs", { skip: process.platform === "win32" ? "symlink permissions vary on Windows" : undefined }, async () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-symlink-race-"));
-		const outside = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-symlink-target-"));
-		roots.push(root, outside);
-		const outputParent = path.join(root, "reports");
-		const outsidePath = path.join(outside, "outside.log");
-		const command = commandFor(root, `
-			const fs = require("node:fs");
-			fs.rmdirSync(${JSON.stringify(outputParent)});
-			fs.symlinkSync(${JSON.stringify(outside)}, ${JSON.stringify(outputParent)}, "dir");
-			process.stdout.write("captured");
-		`);
-
-		await assert.rejects(executeWorkflowHostCommand({
-			key: "replaced-output",
-			params: { kind: "command", command, timeoutMs: 5000, output: "reports/command.log" },
-			cwd: root,
-			defaultOutputPath: path.join(root, "fallback.log"),
-			signal: new AbortController().signal,
-		}), /resolves outside the workflow cwd/);
-		assert.equal(fs.existsSync(outsidePath), false);
-	});
-
-	it("stops the owned process tree when the workflow aborts", async () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-host-command-abort-"));
-		roots.push(root);
-		const readyPath = path.join(root, "ready");
-		const leakedPath = path.join(root, "leaked");
-		const command = commandFor(root, `
-			const { spawn } = require("node:child_process");
-			const fs = require("node:fs");
-			fs.writeFileSync(${JSON.stringify(readyPath)}, "ready");
-			spawn(process.execPath, ["-e", ${JSON.stringify(`setTimeout(() => require("node:fs").writeFileSync(${JSON.stringify(leakedPath)}, "leaked"), 400)}`)}], { stdio: "ignore" });
-			setTimeout(() => {}, 10000);
-		`);
-		const controller = new AbortController();
-		const pending = executeWorkflowHostCommand({
-			key: "abort",
-			params: { kind: "command", command, timeoutMs: 5000 },
-			cwd: root,
-			defaultOutputPath: path.join(root, "abort.log"),
-			signal: controller.signal,
-		});
-		for (let attempt = 0; attempt < 100 && !fs.existsSync(readyPath); attempt += 1) await new Promise((resolve) => setTimeout(resolve, 10));
-		assert.equal(fs.existsSync(readyPath), true);
-		controller.abort();
-		assert.equal((await pending).state, "stopped");
-		await new Promise((resolve) => setTimeout(resolve, 500));
-		assert.equal(fs.existsSync(leakedPath), false);
-	});
-});

package/dist/extensions/pi-subagents/test/unit/host-peer-runtime-imports.test.ts

@@ -1,157 +0,0 @@
-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 { fileURLToPath } from "node:url";
-import test from "node:test";
-import { resolveCompileFromPackageRoot, validateStructuredOutputValue } from "../../src/runs/shared/structured-output.ts";
-import type { JsonSchemaObject } from "../../src/shared/types.ts";
-
-const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-
-const hostPeerPackages = [
-	"@earendil-works/pi-agent-core",
-	"@earendil-works/pi-ai",
-	"@selesai/code",
-	"@earendil-works/pi-tui",
-	"typebox",
-] as const;
-
-function matchingHostPeerPackage(specifier: string): string | undefined {
-	return hostPeerPackages.find((pkg) => specifier === pkg || specifier.startsWith(`${pkg}/`));
-}
-
-/** Extract specifiers from top-level static import/export-from statements, skipping type-only lines. */
-function extractStaticImportSpecifiers(source: string): string[] {
-	const specifiers: string[] = [];
-	const lines = source.split("\n");
-	let i = 0;
-	while (i < lines.length) {
-		const line = lines[i]!.trim();
-		if (!/^(?:import|export)\b/.test(line)) {
-			i++;
-			continue;
-		}
-		// Multi-line statements (e.g. `import {\n\tFoo,\n} from "x";`) continue past this line: keep
-		// pulling lines into one logical statement until we see the `from "..."` clause or a `;`.
-		let statement = line;
-		while (!/from\s+["'][^"']+["']/.test(statement) && !statement.includes(";") && i + 1 < lines.length) {
-			i++;
-			statement += ` ${lines[i]!.trim()}`;
-		}
-		i++;
-
-		if (/^import\s+type\b/.test(statement) || /^export\s+type\b/.test(statement)) continue;
-		const fromMatch = statement.match(/from\s+["']([^"']+)["']/);
-		if (fromMatch) {
-			specifiers.push(fromMatch[1]!);
-			continue;
-		}
-		const sideEffectMatch = statement.match(/^import\s+["']([^"']+)["']/);
-		if (sideEffectMatch) specifiers.push(sideEffectMatch[1]!);
-	}
-	return specifiers;
-}
-
-function resolveRelativeImport(fromFile: string, specifier: string): string | undefined {
-	const base = path.dirname(fromFile);
-	const candidates = [path.resolve(base, specifier), path.resolve(base, `${specifier}.ts`), path.resolve(base, specifier, "index.ts")];
-	return candidates.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
-}
-
-test("detached async runner's runtime import graph never reaches a host peer package (issues #334, #526)", () => {
-	const entryPoint = path.join(projectRoot, "src", "runs", "background", "subagent-runner.ts");
-	const visited = new Set<string>([entryPoint]);
-	const queue: string[] = [entryPoint];
-	const violations: string[] = [];
-
-	while (queue.length > 0) {
-		const file = queue.shift()!;
-		const source = fs.readFileSync(file, "utf-8");
-		for (const specifier of extractStaticImportSpecifiers(source)) {
-			const hostPeerMatch = matchingHostPeerPackage(specifier);
-			if (hostPeerMatch) {
-				violations.push(`${path.relative(projectRoot, file)} has a runtime import of '${specifier}' (host peer package '${hostPeerMatch}')`);
-				continue;
-			}
-			if (!specifier.startsWith(".")) continue;
-			const resolved = resolveRelativeImport(file, specifier);
-			if (!resolved) {
-				throw new Error(`Could not resolve relative import '${specifier}' from ${path.relative(projectRoot, file)}`);
-			}
-			if (!visited.has(resolved)) {
-				visited.add(resolved);
-				queue.push(resolved);
-			}
-		}
-	}
-
-	assert.equal(violations.length, 0, `runtime import graph reached host peer package(s):\n${violations.join("\n")}`);
-	assert.ok(visited.size > 20, `expected a non-trivial reachable file set (a broken resolver could undercount it), got ${visited.size}`);
-});
-
-function writeFakeTypeboxPackage(typeboxDir: string): void {
-	fs.mkdirSync(typeboxDir, { recursive: true });
-	fs.writeFileSync(
-		path.join(typeboxDir, "package.json"),
-		JSON.stringify({ name: "typebox", version: "0.0.0-test", exports: { "./compile": "./compile.mjs" } }),
-	);
-	fs.writeFileSync(path.join(typeboxDir, "compile.mjs"), "export function Compile() {\n\treturn { Check: () => true, Errors: () => [], fakeTypebox: true };\n}\n");
-}
-
-test("resolveCompileFromPackageRoot loads typebox/compile from a fake Pi host package root", async () => {
-	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-host-root-"));
-	try {
-		fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fake-pi-coding-agent", version: "0.0.0" }));
-		writeFakeTypeboxPackage(path.join(root, "node_modules", "typebox"));
-
-		const compile = await resolveCompileFromPackageRoot(root);
-		assert.equal(typeof compile, "function");
-		const compiled = compile!({});
-		assert.equal(compiled.Check({}), true);
-		assert.deepEqual([...compiled.Errors({})], []);
-		assert.equal((compiled as { fakeTypebox?: boolean }).fakeTypebox, true);
-	} finally {
-		fs.rmSync(root, { recursive: true, force: true });
-	}
-
-	const emptyRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-empty-root-"));
-	try {
-		await assert.rejects(resolveCompileFromPackageRoot(emptyRoot));
-	} finally {
-		fs.rmSync(emptyRoot, { recursive: true, force: true });
-	}
-});
-
-test("resolveCompileFromPackageRoot resolves typebox hoisted to an ancestor node_modules", async () => {
-	const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-hoisted-root-"));
-	try {
-		writeFakeTypeboxPackage(path.join(tmp, "node_modules", "typebox"));
-		const packageRoot = path.join(tmp, "apps", "pi", "node_modules", "@earendil-works", "pi-coding-agent");
-		fs.mkdirSync(packageRoot, { recursive: true });
-		fs.writeFileSync(path.join(packageRoot, "package.json"), JSON.stringify({ name: "@selesai/code", version: "0.0.0" }));
-
-		const compile = await resolveCompileFromPackageRoot(packageRoot);
-		assert.equal(typeof compile, "function");
-		const compiled = compile!({});
-		assert.equal(compiled.Check({}), true);
-		assert.equal((compiled as { fakeTypebox?: boolean }).fakeTypebox, true);
-	} finally {
-		fs.rmSync(tmp, { recursive: true, force: true });
-	}
-});
-
-test("validateStructuredOutputValue validates values against a JSON Schema", async () => {
-	const valid = await validateStructuredOutputValue({ type: "object" }, {});
-	assert.deepEqual(valid, { status: "valid" });
-
-	const schema: JsonSchemaObject = {
-		type: "object",
-		properties: { a: { type: "number" } },
-		required: ["a"],
-		additionalProperties: false,
-	};
-	const invalid = await validateStructuredOutputValue(schema, {});
-	assert.equal(invalid.status, "invalid");
-	assert.ok(invalid.status === "invalid" && invalid.message.length > 0);
-});

package/dist/extensions/pi-subagents/test/unit/host-step-status.test.ts

@@ -1,98 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { AsyncStatus, HostStepNodeV1 } from "../../src/shared/types.ts";
-import {
-	HOST_STEP_MAX_LABEL_CHARS,
-	assertHostStepNode,
-	assertWorkflowGraphHostSteps,
-	hostStepWorkflowNode,
-	parseHostStepNode,
-	assertUniqueHostStepIds,
-	upsertHostStep,
-	validHostStepNodes,
-} from "../../src/runs/shared/host-step-status.ts";
-
-function hostStep(overrides: Partial<HostStepNodeV1> = {}): HostStepNodeV1 {
-	return {
-		version: 1,
-		kind: "host-step",
-		monitorKind: "gate",
-		id: "gate-ci",
-		label: "CI and review gate",
-		provider: "github-ci",
-		state: "running",
-		updatedAt: 10,
-		...overrides,
-	};
-}
-
-describe("host step status", () => {
-	it("validates host monitor states and command exit evidence", () => {
-		const running = parseHostStepNode(hostStep({ monitorKind: "ci" }), "fixture");
-		assert.equal(running.monitorKind, "ci");
-		assert.equal(hostStepWorkflowNode(running).status, "running");
-		assert.equal(hostStepWorkflowNode(hostStep({ state: "done", verdict: "pass" })).status, "completed");
-		assert.equal(hostStepWorkflowNode(hostStep({ state: "done", verdict: "inconclusive" })).status, "partial");
-		assert.equal(hostStepWorkflowNode(hostStep({ state: "done" })).status, "partial");
-		assert.equal(hostStepWorkflowNode(hostStep({ state: "done", verdict: "fail" })).status, "failed");
-		assert.equal(hostStepWorkflowNode(hostStep({ state: "cancelled" })).status, "stopped");
-		assert.equal(hostStepWorkflowNode(hostStep({ state: "error" })).status, "failed");
-		assert.equal(parseHostStepNode(hostStep({ monitorKind: "command", state: "done", verdict: "pass", exitCode: 0 })).exitCode, 0);
-	});
-
-	it("rejects unbounded or incomplete terminal data", () => {
-		assert.throws(() => assertHostStepNode(hostStep({ label: "x".repeat(HOST_STEP_MAX_LABEL_CHARS + 1) }), "fixture"), /label exceeds/);
-		assert.throws(() => assertHostStepNode(hostStep({ state: "running", verdict: "pass" }), "fixture"), /verdict is only valid/);
-		assert.throws(() => assertHostStepNode(hostStep({ state: "done", verdict: "inconclusive", freshness: {} as HostStepNodeV1["freshness"] }), "fixture"), /expected/);
-		assert.throws(() => assertHostStepNode(hostStep({ state: "done", verdict: "pass", freshness: { expectedRef: "head", stale: true } }), "fixture"), /stale freshness/);
-		assert.throws(() => assertHostStepNode(hostStep({ exitCode: 1 }), "fixture"), /only valid for command/);
-		assert.throws(() => assertHostStepNode(hostStep({ monitorKind: "command", exitCode: 1 }), "fixture"), /only valid after command settlement/);
-	});
-
-	it("upserts through the host-owned persistence callback without touching legacy child steps", () => {
-		const status: AsyncStatus = {
-			runId: "workflow-1",
-			mode: "workflow",
-			state: "running",
-			startedAt: 1,
-			steps: [{ agent: "reviewer", workflowKey: "review", runId: "child-1", status: "running" }],
-		};
-		const writes: AsyncStatus[] = [];
-		const next = upsertHostStep({ status, hostStep: hostStep({ state: "done", verdict: "pass", updatedAt: 20 }), persist: (value) => writes.push(value) });
-		assert.equal(writes.length, 1);
-		assert.deepEqual(next.steps, status.steps);
-		assert.equal(next.workflowGraph?.nodes[0]?.kind, "host-step");
-		assert.equal(next.workflowGraph?.nodes[0]?.hostStep?.monitorKind, "gate");
-		assert.equal(next.workflowGraph?.nodes[0]?.status, "completed");
-		assert.equal(next.lastUpdate, 20);
-
-		const replaced = upsertHostStep({ status: next, hostStep: hostStep({ state: "error", updatedAt: 30 }), persist: (value) => writes.push(value) });
-		assert.equal(replaced.workflowGraph?.nodes.length, 1);
-		assert.equal(replaced.workflowGraph?.nodes[0]?.status, "failed");
-		assert.equal(writes.length, 2);
-	});
-
-	it("fails closed for malformed graph nodes while strict loaders can reject them", () => {
-		const graph = {
-			runId: "workflow-1",
-			mode: "workflow" as const,
-			phases: [],
-			nodes: [{ id: "bad", kind: "host-step" as const, label: "bad", status: "running" as const }],
-		};
-		assert.deepEqual(validHostStepNodes(graph), []);
-		assert.throws(() => assertHostStepNode(graph.nodes[0]?.hostStep, "status"), /expected an object/);
-	});
-
-	it("rejects ambiguous host-step identities", () => {
-		const duplicate = hostStep({ id: "duplicate" });
-		assert.throws(() => assertUniqueHostStepIds([duplicate, duplicate], "receipt"), /duplicate host step id/);
-		const graph = {
-			runId: "workflow-1",
-			mode: "workflow" as const,
-			phases: [],
-			nodes: [hostStepWorkflowNode(duplicate), hostStepWorkflowNode(duplicate)],
-		};
-		assert.deepEqual(validHostStepNodes(graph), []);
-		assert.throws(() => assertWorkflowGraphHostSteps(graph, "status", "workflow-1"), /duplicate host step id/);
-	});
-});