@selesai/code 0.8.2 → 0.8.4

package/dist/extensions/pi-subagents/test/unit/path-resolution.test.ts

@@ -6,29 +6,40 @@ import * as path from "node:path";
 import { discoverAgents } from "../../src/agents/agents.ts";
 import { resolveSkillPath, clearSkillCache } from "../../src/agents/skills.ts";
 
-const tmpDir = path.join(os.tmpdir(), "pi-path-resolution-test");
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-path-resolution-"));
 const cwdDir = path.join(tmpDir, "cwd");
+const homeDir = path.join(tmpDir, "home");
+const userAgentsDir = path.join(homeDir, ".agents");
+const userAgentsCanary = path.join(userAgentsDir, ".data-loss-canary");
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+const originalAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
 
-const realHomeDir = os.homedir();
-const realUserAgentsDir = path.join(realHomeDir, ".agents");
-const userAgentsDirBackup = path.join(tmpDir, ".agents_backup");
+function restoreEnv(name: "HOME" | "USERPROFILE" | "SELESAI_CODING_AGENT_DIR", value: string | undefined): void {
+	if (value === undefined) delete process.env[name];
+	else process.env[name] = value;
+}
 
 before(() => {
 	fs.mkdirSync(cwdDir, { recursive: true });
-
-	if (fs.existsSync(realUserAgentsDir)) {
-		fs.cpSync(realUserAgentsDir, userAgentsDirBackup, { recursive: true });
-	}
+	fs.mkdirSync(path.join(userAgentsDir, "skills"), { recursive: true });
+	fs.writeFileSync(userAgentsCanary, "preserve me");
+	process.env.HOME = homeDir;
+	process.env.USERPROFILE = homeDir;
+	assert.equal(os.homedir(), homeDir);
+	process.env.SELESAI_CODING_AGENT_DIR = path.join(homeDir, ".selesai", "agent");
 });
 
 after(() => {
-	if (fs.existsSync(userAgentsDirBackup)) {
-		fs.rmSync(realUserAgentsDir, { recursive: true, force: true });
-		fs.cpSync(userAgentsDirBackup, realUserAgentsDir, { recursive: true });
-	} else {
-		fs.rmSync(realUserAgentsDir, { recursive: true, force: true });
+	try {
+		assert.equal(fs.readFileSync(userAgentsCanary, "utf-8"), "preserve me");
+	} finally {
+		restoreEnv("HOME", originalHome);
+		restoreEnv("USERPROFILE", originalUserProfile);
+		restoreEnv("SELESAI_CODING_AGENT_DIR", originalAgentDir);
+		clearSkillCache();
+		fs.rmSync(tmpDir, { recursive: true, force: true });
 	}
-	fs.rmSync(tmpDir, { recursive: true, force: true });
 });
 
 describe("Path resolution for .agents and ~/.agents", () => {
@@ -44,7 +55,7 @@ describe("Path resolution for .agents and ~/.agents", () => {
 	});
 
 	test("should resolve skills in ~/.agents/skills", () => {
-		const userSkillsDir = path.join(realHomeDir, ".agents", "skills");
+		const userSkillsDir = path.join(userAgentsDir, "skills");
 		fs.mkdirSync(userSkillsDir, { recursive: true });
 		fs.writeFileSync(path.join(userSkillsDir, "test-skill-2.md"), "---\nname: test-skill-2\ndescription: test desc\n---\nSkill content");
 
@@ -79,8 +90,6 @@ describe("Path resolution for .agents and ~/.agents", () => {
 	});
 
 	test("should resolve agents in ~/.agents", () => {
-		const userAgentsDir = path.join(realHomeDir, ".agents");
-		fs.mkdirSync(userAgentsDir, { recursive: true });
 		fs.writeFileSync(
 			path.join(userAgentsDir, "test-agent-2.md"),
 			"---\nname: test-agent-2\ndescription: Test agent\n---\nAgent content"

package/dist/extensions/pi-subagents/test/unit/pi-args-permission-system.test.ts

@@ -0,0 +1,405 @@
+/**
+ * Permission-system compatibility tests:
+ * - <active_agent> tag injection into child system prompts
+ * - Permission-system extension auto-detection
+ */
+
+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 {
+	buildPiArgs,
+	resolvePermissionSystemExtension,
+	resolvePiLaunchToolPlan,
+} from "../../src/runs/shared/pi-args.ts";
+
+const originalEnv = {
+	HOME: process.env.HOME,
+	USERPROFILE: process.env.USERPROFILE,
+	SELESAI_CODING_AGENT_DIR: process.env.SELESAI_CODING_AGENT_DIR,
+};
+const tempRoots: string[] = [];
+
+function createFixture() {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-args-perm-"));
+	tempRoots.push(root);
+	const home = path.join(root, "home");
+	const agentDir = path.join(home, ".selesai", "agent");
+	const projectDir = path.join(root, "project");
+	fs.mkdirSync(agentDir, { recursive: true });
+	fs.mkdirSync(projectDir, { recursive: true });
+	process.env.HOME = home;
+	process.env.USERPROFILE = home;
+	process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+	process.chdir(projectDir);
+	return { root, agentDir, projectDir };
+}
+
+afterEach(() => {
+	for (const key of Object.keys(originalEnv)) {
+		const value = originalEnv[key as keyof typeof originalEnv];
+		if (value === undefined) delete process.env[key];
+		else process.env[key] = value;
+	}
+	for (const root of tempRoots) {
+		try {
+			fs.rmSync(root, { recursive: true, force: true });
+		} catch {
+			// best effort
+		}
+	}
+	tempRoots.length = 0;
+});
+
+function readPromptFile(result: { tempDir?: string }): string {
+	assert.ok(result.tempDir, "expected a temp dir from buildPiArgs");
+	const files = fs.readdirSync(result.tempDir);
+	const promptFile = files.find((f: string) => f.endsWith(".md"));
+	assert.ok(promptFile, "expected a prompt.md file");
+	return fs.readFileSync(path.join(result.tempDir, promptFile), "utf-8");
+}
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+describe("resolvePermissionSystemExtension", () => {
+	it("returns undefined when extension is not installed", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const result = resolvePermissionSystemExtension();
+		assert.equal(result, undefined);
+	});
+
+	it("throws when an installed extension dir has no package.json", () => {
+		const { agentDir } = createFixture();
+		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
+		const pkgPath = path.join(extDir, "package.json");
+		fs.mkdirSync(extDir, { recursive: true });
+		assert.throws(
+			() => resolvePermissionSystemExtension(),
+			new RegExp(`Permission-system package manifest is missing at ${escapeRegExp(pkgPath)}`),
+		);
+	});
+
+	it("throws when package.json has no valid pi.extensions entry", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
+		const pkgPath = path.join(extDir, "package.json");
+		fs.mkdirSync(extDir, { recursive: true });
+
+		for (const value of [
+			{ name: "test" },
+			{ name: "test", pi: { extensions: "./src/index.ts" } },
+			{ name: "test", pi: { extensions: [123] } },
+		]) {
+			fs.writeFileSync(pkgPath, JSON.stringify(value));
+			assert.throws(
+				() => resolvePermissionSystemExtension(),
+				new RegExp(`Permission-system package manifest at ${escapeRegExp(pkgPath)}`),
+			);
+		}
+	});
+
+	it("throws when package.json is malformed", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
+		const pkgPath = path.join(extDir, "package.json");
+		fs.mkdirSync(extDir, { recursive: true });
+		fs.writeFileSync(pkgPath, "{ malformed");
+
+		assert.throws(
+			() => resolvePermissionSystemExtension(),
+			new RegExp(`Cannot read permission-system package manifest at ${escapeRegExp(pkgPath)}`),
+		);
+	});
+
+	it("throws when package.json cannot be read", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
+		const pkgPath = path.join(extDir, "package.json");
+		fs.mkdirSync(pkgPath, { recursive: true });
+
+		assert.throws(
+			() => resolvePermissionSystemExtension(),
+			new RegExp(`Cannot read permission-system package manifest at ${escapeRegExp(pkgPath)}`),
+		);
+	});
+
+	it("throws with manifest context when package.json is not an object", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
+		const pkgPath = path.join(extDir, "package.json");
+		fs.mkdirSync(extDir, { recursive: true });
+		fs.writeFileSync(pkgPath, "null");
+
+		assert.throws(
+			() => resolvePermissionSystemExtension(),
+			new RegExp(`Cannot read permission-system package manifest at ${escapeRegExp(pkgPath)}`),
+		);
+	});
+
+	it("uses a valid fallback installation when the first candidate is malformed or missing a manifest", () => {
+		for (const primarySetup of [
+			(dir: string) => fs.writeFileSync(path.join(dir, "package.json"), "{ malformed"),
+			() => undefined,
+		]) {
+			const { agentDir } = createFixture();
+			const primaryDir = path.join(
+				agentDir,
+				"npm",
+				"node_modules",
+				"@gotgenes",
+				"pi-permission-system",
+			);
+			const fallbackDir = path.join(agentDir, "extensions", "pi-permission-system");
+			fs.mkdirSync(primaryDir, { recursive: true });
+			primarySetup(primaryDir);
+			fs.mkdirSync(path.join(fallbackDir, "src"), { recursive: true });
+			fs.writeFileSync(
+				path.join(fallbackDir, "package.json"),
+				JSON.stringify({ name: "test", pi: { extensions: ["./src/index.ts"] } }),
+			);
+			fs.writeFileSync(
+				path.join(fallbackDir, "src", "index.ts"),
+				"export default () => {};",
+			);
+
+			const result = resolvePermissionSystemExtension();
+
+			assert.equal(result, path.join(fallbackDir, "src", "index.ts"));
+		}
+	});
+
+	it("returns extension path when fully installed", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
+		fs.mkdirSync(extDir, { recursive: true });
+		fs.writeFileSync(
+			path.join(extDir, "package.json"),
+			JSON.stringify({ name: "test", pi: { extensions: ["./src/index.ts"] } }),
+		);
+		fs.mkdirSync(path.join(extDir, "src"), { recursive: true });
+		fs.writeFileSync(
+			path.join(extDir, "src", "index.ts"),
+			"export default () => {};",
+		);
+		const result = resolvePermissionSystemExtension();
+		assert.ok(result, "expected extension path");
+		if (!result) return; // narrow for TS
+		assert.ok(
+			result.endsWith(path.join("pi-permission-system", "src", "index.ts")),
+		);
+	});
+
+	it("throws when the configured entry file does not exist", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
+		const pkgPath = path.join(extDir, "package.json");
+		fs.mkdirSync(extDir, { recursive: true });
+		fs.writeFileSync(
+			pkgPath,
+			JSON.stringify({
+				name: "test",
+				pi: { extensions: ["./src/missing.ts"] },
+			}),
+		);
+
+		assert.throws(
+			() => resolvePermissionSystemExtension(),
+			new RegExp(`Permission-system extension entry .* in ${escapeRegExp(pkgPath)} does not exist`),
+		);
+	});
+});
+
+describe("resolvePiLaunchToolPlan with permission system", () => {
+	it("adds the permission system extension to buildPiArgs when installed", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
+		fs.mkdirSync(path.join(extDir, "src"), { recursive: true });
+		fs.writeFileSync(
+			path.join(extDir, "src", "index.ts"),
+			"export default () => {};",
+		);
+		fs.writeFileSync(
+			path.join(extDir, "package.json"),
+			JSON.stringify({ name: "test", pi: { extensions: ["./src/index.ts"] } }),
+		);
+
+		const { args } = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "test task",
+			sessionEnabled: false,
+			inheritProjectContext: false,
+			inheritSkills: false,
+		});
+		const extensionArgs = args.filter(
+			(arg, index) => args[index - 1] === "--extension",
+		);
+		assert.ok(
+			extensionArgs.includes(path.join(extDir, "src", "index.ts")),
+			"permission system extension should be emitted as an extension argument",
+		);
+	});
+
+	it("does NOT include permission system when not installed", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+
+		const plan = resolvePiLaunchToolPlan({});
+		const permExt = plan.runtimeExtensions.find((e) =>
+			e.includes("pi-permission-system"),
+		);
+		assert.equal(permExt, undefined);
+	});
+
+	it("does NOT include permission system when denyExtensions is set", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const extDir = path.join(
+			agentDir,
+			"npm",
+			"node_modules",
+			"@gotgenes",
+			"pi-permission-system",
+		);
+		fs.mkdirSync(path.join(extDir, "src"), { recursive: true });
+		fs.writeFileSync(
+			path.join(extDir, "src", "index.ts"),
+			"export default () => {};",
+		);
+		fs.writeFileSync(
+			path.join(extDir, "package.json"),
+			JSON.stringify({ name: "test", pi: { extensions: ["./src/index.ts"] } }),
+		);
+
+		const plan = resolvePiLaunchToolPlan({
+			capabilityCeiling: {
+				version: 1 as const,
+				allowedTools: ["read"],
+				denyExtensions: true,
+				sources: ["test"],
+			},
+		});
+		const permExt = plan.runtimeExtensions.find((e) =>
+			e.includes("pi-permission-system"),
+		);
+		assert.equal(permExt, undefined);
+	});
+});
+
+describe("buildPiArgs <active_agent> tag injection", () => {
+	it("prepends <active_agent> tag when childAgentName is set", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+
+		const result = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "test task",
+			sessionEnabled: false,
+			systemPrompt: "You are a helpful assistant.",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			childAgentName: "reviewer",
+			promptFileStem: "reviewer",
+		});
+
+		const promptContent = readPromptFile(result);
+		assert.ok(
+			promptContent.startsWith('<active_agent name="reviewer"/>'),
+			`expected prompt to start with <active_agent> tag, got: ${promptContent.slice(0, 100)}`,
+		);
+		assert.ok(
+			promptContent.includes("You are a helpful assistant."),
+			"original prompt should be preserved after the tag",
+		);
+	});
+
+	it("does NOT inject tag when childAgentName is not set", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+
+		const result = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "test task",
+			sessionEnabled: false,
+			systemPrompt: "You are a helper.",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			promptFileStem: "test",
+		});
+
+		const promptContent = readPromptFile(result);
+		assert.equal(
+			promptContent.includes("<active_agent"),
+			false,
+			"should not inject tag when no childAgentName",
+		);
+		assert.equal(promptContent, "You are a helper.");
+	});
+
+	it("does NOT inject tag when systemPrompt is empty", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+
+		const result = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "test task",
+			sessionEnabled: false,
+			systemPrompt: "",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			childAgentName: "worker",
+			promptFileStem: "worker",
+		});
+
+		const promptContent = readPromptFile(result);
+		assert.ok(promptContent.startsWith('<active_agent name="worker"/>'));
+	});
+
+	it("escapes XML metacharacters in agent name", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+
+		const result = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "test task",
+			sessionEnabled: false,
+			systemPrompt: "System prompt here",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			childAgentName: 'my "special" agent',
+			promptFileStem: "test",
+		});
+
+		const promptContent = readPromptFile(result);
+		assert.ok(
+			promptContent.startsWith('<active_agent name="my &quot;special&quot; agent"/>'),
+			`expected escaped tag, got: ${promptContent.slice(0, 120)}`,
+		);
+	});
+
+	it("runtimeExtensions include prompt runtime path (pre-existing behavior)", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+
+		const plan = resolvePiLaunchToolPlan({});
+		assert.ok(plan.runtimeExtensions.length >= 1);
+		const hasPromptRuntime = plan.runtimeExtensions.some((e) =>
+			e.endsWith("subagent-prompt-runtime.ts"),
+		);
+		assert.ok(
+			hasPromptRuntime,
+			"prompt runtime extension should always be included",
+		);
+	});
+});