* feat(setup): add native Pi client support * fix(setup): isolate invalid Pi agent directory overrides Keep malformed Pi path evidence on its client entry so unrelated selected clients can complete setup and doctor. Preserve explicit Pi rejection and block filesystem operations rather than falling back to another directory. * fix(setup): parse Pi configuration as strict JSON Pi's installed MCP loader reads mcp.json with a bare JSON.parse and no BOM tolerance, so comments, trailing commas, a BOM, or an empty existing file yield loader errors and no servers. Parsing the Pi dialect with objectSchema.parse(JSON.parse(text)) before the shared empty/JSONC shortcut rejects those files at every mutation boundary instead of reporting configured registrations Pi cannot load. A missing file still initializes a fresh strict-JSON document, other dialects keep their JSONC/BOM/empty tolerance, and malformed files are never rewritten. --------- Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
302 lines
9.7 KiB
TypeScript
302 lines
9.7 KiB
TypeScript
import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
|
|
import { join, resolve } from "node:path";
|
|
|
|
import { expect } from "vitest";
|
|
|
|
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
|
import { cliTest } from "../../support/cli/cliFixture.js";
|
|
|
|
cliTest(
|
|
"Pi public CLI plans, requires approval, applies, diagnoses, repeats, and uninstalls only owned content",
|
|
async ({ cli }) => {
|
|
const home = await createTestTempDirectory("rea-pi-cli-");
|
|
const agent = join(home, "custom-agent");
|
|
const config = join(agent, "mcp.json");
|
|
const skill = join(
|
|
home,
|
|
".agents/skills/reverse-engineer-anything/SKILL.md",
|
|
);
|
|
const original =
|
|
'{ "mcpServers": { "other": { "command": "other-server" } }, "autoEnableCodemode": false }\n';
|
|
await mkdir(agent);
|
|
await writeFile(config, original);
|
|
const cliPath = resolve("scripts/rea.mjs");
|
|
const run = (arguments_: readonly string[]) =>
|
|
cli.run({
|
|
arguments: arguments_,
|
|
cwd: home,
|
|
environment: {
|
|
HOME: home,
|
|
USERPROFILE: home,
|
|
PI_CODING_AGENT_DIR: "custom-agent",
|
|
OMP_PROFILE: "work",
|
|
PI_PROFILE: "legacy",
|
|
PI_CONFIG_DIR: ".omp-other",
|
|
},
|
|
timeoutMs: 20_000,
|
|
});
|
|
|
|
const planned = await run([
|
|
"setup",
|
|
"--client",
|
|
"pi",
|
|
"--dry-run",
|
|
"--json",
|
|
]);
|
|
expect(planned.exitCode).toBe(0);
|
|
expect(planned.json).toMatchObject({
|
|
status: "planned",
|
|
plannedActions: [
|
|
{
|
|
id: "configure_client:pi",
|
|
label: "Pi",
|
|
target: join("custom-agent", "mcp.json"),
|
|
operation: "update",
|
|
},
|
|
{ id: "install_skill" },
|
|
],
|
|
appliedActions: [],
|
|
});
|
|
expect(await readFile(config, "utf8")).toBe(original);
|
|
await expect(readFile(`${config}.rea.backup`)).rejects.toMatchObject({
|
|
code: "ENOENT",
|
|
});
|
|
await expect(readFile(skill)).rejects.toMatchObject({ code: "ENOENT" });
|
|
|
|
const unapproved = await run(["setup", "--client", "pi", "--json"]);
|
|
expect(unapproved.json).toMatchObject({
|
|
status: "needs_confirmation",
|
|
appliedActions: [],
|
|
});
|
|
expect(await readFile(config, "utf8")).toBe(original);
|
|
|
|
const applied = await run(["setup", "--client", "pi", "--yes", "--json"]);
|
|
expect(applied.exitCode).toBe(0);
|
|
expect(applied.json).toMatchObject({
|
|
status: "ready",
|
|
clients: { pi: { status: "configured" } },
|
|
appliedActions: ["configured_pi", "installed_skill"],
|
|
});
|
|
const configured = await readFile(config, "utf8");
|
|
expect(JSON.parse(configured)).toMatchObject({
|
|
mcpServers: {
|
|
other: { command: "other-server" },
|
|
rea: {
|
|
type: "stdio",
|
|
command: process.platform === "win32" ? process.execPath : cliPath,
|
|
args: process.platform === "win32" ? [cliPath, "mcp"] : ["mcp"],
|
|
},
|
|
},
|
|
autoEnableCodemode: false,
|
|
});
|
|
expect(await readFile(`${config}.rea.backup`, "utf8")).toBe(original);
|
|
expect(await readFile(skill, "utf8")).toContain(
|
|
"reverse-engineer-anything",
|
|
);
|
|
|
|
const doctor = await run(["doctor", "--client", "pi", "--json"]);
|
|
expect(doctor.exitCode).toBe(0);
|
|
expect(doctor.json).toMatchObject({
|
|
healthy: true,
|
|
identity: { registrations: [{ client: "pi", state: "aligned" }] },
|
|
});
|
|
|
|
const repeat = await run(["setup", "--client", "pi", "--yes", "--json"]);
|
|
expect(repeat.exitCode).toBe(0);
|
|
expect(repeat.json).toMatchObject({
|
|
status: "ready",
|
|
plannedActions: [],
|
|
appliedActions: [],
|
|
});
|
|
expect(await readFile(config, "utf8")).toBe(configured);
|
|
expect(await readFile(`${config}.rea.backup`, "utf8")).toBe(original);
|
|
|
|
// Uninstall is global; there is no --client or --yes on this CLI surface.
|
|
const help = await run(["uninstall", "--help"]);
|
|
expect(help.exitCode).toBe(0);
|
|
expect(help.stdout).toContain("--purge-data");
|
|
const removed = await run(["uninstall", "--json"]);
|
|
expect(removed.exitCode).toBe(0);
|
|
expect(JSON.parse(await readFile(config, "utf8"))).toEqual(
|
|
JSON.parse(original),
|
|
);
|
|
expect(await readFile(`${config}.rea.backup`, "utf8")).toBe(original);
|
|
await expect(readFile(skill)).rejects.toMatchObject({ code: "ENOENT" });
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"Pi public CLI creates missing strict-JSON configuration and never repairs a malformed file",
|
|
async ({ cli }) => {
|
|
const created = await createTestTempDirectory("rea-pi-cli-strict-");
|
|
const agent = join(created, "custom-agent");
|
|
const config = join(agent, "mcp.json");
|
|
await mkdir(agent);
|
|
const runIn = (home: string) => (arguments_: readonly string[]) =>
|
|
cli.run({
|
|
arguments: arguments_,
|
|
cwd: home,
|
|
environment: {
|
|
HOME: home,
|
|
USERPROFILE: home,
|
|
PI_CODING_AGENT_DIR: "custom-agent",
|
|
},
|
|
timeoutMs: 20_000,
|
|
});
|
|
const run = runIn(created);
|
|
const setup = await run(["setup", "--client", "pi", "--yes", "--json"]);
|
|
expect(setup.exitCode).toBe(0);
|
|
expect(setup.json).toMatchObject({
|
|
status: "ready",
|
|
clients: { pi: { status: "configured" } },
|
|
});
|
|
const text = await readFile(config, "utf8");
|
|
expect(() => JSON.parse(text)).not.toThrow();
|
|
expect(JSON.parse(text)).toMatchObject({
|
|
mcpServers: { rea: { type: "stdio" } },
|
|
});
|
|
const doctor = await run(["doctor", "--client", "pi", "--json"]);
|
|
expect(doctor.exitCode).toBe(0);
|
|
expect(doctor.json).toMatchObject({
|
|
healthy: true,
|
|
identity: { registrations: [{ client: "pi", state: "aligned" }] },
|
|
});
|
|
await run(["uninstall", "--json"]);
|
|
expect(
|
|
JSON.parse(await readFile(config, "utf8")).mcpServers.rea,
|
|
).toBeUndefined();
|
|
|
|
const blocked = await createTestTempDirectory("rea-pi-cli-malformed-");
|
|
const malformedPath = join(blocked, "custom-agent", "mcp.json");
|
|
await mkdir(join(blocked, "custom-agent"));
|
|
const malformed = `{ // Pi loads strict JSON only\n"mcpServers": { "other": { "command": "other" } }\n}\n`;
|
|
await writeFile(malformedPath, malformed);
|
|
const runMalformed = runIn(blocked);
|
|
const plan = await runMalformed([
|
|
"setup",
|
|
"--client",
|
|
"pi",
|
|
"--dry-run",
|
|
"--json",
|
|
]);
|
|
expect(plan.exitCode).not.toBe(0);
|
|
expect(plan.json).toMatchObject({
|
|
status: "needs_human",
|
|
plannedActions: [],
|
|
appliedActions: [],
|
|
remediation: expect.stringContaining("malformed"),
|
|
});
|
|
const applied = await runMalformed([
|
|
"setup",
|
|
"--client",
|
|
"pi",
|
|
"--yes",
|
|
"--json",
|
|
]);
|
|
expect(applied.exitCode).not.toBe(0);
|
|
expect(applied.json).toMatchObject({
|
|
status: "needs_human",
|
|
plannedActions: [],
|
|
appliedActions: [],
|
|
});
|
|
expect(await readFile(malformedPath, "utf8")).toBe(malformed);
|
|
await expect(readFile(`${malformedPath}.rea.backup`)).rejects.toMatchObject(
|
|
{
|
|
code: "ENOENT",
|
|
},
|
|
);
|
|
const doctorMalformed = await runMalformed([
|
|
"doctor",
|
|
"--client",
|
|
"pi",
|
|
"--json",
|
|
]);
|
|
expect(doctorMalformed.exitCode).not.toBe(0);
|
|
expect(doctorMalformed.json).toMatchObject({
|
|
healthy: false,
|
|
identity: {
|
|
registrations: [{ client: "pi", state: "invalid" }],
|
|
},
|
|
});
|
|
const removed = await runMalformed(["uninstall", "--json"]);
|
|
expect(removed.exitCode).not.toBe(0);
|
|
expect(removed.json).toMatchObject({
|
|
status: "failed",
|
|
items: expect.arrayContaining([
|
|
expect.objectContaining({ name: "pi", status: "failed" }),
|
|
]),
|
|
});
|
|
expect(await readFile(malformedPath, "utf8")).toBe(malformed);
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"malformed Pi overrides do not block selected Codex setup or doctor and never fall back for Pi",
|
|
async ({ cli }) => {
|
|
const home = await createTestTempDirectory("rea-pi-invalid-cli-");
|
|
const run = (arguments_: readonly string[]) =>
|
|
cli.run({
|
|
arguments: arguments_,
|
|
cwd: home,
|
|
environment: {
|
|
HOME: home,
|
|
USERPROFILE: home,
|
|
PI_CODING_AGENT_DIR: "file:///agent%2fdir",
|
|
},
|
|
timeoutMs: 20_000,
|
|
});
|
|
const plan = await run([
|
|
"setup",
|
|
"--client",
|
|
"codex",
|
|
"--dry-run",
|
|
"--json",
|
|
]);
|
|
expect(plan.exitCode).toBe(0);
|
|
expect(plan.json).toMatchObject({ status: "planned", appliedActions: [] });
|
|
expect(await readdir(home)).toEqual([]);
|
|
|
|
const rejected = await run(["setup", "--client", "pi", "--yes", "--json"]);
|
|
expect(rejected.exitCode).not.toBe(0);
|
|
expect(rejected.json).toMatchObject({
|
|
status: "needs_human",
|
|
plannedActions: [],
|
|
appliedActions: [],
|
|
remediation: expect.stringContaining("PI_CODING_AGENT_DIR"),
|
|
});
|
|
expect(await readdir(home)).toEqual([]);
|
|
|
|
const applied = await run([
|
|
"setup",
|
|
"--client",
|
|
"codex",
|
|
"--yes",
|
|
"--json",
|
|
]);
|
|
expect(applied.exitCode).toBe(0);
|
|
expect(applied.json).toMatchObject({
|
|
status: "ready",
|
|
clients: { codex: { status: "configured" } },
|
|
});
|
|
const doctor = await run(["doctor", "--client", "codex", "--json"]);
|
|
expect(doctor.exitCode).toBe(0);
|
|
expect(doctor.json).toMatchObject({
|
|
healthy: true,
|
|
identity: {
|
|
registrations: [
|
|
{ client: "codex", state: "aligned" },
|
|
{
|
|
client: "pi",
|
|
state: "invalid",
|
|
remediation: expect.stringContaining("PI_CODING_AGENT_DIR"),
|
|
},
|
|
],
|
|
},
|
|
});
|
|
const piDoctor = await run(["doctor", "--client", "pi", "--json"]);
|
|
expect(piDoctor.exitCode).not.toBe(0);
|
|
expect(piDoctor.json).toMatchObject({ healthy: false });
|
|
expect((await readdir(home)).sort()).toEqual([".agents", ".codex"]);
|
|
},
|
|
);
|