@selesai/code 0.2.1 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/model-scope.test.ts

@@ -0,0 +1,145 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	checkModelScope,
+	matchesScopePattern,
+	parseModelScopeConfig,
+	type ModelScopeConfig,
+} from "../../src/runs/shared/model-scope.ts";
+
+describe("matchesScopePattern", () => {
+	it("matches an exact provider/id", () => {
+		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "anthropic/claude-sonnet-4"), true);
+	});
+
+	it("matches a provider wildcard", () => {
+		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "anthropic/*"), true);
+		assert.equal(matchesScopePattern("anthropic/claude-haiku-4-5", "anthropic/*"), true);
+	});
+
+	it("matches a model-prefix wildcard", () => {
+		assert.equal(matchesScopePattern("openai/gpt-5-mini", "openai/gpt-5-*"), true);
+		// The dash in the pattern is literal, so the bare id without a trailing part does not match.
+		assert.equal(matchesScopePattern("openai/gpt-5", "openai/gpt-5-*"), false);
+		assert.equal(matchesScopePattern("openai/gpt-5", "openai/gpt-5*"), true);
+	});
+
+	it("does not match across providers", () => {
+		assert.equal(matchesScopePattern("deepseek/deepseek-v4", "anthropic/*"), false);
+		assert.equal(matchesScopePattern("openai/gpt-5-mini", "anthropic/*"), false);
+	});
+
+	it("ignores case on both sides", () => {
+		assert.equal(matchesScopePattern("Anthropic/Claude-Sonnet-4", "anthropic/*"), true);
+		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "ANTHROPIC/CLAUDE-*"), true);
+	});
+
+	it("strips a thinking suffix before matching", () => {
+		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4:high", "anthropic/claude-sonnet-4"), true);
+		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4:high", "anthropic/*"), true);
+	});
+
+	it("does not treat arbitrary colon text as a thinking suffix", () => {
+		assert.equal(matchesScopePattern("anthropic:claude-opus", "anthropic"), false);
+		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4:experimental", "anthropic/claude-sonnet-4"), false);
+	});
+
+	it("requires a full match, not a substring", () => {
+		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "anthropic/claude"), false);
+		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "*claude*"), true);
+	});
+});
+
+describe("checkModelScope", () => {
+	const scope: ModelScopeConfig = { enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] };
+
+	it("returns undefined when enforcement is off", () => {
+		assert.equal(checkModelScope("deepseek/deepseek-v4", { enforce: false, allow: ["anthropic/*"] }, "explicit"), undefined);
+		assert.equal(checkModelScope("deepseek/deepseek-v4", undefined, "explicit"), undefined);
+	});
+
+	it("returns undefined when no allow list is configured", () => {
+		assert.equal(checkModelScope("deepseek/deepseek-v4", { enforce: true }, "explicit"), undefined);
+		assert.equal(checkModelScope("deepseek/deepseek-v4", { enforce: true, allow: [] }, "explicit"), undefined);
+	});
+
+	it("returns undefined when the model is in scope", () => {
+		assert.equal(checkModelScope("anthropic/claude-sonnet-4", scope, "explicit"), undefined);
+		assert.equal(checkModelScope("openai/gpt-5-mini:high", scope, "inherited"), undefined);
+	});
+
+	it("returns an error violation for an explicit out-of-scope model", () => {
+		const violation = checkModelScope("deepseek/deepseek-v4", scope, "explicit");
+		assert.equal(violation?.severity, "error");
+		assert.equal(violation?.model, "deepseek/deepseek-v4");
+		assert.deepEqual(violation?.allowedPatterns, ["anthropic/*", "openai/gpt-5-*"]);
+		assert.match(violation?.message ?? "", /outside the configured subagent model scope/);
+	});
+
+	it("returns a warn violation for an inherited out-of-scope model", () => {
+		const violation = checkModelScope("deepseek/deepseek-v4", scope, "inherited");
+		assert.equal(violation?.severity, "warn");
+	});
+
+	it("defaults to inherited (warn) severity when source is omitted-ish via inherited", () => {
+		// Caller passes "inherited" for frontmatter/parent-inherited models.
+		assert.equal(checkModelScope("meta/llama-4", scope, "inherited")?.severity, "warn");
+	});
+
+	it("strips the thinking suffix from the reported model", () => {
+		const violation = checkModelScope("deepseek/deepseek-v4:high", scope, "explicit");
+		assert.equal(violation?.model, "deepseek/deepseek-v4");
+	});
+
+	it("returns undefined for an undefined model", () => {
+		assert.equal(checkModelScope(undefined, scope, "explicit"), undefined);
+	});
+});
+
+describe("parseModelScopeConfig", () => {
+	const meta = { filePath: "~/.pi/agent/settings.json" };
+
+	it("returns undefined when the field is absent", () => {
+		assert.equal(parseModelScopeConfig(undefined, meta), undefined);
+	});
+
+	it("parses a well-formed config", () => {
+		assert.deepEqual(
+			parseModelScopeConfig({ enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] }, meta),
+			{ enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] },
+		);
+	});
+
+	it("parses enforce alone", () => {
+		assert.deepEqual(parseModelScopeConfig({ enforce: false }, meta), { enforce: false });
+	});
+
+	it("trims allow patterns and drops empties", () => {
+		assert.deepEqual(
+			parseModelScopeConfig({ enforce: true, allow: ["  anthropic/*  ", "", "  "] }, meta),
+			{ enforce: true, allow: ["anthropic/*"] },
+		);
+	});
+
+	it("rejects a non-object value", () => {
+		assert.throws(() => parseModelScopeConfig("anthropic/*", meta), /invalid 'modelScope'/);
+		assert.throws(() => parseModelScopeConfig([], meta), /invalid 'modelScope'/);
+	});
+
+	it("rejects a non-boolean enforce", () => {
+		assert.throws(() => parseModelScopeConfig({ enforce: "yes" }, meta), /invalid 'modelScope.enforce'/);
+	});
+
+	it("rejects a non-array allow", () => {
+		assert.throws(() => parseModelScopeConfig({ allow: "anthropic/*" }, meta), /invalid 'modelScope.allow'/);
+	});
+
+	it("rejects an allow array with non-string entries", () => {
+		assert.throws(() => parseModelScopeConfig({ enforce: true, allow: ["anthropic/*", 42] }, meta), /invalid 'modelScope.allow'/);
+	});
+
+	it("rejects enforce without a non-empty allow list", () => {
+		assert.throws(() => parseModelScopeConfig({ enforce: true }, meta), /without a non-empty 'allow'/);
+		assert.throws(() => parseModelScopeConfig({ enforce: true, allow: [] }, meta), /non-empty array of patterns/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/native-supervisor-channel.test.ts

@@ -0,0 +1,162 @@
+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 { randomUUID } from "node:crypto";
+import { afterEach, describe, it } from "node:test";
+import {
+	NATIVE_SUPERVISOR_TOOL_NAME,
+	createNativeSupervisorChannel,
+	ensureSupervisorChannelDir,
+	resolveSupervisorChannelDir,
+} from "../../src/intercom/native-supervisor-channel.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+
+const createdChannels: string[] = [];
+
+function makeState(sessionId: string | null, ctx: unknown): SubagentState {
+	return {
+		baseCwd: process.cwd(),
+		currentSessionId: sessionId,
+		asyncJobs: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		cleanupTimers: new Map(),
+		lastUiContext: ctx as SubagentState["lastUiContext"],
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
+function writeRequest(input: { sessionId: string; runId: string; agent?: string; index?: number; message?: string }): string {
+	const agent = input.agent ?? "worker";
+	const index = input.index ?? 0;
+	const channelDir = resolveSupervisorChannelDir(input.runId, agent, index);
+	createdChannels.push(channelDir);
+	ensureSupervisorChannelDir(channelDir);
+	const requestId = randomUUID();
+	fs.writeFileSync(path.join(channelDir, "requests", `${requestId}.json`), JSON.stringify({
+		type: "subagent.supervisor.request",
+		id: requestId,
+		createdAt: Date.now(),
+		reason: "need_decision",
+		message: input.message ?? "Need a decision",
+		expectsReply: true,
+		orchestratorSessionId: input.sessionId,
+		orchestratorTarget: "shared-name",
+		runId: input.runId,
+		agent,
+		childIndex: index,
+	}, null, "\t"));
+	return requestId;
+}
+
+afterEach(() => {
+	for (const channel of createdChannels.splice(0)) fs.rmSync(channel, { recursive: true, force: true });
+});
+
+describe("native supervisor channel", () => {
+	it("delivers requests only to the exact current session id", () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const otherSessionId = `session-${randomUUID()}`;
+		const matchingId = writeRequest({ sessionId: currentSessionId, runId: `run-${randomUUID()}` });
+		const otherId = writeRequest({ sessionId: otherSessionId, runId: `run-${randomUUID()}` });
+		const sent: Array<{ content?: string; details?: { id?: string } }> = [];
+		const registeredTools: string[] = [];
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [],
+			registerTool: (tool: { name: string }) => { registeredTools.push(tool.name); },
+			sendMessage: (message: { content?: string; details?: { id?: string } }) => { sent.push(message); },
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
+
+		assert.deepEqual(registeredTools, []);
+		channel.start();
+		channel.dispose();
+
+		assert.deepEqual(registeredTools, [NATIVE_SUPERVISOR_TOOL_NAME, "intercom"]);
+		assert.deepEqual(sent.map((message) => message.details?.id), [matchingId]);
+		assert.equal(channel.pending.has(matchingId), false, "disposed channel clears pending requests");
+		assert.equal(sent.some((message) => message.details?.id === otherId), false);
+	});
+
+	it("matches supervisor requests against the runtime session id instead of persisted session file path", () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const persistedSessionFile = path.join(os.tmpdir(), `${currentSessionId}.jsonl`);
+		const matchingId = writeRequest({ sessionId: currentSessionId, runId: `run-${randomUUID()}` });
+		const sent: Array<{ details?: { id?: string } }> = [];
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => persistedSessionFile,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [],
+			registerTool: () => {},
+			sendMessage: (message: { details?: { id?: string } }) => { sent.push(message); },
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(persistedSessionFile, ctx));
+
+		channel.start();
+		channel.dispose();
+
+		assert.deepEqual(sent.map((message) => message.details?.id), [matchingId]);
+	});
+
+	it("keeps an installed intercom tool and still exposes a native supervisor reply path", async () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const runId = `run-${randomUUID()}`;
+		const requestId = writeRequest({ sessionId: currentSessionId, runId });
+		const registeredTools = new Map<string, { execute: (_id: string, params: { action: string; replyTo?: string; message?: string }) => Promise<unknown> }>();
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [{ name: "intercom" }, ...[...registeredTools.keys()].map((name) => ({ name }))],
+			registerTool: (tool: { name: string; execute: (_id: string, params: { action: string; replyTo?: string; message?: string }) => Promise<unknown> }) => {
+				registeredTools.set(tool.name, tool);
+			},
+			sendMessage: () => {},
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
+
+		try {
+			assert.deepEqual([...registeredTools.keys()], []);
+			channel.start();
+
+			assert.deepEqual([...registeredTools.keys()], [NATIVE_SUPERVISOR_TOOL_NAME]);
+			await registeredTools.get(NATIVE_SUPERVISOR_TOOL_NAME)?.execute("reply", { action: "reply", replyTo: requestId, message: "Approved" });
+			const replyFile = path.join(resolveSupervisorChannelDir(runId, "worker", 0), "replies", `${requestId}.json`);
+			const reply = JSON.parse(fs.readFileSync(replyFile, "utf-8")) as { message?: string; requestId?: string };
+			assert.equal(reply.requestId, requestId);
+			assert.equal(reply.message, "Approved");
+		} finally {
+			channel.dispose();
+		}
+	});
+});