mirror of
https://github.com/morluto/rea.git
synced 2026-11-21 22:15:50 +00:00
* feat(config): persist provider settings in a user config file Providers currently rediscover install paths from scratch in every process, so a path set once (for example GHIDRA_INSTALL_DIR) silently reverts on the next run. Introduce ~/.config/rea/rea.json as the user-owned persistence layer and merge it into the environment snapshot before configuration parsing, keeping env > config file > auto-detect precedence on both the CLI and MCP entry points. Add a rea config command (list/get/set/unset) as the write surface, reporting the effective value and where it came from. * fix(config): address review findings on persistence safety and CLI surface - stage config writes beside the file and rename into place so an interrupted write cannot leave partial JSON (greptile #4, codex #11) - convert unreadable config files into configuration errors on the CLI seam instead of escaping raw filesystem errors (greptile #5, codex #15) - keep injected runtimes without a config root isolated from the host account's rea.json (codex #18) - surface the config file error on stderr when doctor falls back to the raw environment (greptile #3, codex #16) - route the config command through logCliCommand and return documents so --json stays parseable and failures exit non-zero (greptile #2, codex #10) - reject empty --set values, unknown --set/--unset/--get names, and --get combined with mutations (greptile #1/#7, codex #9/#12/#13/#17) - cover the new behavior in the boundary tests and stop leaking one temporary home per run (greptile #8) * fix(config): validate and back up persisted provider settings * fix(config): keep saved provider defaults out of client registrations * fix(config): preserve provider discovery and budgets for saved settings * fix(config): check only settings needed by the IDA deadline lookup * fix(config): share effective provider settings and verify config file reads * fix(doctor): share selected settings with Hopper and ILSpy probes * fix(config): resolve the destination of first-time saves * fix(doctor): preserve unresolved provider location inputs * fix(doctor): honor inherited IDA deadline overrides * fix(config): show empty environment overrides * fix(setup): preserve client-selected saved configuration roots --------- Co-authored-by: Jackzigen <zigenhan@gmail.com> Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
482 lines
16 KiB
TypeScript
482 lines
16 KiB
TypeScript
import { lstat, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
|
|
import { dirname, join } from "node:path";
|
|
import { expect } from "vitest";
|
|
|
|
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
|
import { cliTest } from "../../support/cli/cliFixture.js";
|
|
import { registrationEnvironment } from "../../support/cli/registrationEnvironment.js";
|
|
|
|
cliTest(
|
|
"reports persisted setting origins and keeps startup recovery actionable",
|
|
async ({ cli }) => {
|
|
const home = await createTestTempDirectory("rea-user-config-cli-");
|
|
const xdg = join(home, ".config");
|
|
const config = join(xdg, "rea", "rea.json");
|
|
const saved = join(home, "java-saved");
|
|
const override = join(home, "java-env");
|
|
const environment = {
|
|
HOME: home,
|
|
USERPROFILE: home,
|
|
XDG_CONFIG_HOME: xdg,
|
|
JAVA_HOME: undefined,
|
|
HOPPER_LAUNCHER_PATH: undefined,
|
|
};
|
|
const run = (
|
|
arguments_: readonly string[],
|
|
env = environment as NodeJS.ProcessEnv,
|
|
) =>
|
|
cli.run({
|
|
arguments: arguments_,
|
|
cwd: home,
|
|
environment: env,
|
|
freshProcess: true,
|
|
});
|
|
|
|
const set = await run(["config", "--set", `JAVA_HOME=${saved}`, "--json"]);
|
|
expect(set.exitCode, [set.stdout, set.stderr].join("\n")).toBe(0);
|
|
const get = ["config", "--get", "JAVA_HOME", "--json"];
|
|
expect((await run(get)).json).toMatchObject({
|
|
value: saved,
|
|
source: "config",
|
|
});
|
|
expect(
|
|
(await run(get, { ...environment, JAVA_HOME: override })).json,
|
|
).toMatchObject({
|
|
value: override,
|
|
source: "env",
|
|
});
|
|
|
|
const emptyOverride = { ...environment, JAVA_HOME: "" };
|
|
const effective = { value: "", source: "env" };
|
|
expect.soft((await run(get, emptyOverride)).json).toMatchObject(effective);
|
|
expect
|
|
.soft((await run(["config", "--json"], emptyOverride)).json)
|
|
.toMatchObject({ settings: { JAVA_HOME: effective } });
|
|
const invalidJava = await run(["mcp"], emptyOverride);
|
|
expect(invalidJava.exitCode).toBe(1);
|
|
expect(invalidJava.stderr).toContain("JAVA_HOME");
|
|
|
|
if (process.platform === "darwin" || process.platform === "linux") {
|
|
const hopper = await run([
|
|
"config",
|
|
"--get",
|
|
"HOPPER_LAUNCHER_PATH",
|
|
"--json",
|
|
]);
|
|
expect(hopper.json).toMatchObject({
|
|
source: "auto-detect",
|
|
value: expect.stringMatching(/[/]hopper$/iu),
|
|
});
|
|
}
|
|
await mkdir(dirname(config), { recursive: true });
|
|
await writeFile(config, "{ broken");
|
|
const version = await run(["--version", "--json"]);
|
|
expect(version.exitCode, version.stderr).toBe(0);
|
|
const doctor = await run(["doctor", "--json"]);
|
|
expect(doctor.exitCode).toBe(1);
|
|
expect(doctor.json).toMatchObject({
|
|
ok: false,
|
|
error: {
|
|
code: "CONFIGURATION_INVALID",
|
|
message: expect.stringContaining("must be valid JSON"),
|
|
},
|
|
});
|
|
const mcp = await run(["mcp"]);
|
|
expect(mcp.exitCode).toBe(1);
|
|
expect(mcp.stderr).toContain(config);
|
|
expect(mcp.stderr).toContain("must be valid JSON");
|
|
expect(await readFile(config, "utf8")).toBe("{ broken");
|
|
},
|
|
);
|
|
|
|
for (const purgeData of [false, true]) {
|
|
cliTest(
|
|
`uninstall with purge-data=${String(purgeData)} cleans owned resources when saved provider settings are malformed`,
|
|
async ({ cli }) => {
|
|
const home = await createTestTempDirectory(
|
|
"rea-uninstall-provider-config-",
|
|
);
|
|
const environment = await registrationEnvironment(home);
|
|
const config = join(environment.XDG_CONFIG_HOME!, "rea", "rea.json");
|
|
const registration = join(home, ".claude.json");
|
|
const cache = join(home, ".rea", "cache", "sentinel");
|
|
const malformed = "{ broken";
|
|
const cacheContents = "owned cache";
|
|
const peer = { command: "other-server" };
|
|
await mkdir(dirname(config), { recursive: true });
|
|
await mkdir(dirname(cache), { recursive: true });
|
|
await writeFile(config, malformed);
|
|
await writeFile(cache, cacheContents);
|
|
await writeFile(
|
|
registration,
|
|
JSON.stringify({
|
|
mcpServers: {
|
|
rea: { command: "npx", args: ["-y", "rea-agents@1.0.0", "mcp"] },
|
|
peer,
|
|
},
|
|
}),
|
|
);
|
|
const result = await cli.run({
|
|
arguments: [
|
|
"uninstall",
|
|
...(purgeData ? ["--purge-data"] : []),
|
|
"--json",
|
|
],
|
|
cwd: home,
|
|
environment,
|
|
freshProcess: true,
|
|
});
|
|
expect(result.exitCode, result.stdout).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
status: "complete",
|
|
items: expect.arrayContaining([
|
|
expect.objectContaining({ name: "claude_code", status: "removed" }),
|
|
]),
|
|
});
|
|
expect(JSON.parse(await readFile(registration, "utf8"))).toEqual({
|
|
mcpServers: { peer },
|
|
});
|
|
expect(await readFile(config, "utf8")).toBe(malformed);
|
|
if (purgeData)
|
|
await expect(lstat(cache)).rejects.toMatchObject({ code: "ENOENT" });
|
|
else expect(await readFile(cache, "utf8")).toBe(cacheContents);
|
|
},
|
|
);
|
|
}
|
|
|
|
cliTest(
|
|
"setup leaves shared defaults live and preserves client overrides",
|
|
async ({ cli }) => {
|
|
const home = await createTestTempDirectory("rea-user-config-setup-");
|
|
const config = join(home, ".cursor", "mcp.json");
|
|
const firstDefault = join(home, "first-ida.json");
|
|
const secondDefault = join(home, "second-ida.json");
|
|
const clientOverride = join(home, "cursor-ida.json");
|
|
const environment: NodeJS.ProcessEnv = {
|
|
HOME: home,
|
|
USERPROFILE: home,
|
|
XDG_CONFIG_HOME: join(home, "xdg"),
|
|
CURSOR_CONFIG_DIR: undefined,
|
|
REA_IDA_MCP_CONFIG: undefined,
|
|
};
|
|
const run = (arguments_: readonly string[], env = environment) =>
|
|
cli.run({
|
|
arguments: arguments_,
|
|
cwd: home,
|
|
environment: env,
|
|
freshProcess: true,
|
|
});
|
|
const save = async (path: string) => {
|
|
const result = await run([
|
|
"config",
|
|
"--set",
|
|
`REA_IDA_MCP_CONFIG=${path}`,
|
|
"--json",
|
|
]);
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
};
|
|
const setup = async (env = environment) => {
|
|
const result = await run(
|
|
["setup", "--client", "cursor", "--skill=false", "--yes", "--json"],
|
|
env,
|
|
);
|
|
expect(result.json, result.stderr).toMatchObject({ status: "ready" });
|
|
return JSON.parse(await readFile(config, "utf8"));
|
|
};
|
|
|
|
await save(firstDefault);
|
|
const initial = await setup();
|
|
expect(initial.mcpServers.rea.env ?? {}).not.toHaveProperty(
|
|
"REA_IDA_MCP_CONFIG",
|
|
);
|
|
|
|
await save(secondDefault);
|
|
expect(
|
|
(await run(["config", "--get", "REA_IDA_MCP_CONFIG", "--json"])).json,
|
|
).toMatchObject({ value: secondDefault, source: "config" });
|
|
expect((await setup()).mcpServers.rea.env ?? {}).not.toHaveProperty(
|
|
"REA_IDA_MCP_CONFIG",
|
|
);
|
|
|
|
expect(
|
|
(await setup({ ...environment, REA_IDA_MCP_CONFIG: clientOverride }))
|
|
.mcpServers.rea.env,
|
|
).toMatchObject({ REA_IDA_MCP_CONFIG: clientOverride });
|
|
expect((await setup()).mcpServers.rea.env).toMatchObject({
|
|
REA_IDA_MCP_CONFIG: clientOverride,
|
|
});
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"doctor resolves selected client settings from the same file as MCP startup",
|
|
async ({ cli, processes }) => {
|
|
const home = await createTestTempDirectory("rea-client-settings-origin-");
|
|
const terminalConfigHome = join(home, "terminal-config");
|
|
const clientConfigHome = join(home, "client-config");
|
|
const clientConfig = join(clientConfigHome, "rea", "rea.json");
|
|
const codexHome = join(home, ".codex");
|
|
const codexConfig = join(codexHome, "config.toml");
|
|
const terminalIda = join(home, "terminal-ida.json");
|
|
const clientIda = join(home, "client-ida.json");
|
|
const explicitIda = join(home, "explicit-ida.json");
|
|
const environment: NodeJS.ProcessEnv = {
|
|
HOME: home,
|
|
USERPROFILE: home,
|
|
CODEX_HOME: codexHome,
|
|
XDG_CONFIG_HOME: terminalConfigHome,
|
|
REA_IDA_MCP_CONFIG: undefined,
|
|
};
|
|
const save = async (configHome: string, providerConfig: string) => {
|
|
const path = join(configHome, "rea", "rea.json");
|
|
await mkdir(dirname(path), { recursive: true });
|
|
await writeFile(
|
|
path,
|
|
JSON.stringify({ REA_IDA_MCP_CONFIG: providerConfig }),
|
|
);
|
|
};
|
|
await save(terminalConfigHome, terminalIda);
|
|
await save(clientConfigHome, clientIda);
|
|
await mkdir(codexHome);
|
|
const cliPath = join(process.cwd(), "scripts", "rea.mjs");
|
|
const writeRegistration = (explicit?: string) =>
|
|
writeFile(
|
|
codexConfig,
|
|
[
|
|
"[mcp_servers.rea]",
|
|
`command = ${JSON.stringify(process.execPath)}`,
|
|
`args = ${JSON.stringify([cliPath, "mcp"])}`,
|
|
"startup_timeout_sec = 30",
|
|
"tool_timeout_sec = 450",
|
|
"[mcp_servers.rea.env]",
|
|
`XDG_CONFIG_HOME = ${JSON.stringify(clientConfigHome)}`,
|
|
...(explicit === undefined
|
|
? []
|
|
: [`REA_IDA_MCP_CONFIG = ${JSON.stringify(explicit)}`]),
|
|
].join("\n"),
|
|
);
|
|
const doctor = () =>
|
|
cli.run({
|
|
arguments: [
|
|
"doctor",
|
|
"--client",
|
|
"codex",
|
|
"--provider",
|
|
"ida",
|
|
"--skill=false",
|
|
"--json",
|
|
],
|
|
cwd: home,
|
|
environment,
|
|
freshProcess: true,
|
|
});
|
|
const expectInspection = async (
|
|
setting: string,
|
|
source: "config" | "env",
|
|
) => {
|
|
const result = await doctor();
|
|
expect(result.exitCode).toBe(1);
|
|
expect(result.json).toMatchObject({
|
|
providerInspections: expect.arrayContaining([
|
|
expect.objectContaining({
|
|
id: "ida",
|
|
configured: true,
|
|
checks: expect.arrayContaining([
|
|
expect.objectContaining({
|
|
code: "invalid_configuration",
|
|
detail: expect.stringContaining(setting),
|
|
}),
|
|
]),
|
|
providerSettings: {
|
|
REA_IDA_MCP_CONFIG: { value: setting, source },
|
|
},
|
|
}),
|
|
]),
|
|
});
|
|
};
|
|
|
|
await writeRegistration();
|
|
await expectInspection(clientIda, "config");
|
|
await writeFile(
|
|
clientIda,
|
|
JSON.stringify({ url: "http://127.0.0.1:12345/mcp", protocol: "native" }),
|
|
);
|
|
const setup = await cli.run({
|
|
arguments: [
|
|
"setup",
|
|
"--client",
|
|
"codex",
|
|
"--skill=false",
|
|
"--yes",
|
|
"--json",
|
|
],
|
|
cwd: home,
|
|
environment: { ...environment, XDG_CONFIG_HOME: undefined },
|
|
freshProcess: true,
|
|
});
|
|
expect(setup.json, setup.stderr).toMatchObject({ status: "ready" });
|
|
const configured = await readFile(codexConfig, "utf8");
|
|
expect(configured).toContain("XDG_CONFIG_HOME");
|
|
expect(configured).not.toContain("REA_IDA_MCP_CONFIG");
|
|
|
|
await writeRegistration(explicitIda);
|
|
await expectInspection(explicitIda, "env");
|
|
|
|
await writeFile(clientConfig, "{");
|
|
const invalid = await doctor();
|
|
expect(invalid.exitCode).toBe(1);
|
|
expect(invalid.json).toMatchObject({
|
|
providerInspections: expect.arrayContaining([
|
|
expect.objectContaining({
|
|
id: "ida",
|
|
checks: expect.arrayContaining([
|
|
expect.objectContaining({
|
|
code: "invalid_configuration",
|
|
detail: expect.stringContaining(clientConfig),
|
|
}),
|
|
]),
|
|
}),
|
|
]),
|
|
});
|
|
const launch = await processes.run(process.execPath, [cliPath, "mcp"], {
|
|
cwd: home,
|
|
env: { ...environment, XDG_CONFIG_HOME: clientConfigHome },
|
|
});
|
|
expect(launch.exitCode).toBe(1);
|
|
expect(launch.stderr).toContain(clientConfig);
|
|
},
|
|
);
|
|
|
|
cliTest.skipIf(process.platform === "win32")(
|
|
"refuses a saved configuration FIFO during reads and edits without waiting for a writer",
|
|
async ({ cli, processes }) => {
|
|
const home = await createTestTempDirectory("rea-user-config-fifo-");
|
|
const xdg = join(home, "xdg");
|
|
const config = join(xdg, "rea", "rea.json");
|
|
await mkdir(dirname(config), { recursive: true });
|
|
const created = await processes.run("mkfifo", [config], {
|
|
timeoutMs: 5_000,
|
|
});
|
|
expect(created.exitCode, created.stderr).toBe(0);
|
|
for (const arguments_ of [
|
|
["doctor", "--json"],
|
|
["mcp"],
|
|
["config", "--set", `JAVA_HOME=${join(home, "java")}`, "--json"],
|
|
]) {
|
|
const result = await cli.run({
|
|
arguments: arguments_,
|
|
cwd: home,
|
|
environment: { HOME: home, USERPROFILE: home, XDG_CONFIG_HOME: xdg },
|
|
freshProcess: true,
|
|
timeoutMs: 5_000,
|
|
});
|
|
expect(result.exitCode, JSON.stringify(arguments_)).toBe(1);
|
|
const diagnostic = [result.stdout, result.stderr].join("\n");
|
|
expect(diagnostic).toContain(config);
|
|
expect(diagnostic).toContain("regular JSON file");
|
|
}
|
|
expect((await lstat(config)).isFIFO()).toBe(true);
|
|
expect(await readdir(dirname(config))).toEqual(["rea.json"]);
|
|
},
|
|
);
|
|
|
|
// Linux verifies a launcher against authenticated publisher metadata. The macOS
|
|
// fixture can exercise selection with a local executable and no publisher access.
|
|
cliTest.runIf(process.platform === "darwin")(
|
|
"doctor uses the selected client file for Hopper and ILSpy probes",
|
|
async ({ cli }) => {
|
|
const home = await createTestTempDirectory("rea-static-provider-settings-");
|
|
const configHome = join(home, "client-config");
|
|
const savedConfig = join(configHome, "rea", "rea.json");
|
|
const codexHome = join(home, ".codex");
|
|
const codexConfig = join(codexHome, "config.toml");
|
|
const hopper = join(home, "selected-hopper");
|
|
const ilspy = join(home, "selected-ilspycmd");
|
|
await writeFile(hopper, "#!/bin/sh\nexit 0\n", { mode: 0o700 });
|
|
await writeFile(ilspy, "#!/bin/sh\nprintf 'ilspycmd: 9.1.0\\n'\n", {
|
|
mode: 0o700,
|
|
});
|
|
await mkdir(dirname(savedConfig), { recursive: true });
|
|
await mkdir(codexHome);
|
|
await writeFile(
|
|
savedConfig,
|
|
JSON.stringify({
|
|
HOPPER_LAUNCHER_PATH: hopper,
|
|
REA_ILSPY_CMD_PATH: ilspy,
|
|
}),
|
|
);
|
|
const cliPath = join(process.cwd(), "scripts", "rea.mjs");
|
|
await writeFile(
|
|
codexConfig,
|
|
[
|
|
"[mcp_servers.rea]",
|
|
`command = ${JSON.stringify(process.execPath)}`,
|
|
`args = ${JSON.stringify([cliPath, "mcp"])}`,
|
|
"startup_timeout_sec = 30",
|
|
"tool_timeout_sec = 450",
|
|
"[mcp_servers.rea.env]",
|
|
`XDG_CONFIG_HOME = ${JSON.stringify(configHome)}`,
|
|
].join("\n"),
|
|
);
|
|
const run = (...arguments_: string[]) =>
|
|
cli.run({
|
|
arguments: [
|
|
...arguments_,
|
|
"--client",
|
|
"codex",
|
|
"--skill=false",
|
|
"--json",
|
|
],
|
|
cwd: home,
|
|
environment: {
|
|
HOME: home,
|
|
USERPROFILE: home,
|
|
CODEX_HOME: codexHome,
|
|
XDG_CONFIG_HOME: undefined,
|
|
HOPPER_LAUNCHER_PATH: undefined,
|
|
REA_ILSPY_CMD_PATH: undefined,
|
|
},
|
|
freshProcess: true,
|
|
});
|
|
const report = await run("doctor");
|
|
expect(report.json).toMatchObject({
|
|
hopperPath: hopper,
|
|
staticProviderSettings: {
|
|
HOPPER_LAUNCHER_PATH: { value: hopper, source: "config" },
|
|
REA_ILSPY_CMD_PATH: { value: ilspy, source: "config" },
|
|
},
|
|
checks: expect.arrayContaining([
|
|
expect.objectContaining({ name: "hopper", ok: true, detail: hopper }),
|
|
expect.objectContaining({
|
|
name: "ilspycmd",
|
|
ok: true,
|
|
detail: expect.stringContaining(ilspy),
|
|
}),
|
|
]),
|
|
});
|
|
|
|
const setup = await run("setup", "--yes");
|
|
expect(setup.exitCode, setup.stdout).toBe(0);
|
|
const setupRegistration = await readFile(codexConfig, "utf8");
|
|
expect(setupRegistration).toContain("XDG_CONFIG_HOME");
|
|
expect(setupRegistration).not.toContain("HOPPER_LAUNCHER_PATH");
|
|
expect(setupRegistration).not.toContain("REA_ILSPY_CMD_PATH");
|
|
|
|
await writeFile(savedConfig, "{");
|
|
const invalid = await run("doctor");
|
|
expect(invalid.exitCode).toBe(1);
|
|
expect(invalid.json).not.toHaveProperty("hopperPath");
|
|
expect(invalid.json).toMatchObject({
|
|
checks: expect.arrayContaining(
|
|
["hopper", "ilspycmd"].map((name) =>
|
|
expect.objectContaining({
|
|
name,
|
|
ok: false,
|
|
detail: expect.stringContaining(savedConfig),
|
|
}),
|
|
),
|
|
),
|
|
});
|
|
},
|
|
);
|