mirror of
https://bitbucket.org/siakitem/my-pi.git
synced 2026-10-26 10:45:22 +00:00
217 lines
11 KiB
TypeScript
217 lines
11 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import { dirname, join, resolve } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import { spawnSync } from "node:child_process";
|
|
import test from "node:test";
|
|
|
|
const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
|
|
const hasPi = spawnSync("pi", ["--version"], { encoding: "utf8" }).status === 0;
|
|
|
|
test("subagents source is retained but disabled in the root bundle", async () => {
|
|
const packageJson = JSON.parse(await readFile(join(repositoryRoot, "package.json"), "utf8")) as {
|
|
dependencies: Record<string, string>;
|
|
files: string[];
|
|
pi: { extensions: string[] };
|
|
};
|
|
assert.ok(packageJson.files.includes("pi-subagents"), "the bundle must retain the maintained subagents source");
|
|
assert.equal(packageJson.dependencies["@tintinweb/pi-subagents"], undefined);
|
|
assert.equal(
|
|
packageJson.pi.extensions.includes("./extensions/subagents.ts"),
|
|
false,
|
|
"the bundle must not default-load the disabled subagents wrapper",
|
|
);
|
|
});
|
|
|
|
test("all package extensions load together without global registration conflicts", { skip: !hasPi }, async () => {
|
|
const packageJson = JSON.parse(await readFile(join(repositoryRoot, "package.json"), "utf8")) as {
|
|
dependencies: Record<string, string>;
|
|
files: string[];
|
|
pi: { extensions: string[] };
|
|
};
|
|
assert.ok(
|
|
packageJson.pi.extensions.includes("./extensions/plugin-init.ts"),
|
|
"the bundle must expose the project plugin initializer command",
|
|
);
|
|
assert.ok(
|
|
packageJson.pi.extensions.includes("./hippo-memory-pi/index.ts"),
|
|
"the bundle must load the vendored official Hippo Memory extension",
|
|
);
|
|
assert.ok(
|
|
packageJson.pi.extensions.includes("./pi-minimal-footer/index.ts"),
|
|
"the bundle must load the locally maintained minimal footer",
|
|
);
|
|
assert.ok(
|
|
packageJson.pi.extensions.includes("./pi-extension-codex-fast-mode/index.ts"),
|
|
"the bundle must load the locally maintained Codex Fast mode extension",
|
|
);
|
|
assert.equal(packageJson.dependencies["pi-compaction"], "file:./pi-compaction");
|
|
assert.ok(packageJson.files.includes("pi-compaction"), "the packed bundle must include maintained pi-compaction source");
|
|
assert.ok(
|
|
packageJson.pi.extensions.includes("./pi-compaction/index.ts"),
|
|
"the bundle must load the unified pi-compaction authority",
|
|
);
|
|
assert.equal(packageJson.dependencies["pi-condense"], undefined);
|
|
assert.equal(packageJson.dependencies["@ogulcancelik/pi-codex-compaction"], undefined);
|
|
assert.equal(packageJson.dependencies["pi-context-view"], undefined);
|
|
assert.ok(packageJson.pi.extensions.includes("./extensions/context-view.ts"));
|
|
assert.ok(
|
|
packageJson.pi.extensions.indexOf("./pi-compaction/index.ts") <
|
|
packageJson.pi.extensions.indexOf("./extensions/context-view.ts"),
|
|
"the context observer must load after the compaction authority",
|
|
);
|
|
assert.ok(
|
|
packageJson.pi.extensions.indexOf("./pi-compaction/index.ts") <
|
|
packageJson.pi.extensions.indexOf("./pi-minimal-footer/index.ts"),
|
|
"the footer must load after the compaction metrics service",
|
|
);
|
|
assert.ok(packageJson.pi.extensions.includes("./pi-ssh/index.ts"), "the bundle must load the locally maintained SSH extension");
|
|
assert.equal(packageJson.dependencies["pi-ssh"], "file:./pi-ssh");
|
|
assert.equal(packageJson.dependencies.ssh2, "1.17.0", "the packed bundle must install pi-ssh's runtime transport");
|
|
assert.equal(packageJson.dependencies.jiti, "2.7.0", "the packed helper must load local TypeScript outside Pi");
|
|
assert.ok(packageJson.files.includes("pi-ssh"), "the packed bundle must include the locally maintained SSH source");
|
|
assert.ok(packageJson.files.includes("ssh_config.sh"), "the packed bundle must include the SSH host import helper");
|
|
assert.ok(packageJson.pi.extensions.includes("./pi-ask-user/index.ts"), "the bundle must load pi-ask-user");
|
|
assert.equal(packageJson.dependencies["pi-ask-user"], "file:./pi-ask-user");
|
|
assert.ok(packageJson.files.includes("pi-ask-user"), "the packed bundle must include pi-ask-user source");
|
|
const chromeExtension = "./pi-chrome/extensions/chrome-profile-bridge/index.ts";
|
|
assert.equal(packageJson.dependencies["pi-chrome"], "file:./pi-chrome", "the browser bridge must use the locally maintained source");
|
|
assert.ok(packageJson.files.includes("pi-chrome"), "the packed bundle must include the locally maintained pi-chrome source");
|
|
assert.ok(packageJson.pi.extensions.includes(chromeExtension), "the bundle must load the local Chrome profile bridge directly");
|
|
assert.ok(
|
|
packageJson.pi.extensions.indexOf(chromeExtension) <
|
|
packageJson.pi.extensions.indexOf("./pi-tool-search/extensions/index.ts"),
|
|
"pi-chrome must register before Tool Search catalogs its authorized tools",
|
|
);
|
|
const permissionPolicySource = await readFile(
|
|
join(repositoryRoot, "config", "pi-permission-policy.jsonc"),
|
|
"utf8",
|
|
);
|
|
const hardGuardSource = await readFile(
|
|
join(repositoryRoot, "config", "pi-permission-hard-guards.jsonc"),
|
|
"utf8",
|
|
);
|
|
const stripLineComments = (source: string): string => source.replace(/^\s*\/\/.*$/gmu, "");
|
|
const permissionConfig = JSON.parse(stripLineComments(permissionPolicySource)) as {
|
|
authorizerChain: string[];
|
|
permission: Record<string, unknown>;
|
|
};
|
|
const hardGuardConfig = JSON.parse(stripLineComments(hardGuardSource)) as {
|
|
permission: { path?: Record<string, string>; bash: Record<string, string> };
|
|
};
|
|
assert.equal(permissionConfig.permission.ssh_connect, "ask", "SSH connection must enter the permission gate");
|
|
assert.equal(permissionConfig.permission.ssh_cd, "ask", "remote workspace changes must enter the permission gate");
|
|
assert.deepEqual(permissionConfig.authorizerChain, ["auto-review"], "SSH connection asks must reach AutoReview");
|
|
assert.equal(hardGuardConfig.permission.path, undefined, "sensitive paths must not be hard-denied by default");
|
|
assert.equal(hardGuardConfig.permission.bash["rm -rf /"], "deny");
|
|
assert.equal(
|
|
packageJson.pi.extensions.some((entry) => entry.includes("pi-permission-auto-review")),
|
|
false,
|
|
"AutoReview must be integrated instead of loaded as a second extension",
|
|
);
|
|
assert.ok(
|
|
packageJson.pi.extensions.indexOf("./extensions/permission-system.ts") <
|
|
packageJson.pi.extensions.indexOf("./pi-ssh/index.ts"),
|
|
"the permission service must load before pi-ssh registers its permission bridge",
|
|
);
|
|
assert.ok(
|
|
packageJson.pi.extensions.indexOf("./pi-ssh/index.ts") <
|
|
packageJson.pi.extensions.indexOf("./pi-tool-search/extensions/index.ts"),
|
|
"pi-ssh tools must register before Tool Search builds its catalog",
|
|
);
|
|
assert.ok(
|
|
packageJson.pi.extensions.indexOf("./pi-ask-user/index.ts") <
|
|
packageJson.pi.extensions.indexOf("./pi-tool-search/extensions/index.ts"),
|
|
"ask_user_question must register before Tool Search builds its catalog",
|
|
);
|
|
assert.equal(
|
|
packageJson.dependencies["@firstpick/pi-extension-codex-fast-mode"],
|
|
"file:./pi-extension-codex-fast-mode",
|
|
);
|
|
assert.ok(
|
|
packageJson.files.includes("pi-extension-codex-fast-mode"),
|
|
"the packed bundle must include the locally maintained Codex Fast mode source",
|
|
);
|
|
assert.ok(
|
|
packageJson.pi.extensions.includes("./pi-notify/src/index.ts"),
|
|
"the bundle must load the locally maintained Kitty notification extension",
|
|
);
|
|
assert.equal(packageJson.dependencies["@smoose/pi-notify"], "file:./pi-notify");
|
|
assert.ok(
|
|
packageJson.files.includes("pi-notify"),
|
|
"the packed bundle must include the locally maintained notification source",
|
|
);
|
|
assert.equal(packageJson.dependencies["@ogulcancelik/pi-minimal-footer"], "file:./pi-minimal-footer");
|
|
assert.equal(packageJson.dependencies["@tintinweb/pi-subagents"], undefined);
|
|
assert.equal(packageJson.pi.extensions.includes("./extensions/subagents.ts"), false);
|
|
assert.equal(
|
|
packageJson.pi.extensions.some((entry) => entry.includes("pi-hermes-memory") || entry.includes("the-forge-flow")),
|
|
false,
|
|
"retired Hermes and third-party Hippo extensions must not be loaded",
|
|
);
|
|
assert.equal(packageJson.dependencies["@the-forge-flow/hippo-memory-pi"], undefined);
|
|
assert.equal(packageJson.dependencies["@sinclair/typebox"], undefined);
|
|
const home = await mkdtemp(join(tmpdir(), "my-pi-extension-load-"));
|
|
const mockBin = join(home, "bin");
|
|
await mkdir(mockBin, { recursive: true });
|
|
const hippo = join(mockBin, "hippo");
|
|
await writeFile(hippo, "#!/bin/sh\nprintf '%s\\n' 'Hippo Memory status'\n", "utf8");
|
|
await chmod(hippo, 0o755);
|
|
const args = ["--no-extensions"];
|
|
for (const entry of packageJson.pi.extensions) args.push("-e", resolve(repositoryRoot, entry));
|
|
args.push("--mode", "rpc");
|
|
|
|
const loadEnvironment = {
|
|
...process.env,
|
|
HOME: home,
|
|
XDG_CONFIG_HOME: join(home, ".config"),
|
|
PI_CODING_AGENT_DIR: join(home, ".pi-agent"),
|
|
MY_PI_SEARCH_CONFIG: join(home, "missing-search.env"),
|
|
PATH: `${mockBin}:${process.env.PATH ?? ""}`,
|
|
PI_OFFLINE: "1",
|
|
TAVILY_API_KEY: "",
|
|
EXA_API_KEY: "",
|
|
KEENABLE_API_KEY: "",
|
|
};
|
|
const runBundle = () => spawnSync("pi", args, {
|
|
encoding: "utf8",
|
|
timeout: 60_000,
|
|
env: loadEnvironment,
|
|
});
|
|
const result = runBundle();
|
|
|
|
assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
|
|
assert.doesNotMatch(`${result.stdout}\n${result.stderr}`, /Failed to load extension|conflicts with/u);
|
|
const deployedPermissionPolicy = await readFile(
|
|
join(home, ".pi-agent", "extensions", "pi-permission-system", "policy.jsonc"),
|
|
"utf8",
|
|
);
|
|
const deployedHardGuards = await readFile(
|
|
join(home, ".pi-agent", "extensions", "pi-permission-system", "hard-guards.jsonc"),
|
|
"utf8",
|
|
);
|
|
assert.equal(deployedPermissionPolicy, permissionPolicySource, "the seeded policy must match the bundle source");
|
|
assert.equal(deployedHardGuards, hardGuardSource, "the seeded hard guards must match the bundle source");
|
|
|
|
const deployedConfigDir = join(home, ".pi-agent", "extensions", "pi-permission-system");
|
|
const deployedPolicyPath = join(deployedConfigDir, "policy.jsonc");
|
|
const deployedHardGuardPath = join(deployedConfigDir, "hard-guards.jsonc");
|
|
const customPolicy = `{ "permission": { "*": "deny" } }\n`;
|
|
const customHardGuards = `{ "version": 1, "permission": { "*": "allow" } }\n`;
|
|
await writeFile(deployedPolicyPath, customPolicy, "utf8");
|
|
await writeFile(deployedHardGuardPath, customHardGuards, "utf8");
|
|
const preserveResult = runBundle();
|
|
assert.equal(preserveResult.status, 0, `${preserveResult.stdout}\n${preserveResult.stderr}`);
|
|
assert.equal(await readFile(deployedPolicyPath, "utf8"), customPolicy, "reload must preserve user policy edits");
|
|
assert.equal(await readFile(deployedHardGuardPath, "utf8"), customHardGuards, "reload must preserve user hard guards");
|
|
|
|
await rm(deployedPolicyPath);
|
|
const legacyPolicy = `{ "authorizerChain": ["auto-review"], "permission": { "*": "ask" } }\n`;
|
|
await writeFile(join(deployedConfigDir, "config.json"), legacyPolicy, "utf8");
|
|
const migrationResult = runBundle();
|
|
assert.equal(migrationResult.status, 0, `${migrationResult.stdout}\n${migrationResult.stderr}`);
|
|
assert.equal(await readFile(deployedPolicyPath, "utf8"), legacyPolicy, "legacy config.json must seed policy.jsonc once");
|
|
assert.equal(await readFile(deployedHardGuardPath, "utf8"), customHardGuards, "legacy migration must not replace hard guards");
|
|
});
|