mirror of
https://github.com/morluto/rea.git
synced 2026-11-19 13:12:26 +00:00
832 lines
30 KiB
TypeScript
832 lines
30 KiB
TypeScript
import { registerMcpClientsOnHost } from "../../fixtures/mcpRegistration.js";
|
|
import { HOST_PLATFORM } from "../../../src/platform/HostPlatform.js";
|
|
import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { afterEach, beforeEach, expect, it, vi } from "vitest";
|
|
|
|
import { readEffectiveClientRegistrationConfiguration } from "../../../src/application/ClientConfigurationFiles.js";
|
|
import { currentClientRegistrationCommand } from "../../../src/application/ClientRegistrationIdentity.js";
|
|
import { readClientRegistrationStatuses } from "../../../src/application/ClientRegistrationStatus.js";
|
|
import { resolveMcpRegistrationClients } from "../../../src/application/McpRegistrationCatalog.js";
|
|
import {
|
|
resolveSupportedClients,
|
|
supportedClients,
|
|
} from "../../../src/application/SupportedClients.js";
|
|
import { detectClients } from "../../../src/application/SetupHost.js";
|
|
import {
|
|
clientRefreshRefusal,
|
|
configureClientConfiguration,
|
|
inspectClientConfiguration,
|
|
} from "../../../src/application/SetupClientConfiguration.js";
|
|
import {
|
|
runUninstall,
|
|
systemUninstallHost,
|
|
} from "../../../src/application/Uninstall.js";
|
|
import { existingMaintenanceScope } from "../../../src/application/UpdateMaintenance.js";
|
|
import { ArtifactResourceScope } from "../../../src/resources/ArtifactResourceScope.js";
|
|
import { PRODUCT_IDENTITY } from "../../../src/identity.js";
|
|
import { clearClientLocationEnvironment } from "../../fixtures/clientEnvironment.js";
|
|
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
|
|
|
const platform = process.platform;
|
|
const command = currentClientRegistrationCommand({ platform });
|
|
|
|
beforeEach(clearClientLocationEnvironment);
|
|
afterEach(() => vi.unstubAllEnvs());
|
|
|
|
const kiloRow = async (home: string, environment: NodeJS.ProcessEnv = {}) =>
|
|
(await resolveSupportedClients(home, platform, environment)).find(
|
|
({ name }) => name === "kilo",
|
|
);
|
|
|
|
/** The user-scope file `rea mcp add --agent kilo` selects from the same layers. */
|
|
const mcpAddTarget = async (home: string, environment: NodeJS.ProcessEnv) => {
|
|
const selected = await resolveMcpRegistrationClients(
|
|
{ agents: ["kilo"], global: true, cwd: home, home, platform, environment },
|
|
new ArtifactResourceScope(),
|
|
);
|
|
if (!selected.ok) throw selected.error;
|
|
return selected.value[0]?.configPath;
|
|
};
|
|
|
|
it("writes Kilo's kilo.json in its config root until another layer exists", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-default-");
|
|
const root = join(home, ".config", "kilo");
|
|
const synchronous = supportedClients(home, platform, {}).find(
|
|
({ name }) => name === "kilo",
|
|
);
|
|
expect(synchronous).toMatchObject({
|
|
configPath: join(root, "kilo.json"),
|
|
markerPath: root,
|
|
});
|
|
expect(synchronous?.configPaths).toContain(join(home, ".kilo", "kilo.jsonc"));
|
|
expect(await kiloRow(home)).toMatchObject({
|
|
configPath: join(root, "kilo.json"),
|
|
configPaths: [join(root, "kilo.json")],
|
|
});
|
|
});
|
|
|
|
it("selects the last present Kilo layer, as rea mcp add does", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-layers-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
await writeFile(join(root, "config.json"), "{}");
|
|
const legacy = join(home, ".kilocode");
|
|
await mkdir(legacy);
|
|
await writeFile(join(legacy, "kilo.jsonc"), "{}");
|
|
const row = await kiloRow(home);
|
|
expect(row).toMatchObject({
|
|
configPath: join(legacy, "kilo.jsonc"),
|
|
configPaths: [join(root, "config.json"), join(legacy, "kilo.jsonc")],
|
|
});
|
|
expect(await mcpAddTarget(home, {})).toBe(row?.configPath);
|
|
// Any folder Kilo reads is evidence that setup should offer it.
|
|
await rm(root, { recursive: true });
|
|
expect(
|
|
(await detectClients(home, platform, {})).map(({ name }) => name),
|
|
).toContain("kilo");
|
|
});
|
|
|
|
it("selects an existing file in a KILO_CONFIG_DIR spelled with a dot segment", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-config-dir-dot-");
|
|
const custom = join(home, "profiles", "kilo");
|
|
await mkdir(custom, { recursive: true });
|
|
await writeFile(join(custom, "kilo.jsonc"), "{}");
|
|
const environment = { KILO_CONFIG_DIR: `${home}/profiles/./kilo` };
|
|
const row = await kiloRow(home, environment);
|
|
expect(row?.configPath).toBe(join(custom, "kilo.jsonc"));
|
|
expect(row?.configPaths).toContain(row?.configPath);
|
|
expect(await mcpAddTarget(home, environment)).toBe(row?.configPath);
|
|
});
|
|
|
|
it("plans kilo.json in an empty KILO_CONFIG_DIR", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-config-dir-");
|
|
const custom = join(home, "custom-kilo");
|
|
const environment = { KILO_CONFIG_DIR: custom };
|
|
const row = await kiloRow(home, environment);
|
|
expect(row?.configPath).toBe(join(custom, "kilo.json"));
|
|
expect(await mcpAddTarget(home, environment)).toBe(row?.configPath);
|
|
});
|
|
|
|
it("loads KILO_CONFIG above Kilo's root files and below its home folders", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-config-file-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
await writeFile(join(root, "kilo.json"), "{}");
|
|
const explicit = join(home, "profiles", "kilo.json");
|
|
const environment = { KILO_CONFIG: explicit };
|
|
// A selected file that does not exist yet is still Kilo's last root layer.
|
|
const planned = await kiloRow(home, environment);
|
|
expect(planned).toMatchObject({
|
|
configPath: explicit,
|
|
configPaths: [join(root, "kilo.json"), explicit],
|
|
});
|
|
expect(await mcpAddTarget(home, environment)).toBe(explicit);
|
|
// A home folder layer loads after it and becomes the write target.
|
|
await mkdir(join(home, ".kilo"));
|
|
await writeFile(join(home, ".kilo", "kilo.jsonc"), "{}");
|
|
const layered = await kiloRow(home, environment);
|
|
expect(layered).toMatchObject({
|
|
configPath: join(home, ".kilo", "kilo.jsonc"),
|
|
configPaths: [
|
|
join(root, "kilo.json"),
|
|
explicit,
|
|
join(home, ".kilo", "kilo.jsonc"),
|
|
],
|
|
});
|
|
expect(await mcpAddTarget(home, environment)).toBe(layered?.configPath);
|
|
});
|
|
|
|
it("loads ~/.kilo after the legacy ~/.kilocode folder", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-home-folders-");
|
|
for (const folder of [".kilocode", ".kilo"]) {
|
|
await mkdir(join(home, folder));
|
|
await writeFile(join(home, folder, "kilo.json"), "{}");
|
|
}
|
|
const row = await kiloRow(home);
|
|
expect(row).toMatchObject({
|
|
configPath: join(home, ".kilo", "kilo.json"),
|
|
configPaths: [
|
|
join(home, ".kilocode", "kilo.json"),
|
|
join(home, ".kilo", "kilo.json"),
|
|
],
|
|
});
|
|
expect(await mcpAddTarget(home, {})).toBe(row?.configPath);
|
|
});
|
|
|
|
it("lets doctor and setup accept REA's entry that only KILO_CONFIG_CONTENT defines", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-inline-only-");
|
|
// Kilo is installed but none of its files exists yet.
|
|
await mkdir(join(home, ".config", "kilo"), { recursive: true });
|
|
const environment = {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { type: "local", command, enabled: true } },
|
|
}),
|
|
};
|
|
const statuses = await readClientRegistrationStatuses(home, command[1], {
|
|
platform,
|
|
environment,
|
|
});
|
|
expect(statuses.find(({ client }) => client === "kilo")).toMatchObject({
|
|
state: "aligned",
|
|
});
|
|
const row = await kiloRow(home, environment);
|
|
if (row === undefined) throw new Error("Kilo row is missing");
|
|
// Writing the same entry beneath it changes nothing Kilo loads, so setup
|
|
// may still record it in the file it manages.
|
|
expect(await inspectClientConfiguration(row, {}, command)).toMatchObject({
|
|
status: "create",
|
|
});
|
|
});
|
|
|
|
it("refuses a relative Kilo configuration path instead of guessing its folder", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-relative-");
|
|
for (const environment of [
|
|
{ KILO_CONFIG: "kilo.json" },
|
|
{ KILO_CONFIG_DIR: "kilo" },
|
|
{ XDG_CONFIG_HOME: "config" },
|
|
]) {
|
|
const row = supportedClients(home, platform, environment).find(
|
|
({ name }) => name === "kilo",
|
|
);
|
|
expect(row?.configPathError).toContain("is relative");
|
|
const resolved = await kiloRow(home, environment);
|
|
expect(resolved?.configPathError).toContain("is relative");
|
|
if (resolved === undefined) throw new Error("Kilo row is missing");
|
|
// Readers such as doctor's provider settings refuse it instead of reading
|
|
// a file relative to REA's own folder.
|
|
expect(
|
|
await readEffectiveClientRegistrationConfiguration(
|
|
resolved,
|
|
undefined,
|
|
HOST_PLATFORM.platform,
|
|
),
|
|
).toMatchObject({ ok: false, error: { kind: "unreadable" } });
|
|
}
|
|
});
|
|
|
|
it.each(["\\kilo.json", "/kilo.json"])(
|
|
"refuses a drive-less Windows KILO_CONFIG %s that follows Kilo's current drive",
|
|
(value) => {
|
|
const row = supportedClients("C:\\Users\\x", "win32", {
|
|
KILO_CONFIG: value,
|
|
}).find(({ name }) => name === "kilo");
|
|
expect(row?.configPathError).toContain("has no drive");
|
|
},
|
|
);
|
|
|
|
it("lets doctor and uninstall act on the Kilo layer rea mcp add wrote", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-lifecycle-");
|
|
const legacy = join(home, ".kilocode");
|
|
await mkdir(legacy);
|
|
const target = join(legacy, "kilo.jsonc");
|
|
await writeFile(target, "{}\n");
|
|
const resources = new ArtifactResourceScope();
|
|
const selected = await resolveMcpRegistrationClients(
|
|
{
|
|
agents: ["kilo"],
|
|
global: true,
|
|
cwd: home,
|
|
home,
|
|
platform,
|
|
environment: {},
|
|
},
|
|
resources,
|
|
);
|
|
if (!selected.ok) throw selected.error;
|
|
const [outcome] = await registerMcpClientsOnHost(
|
|
selected.value,
|
|
{ command: command[0] ?? "", args: command.slice(1) },
|
|
undefined,
|
|
resources,
|
|
);
|
|
expect(outcome).toMatchObject({ status: "completed" });
|
|
const statuses = await readClientRegistrationStatuses(home, command[1], {
|
|
platform,
|
|
environment: {},
|
|
});
|
|
expect(statuses.find(({ client }) => client === "kilo")).toMatchObject({
|
|
config_path: target,
|
|
state: "aligned",
|
|
});
|
|
const uninstall = await runUninstall(
|
|
false,
|
|
systemUninstallHost(home, undefined, {}, platform),
|
|
);
|
|
expect(uninstall.items).toContainEqual(
|
|
expect.objectContaining({ name: "kilo", status: "removed" }),
|
|
);
|
|
expect(await readFile(target, "utf8")).not.toContain('"rea"');
|
|
});
|
|
|
|
it("reads KILO_CONFIG_CONTENT as Kilo's top read-only layer", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-inline-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
const target = join(root, "kilo.json");
|
|
const registered = JSON.stringify({
|
|
mcp: { rea: { type: "local", command, enabled: true } },
|
|
});
|
|
await writeFile(target, registered);
|
|
const status = async (environment: NodeJS.ProcessEnv) =>
|
|
(
|
|
await readClientRegistrationStatuses(home, command[1], {
|
|
platform,
|
|
environment,
|
|
})
|
|
).find(({ client }) => client === "kilo");
|
|
// An inline layer that leaves REA alone keeps the file registration current.
|
|
const peer = {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({ mcp: { other: { command: ["x"] } } }),
|
|
};
|
|
expect(await status(peer)).toMatchObject({ state: "aligned" });
|
|
const row = await kiloRow(home, peer);
|
|
if (row === undefined) throw new Error("Kilo row is missing");
|
|
expect(await inspectClientConfiguration(row, {}, command)).toMatchObject({
|
|
status: "already_current",
|
|
});
|
|
const remediation = async (environment: NodeJS.ProcessEnv) => {
|
|
const overridden = await kiloRow(home, environment);
|
|
if (overridden === undefined) throw new Error("Kilo row is missing");
|
|
expect(overridden.configPath).toBe(target);
|
|
const inspection = await inspectClientConfiguration(
|
|
overridden,
|
|
{},
|
|
command,
|
|
);
|
|
if (inspection.status !== "invalid")
|
|
throw new Error(`Setup admitted the override: ${inspection.status}`);
|
|
return inspection.remediation;
|
|
};
|
|
// An inline launcher replaces the one setup wrote; its owner is unknown.
|
|
const launcher = {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { command: ["/opt/other/rea", "mcp"] } },
|
|
}),
|
|
};
|
|
// Doctor and setup name the layer the unowned launcher may come from.
|
|
const doctor = await status(launcher);
|
|
expect(doctor?.state).not.toBe("aligned");
|
|
expect(doctor?.remediation).toContain(", KILO_CONFIG_CONTENT has unknown");
|
|
expect(await remediation(launcher)).toContain(
|
|
"has unknown ownership and was not changed",
|
|
);
|
|
expect(await remediation(launcher)).toContain("KILO_CONFIG_CONTENT");
|
|
// An inline setting overrides the registration setup would write.
|
|
const disabled = {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({ mcp: { rea: { enabled: false } } }),
|
|
};
|
|
// Doctor's recovery names the layer setup cannot edit.
|
|
expect(await status(disabled)).toMatchObject({
|
|
state: "stale",
|
|
remediation: expect.stringContaining(
|
|
"KILO_CONFIG_CONTENT also sets the rea entry",
|
|
),
|
|
});
|
|
expect(await remediation(disabled)).toContain(
|
|
"KILO_CONFIG_CONTENT overrides REA's rea registration",
|
|
);
|
|
expect(await readFile(target, "utf8")).toBe(registered);
|
|
});
|
|
|
|
it("refuses a setup write that KILO_CONFIG_CONTENT would override", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-inline-write-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
const target = join(root, "kilo.json");
|
|
const environment = { HOPPER_LAUNCHER_PATH: "/opt/first/hopper" };
|
|
const registered = JSON.stringify({
|
|
mcp: { rea: { type: "local", command, enabled: true, environment } },
|
|
});
|
|
await writeFile(target, registered);
|
|
const row = await kiloRow(home, {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({ mcp: { rea: { environment } } }),
|
|
});
|
|
if (row === undefined) throw new Error("Kilo row is missing");
|
|
// Settings chosen after inspection, such as a newly installed Hopper,
|
|
// would be written beneath the inline value that Kilo keeps loading.
|
|
const result = await configureClientConfiguration(
|
|
row,
|
|
{ HOPPER_LAUNCHER_PATH: "/opt/second/hopper" },
|
|
command,
|
|
);
|
|
expect(result).toMatchObject({
|
|
status: "failed",
|
|
reason: "read_only_override",
|
|
});
|
|
expect(await readFile(target, "utf8")).toBe(registered);
|
|
});
|
|
|
|
it("refuses Kilo's location while KILO_CONFIG_CONTENT cannot be parsed", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-inline-malformed-");
|
|
const row = await kiloRow(home, { KILO_CONFIG_CONTENT: "{" });
|
|
expect(row?.configPathError).toContain(
|
|
"KILO_CONFIG_CONTENT cannot be admitted",
|
|
);
|
|
});
|
|
|
|
it("registers Kilo through its table row in rea mcp add", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-mcp-add-row-");
|
|
const resources = new ArtifactResourceScope();
|
|
const select = (environment: NodeJS.ProcessEnv) =>
|
|
resolveMcpRegistrationClients(
|
|
{
|
|
agents: ["kilo"],
|
|
global: true,
|
|
cwd: home,
|
|
home,
|
|
platform,
|
|
environment,
|
|
},
|
|
resources,
|
|
);
|
|
// A relative path is refused as setup refuses it, not resolved from cwd.
|
|
const relative = await select({ KILO_CONFIG: "kilo.json" });
|
|
expect(relative.ok).toBe(false);
|
|
if (!relative.ok) expect(relative.error.message).toContain("is relative");
|
|
// The row's inline layer still decides what Kilo loads.
|
|
const selected = await select({
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { command: ["/opt/other/rea", "mcp"] } },
|
|
}),
|
|
});
|
|
if (!selected.ok) throw selected.error;
|
|
expect(selected.value[0]?.inlineConfiguration?.origin).toBe(
|
|
"KILO_CONFIG_CONTENT",
|
|
);
|
|
const [outcome] = await registerMcpClientsOnHost(
|
|
selected.value,
|
|
{ command: command[0] ?? "", args: command.slice(1) },
|
|
undefined,
|
|
resources,
|
|
);
|
|
if (outcome?.status !== "completed") throw new Error("Kilo did not run");
|
|
if (outcome.result.ok) throw new Error("The inline launcher was ignored");
|
|
expect(outcome.result.error.message).toContain(
|
|
"higher-priority configuration overrides",
|
|
);
|
|
});
|
|
|
|
/** Uninstall's Kilo outcome, and every action detail it reported. */
|
|
const uninstallKilo = async (home: string, environment: NodeJS.ProcessEnv) => {
|
|
const result = await runUninstall(
|
|
false,
|
|
systemUninstallHost(home, undefined, environment, platform),
|
|
);
|
|
const kilo = result.items.find(({ name }) => name === "kilo");
|
|
return {
|
|
kilo,
|
|
details: [kilo?.detail, ...(kilo?.actions ?? []).map((a) => a.detail)].join(
|
|
"\n",
|
|
),
|
|
};
|
|
};
|
|
|
|
it("refuses to uninstall when removal would expose a lower Kilo layer's unowned entry", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-uninstall-lower-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
const lower = join(root, "kilo.json");
|
|
const unowned = JSON.stringify({
|
|
mcp: { rea: { type: "local", command: ["/opt/other/rea", "mcp"] } },
|
|
});
|
|
await writeFile(lower, unowned);
|
|
await mkdir(join(home, ".kilo"));
|
|
const upper = join(home, ".kilo", "kilo.json");
|
|
const owned = JSON.stringify({
|
|
mcp: { rea: { type: "local", command, enabled: true } },
|
|
});
|
|
await writeFile(upper, owned);
|
|
const { kilo, details } = await uninstallKilo(home, {});
|
|
expect(kilo?.status).toBe("failed");
|
|
expect(details).toContain("another Kilo configuration layer");
|
|
expect(await readFile(lower, "utf8")).toBe(unowned);
|
|
expect(await readFile(upper, "utf8")).toBe(owned);
|
|
});
|
|
|
|
it("refuses to uninstall while KILO_CONFIG_CONTENT keeps REA's entry in effect", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-uninstall-inline-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
const target = join(root, "kilo.json");
|
|
const owned = JSON.stringify({
|
|
mcp: { rea: { type: "local", command, enabled: true } },
|
|
});
|
|
await writeFile(target, owned);
|
|
const { kilo, details } = await uninstallKilo(home, {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { type: "local", command } },
|
|
}),
|
|
});
|
|
expect(kilo?.status).toBe("failed");
|
|
expect(details).toContain("KILO_CONFIG_CONTENT, which REA does not edit");
|
|
expect(await readFile(target, "utf8")).toBe(owned);
|
|
});
|
|
|
|
it("reports REA's Kilo entry that only KILO_CONFIG_CONTENT sets instead of calling uninstall complete", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-uninstall-inline-only-");
|
|
// Kilo is installed, and both files exist without REA's entry.
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
const other = JSON.stringify({ mcp: { other: { command: ["x"] } } });
|
|
await writeFile(join(root, "kilo.json"), other);
|
|
await mkdir(join(home, ".kilo"));
|
|
await writeFile(join(home, ".kilo", "kilo.json"), other);
|
|
const { kilo, details } = await uninstallKilo(home, {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { type: "local", command, enabled: true } },
|
|
}),
|
|
});
|
|
expect(kilo?.status).toBe("failed");
|
|
expect(details).toContain("Remove the rea entry from KILO_CONFIG_CONTENT");
|
|
// One report although uninstall visits each Kilo file.
|
|
expect(details.match(/KILO_CONFIG_CONTENT sets/g)).toHaveLength(1);
|
|
expect(await readFile(join(root, "kilo.json"), "utf8")).toBe(other);
|
|
});
|
|
|
|
it.each(["lower", "upper"])(
|
|
"keeps an inline Kilo registration disabled by its %s file during uninstall",
|
|
async (layer) => {
|
|
const home = await createTestTempDirectory("rea-kilo-uninstall-disabled-");
|
|
const lowerRoot = join(home, ".config", "kilo");
|
|
const upperRoot = join(home, ".kilo");
|
|
await mkdir(lowerRoot, { recursive: true });
|
|
await mkdir(upperRoot);
|
|
const lower = join(lowerRoot, "kilo.json");
|
|
const upper = join(upperRoot, "kilo.json");
|
|
const disabled = JSON.stringify({ mcp: { rea: { enabled: false } } });
|
|
const other = JSON.stringify({ mcp: { other: { command: ["x"] } } });
|
|
await writeFile(lower, layer === "lower" ? disabled : other);
|
|
await writeFile(upper, layer === "upper" ? disabled : other);
|
|
const environment = {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { type: "local", command } },
|
|
}),
|
|
};
|
|
const row = await kiloRow(home, environment);
|
|
if (row === undefined) throw new Error("Kilo row is missing");
|
|
const before = await readEffectiveClientRegistrationConfiguration(
|
|
row,
|
|
undefined,
|
|
platform,
|
|
);
|
|
expect(before).toMatchObject({
|
|
ok: true,
|
|
value: { document: { servers: { rea: { enabled: false } } } },
|
|
});
|
|
const { kilo } = await uninstallKilo(home, environment);
|
|
expect(kilo).toBeDefined();
|
|
expect(kilo?.status).not.toBe("failed");
|
|
const enabled = await uninstallKilo(home, {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { type: "local", command, enabled: true } },
|
|
}),
|
|
});
|
|
expect(enabled.kilo?.status).toBe("failed");
|
|
expect(await readFile(lower, "utf8")).toBe(
|
|
layer === "lower" ? disabled : other,
|
|
);
|
|
expect(await readFile(upper, "utf8")).toBe(
|
|
layer === "upper" ? disabled : other,
|
|
);
|
|
},
|
|
);
|
|
|
|
it("leaves a stale Kilo registration KILO_CONFIG_CONTENT pins out of update maintenance", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-update-inline-");
|
|
await mkdir(join(home, ".config", "kilo"), { recursive: true });
|
|
const environment = {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: {
|
|
rea: {
|
|
type: "local",
|
|
command: [
|
|
"npx",
|
|
"-y",
|
|
`${PRODUCT_IDENTITY.packageName}@3.2.0`,
|
|
"mcp",
|
|
],
|
|
enabled: true,
|
|
},
|
|
},
|
|
}),
|
|
};
|
|
const scope = await existingMaintenanceScope(
|
|
home,
|
|
command[1] ?? "",
|
|
environment,
|
|
{ platform: HOST_PLATFORM.platform },
|
|
);
|
|
expect(scope.clients).not.toContain("kilo");
|
|
expect(scope.unresolved).toEqual([
|
|
expect.objectContaining({
|
|
client: "kilo",
|
|
state: "stale",
|
|
remediation: expect.stringContaining(
|
|
"KILO_CONFIG_CONTENT overrides REA's rea registration",
|
|
),
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it("maintains a stale Kilo registration whose KILO_CONFIG_CONTENT entry setup's refresh keeps", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-update-inline-kept-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
await writeFile(
|
|
join(root, "kilo.json"),
|
|
JSON.stringify({
|
|
mcp: {
|
|
rea: {
|
|
type: "local",
|
|
command: [
|
|
"npx",
|
|
"-y",
|
|
`${PRODUCT_IDENTITY.packageName}@3.2.0`,
|
|
"mcp",
|
|
],
|
|
enabled: true,
|
|
},
|
|
},
|
|
}),
|
|
);
|
|
const scope = await existingMaintenanceScope(
|
|
home,
|
|
command[1] ?? "",
|
|
{
|
|
KILO_CONFIG_CONTENT: JSON.stringify({ mcp: { rea: { enabled: true } } }),
|
|
},
|
|
{ platform: HOST_PLATFORM.platform },
|
|
);
|
|
expect(scope.clients).toContain("kilo");
|
|
expect(scope.unresolved).toBeUndefined();
|
|
});
|
|
|
|
it("leaves an aligned Kilo registration out of update maintenance when KILO_CONFIG_CONTENT adds what setup would not write", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-update-inline-aligned-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
await writeFile(
|
|
join(root, "kilo.json"),
|
|
JSON.stringify({ mcp: { rea: { type: "local", command, enabled: true } } }),
|
|
);
|
|
const environment = {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { environment: { FOO: "bar" } } },
|
|
}),
|
|
};
|
|
const [status] = await readClientRegistrationStatuses(
|
|
home,
|
|
command[1] ?? "",
|
|
{
|
|
platform: HOST_PLATFORM.platform,
|
|
environment,
|
|
selectedClientIds: ["kilo"],
|
|
},
|
|
);
|
|
expect(status).toMatchObject({ client: "kilo", state: "aligned" });
|
|
const scope = await existingMaintenanceScope(
|
|
home,
|
|
command[1] ?? "",
|
|
environment,
|
|
{ platform: HOST_PLATFORM.platform },
|
|
);
|
|
expect(scope.clients).not.toContain("kilo");
|
|
expect(scope.unresolved).toEqual([
|
|
expect.objectContaining({
|
|
client: "kilo",
|
|
state: "aligned",
|
|
remediation: expect.stringContaining(
|
|
"KILO_CONFIG_CONTENT overrides REA's rea registration",
|
|
),
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it("reports a Kilo registration whose KILO_CONFIG_CONTENT differs only in a discovered provider path as needing setup", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-update-discovered-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
await writeFile(
|
|
join(root, "kilo.json"),
|
|
JSON.stringify({ mcp: { rea: { type: "local", command, enabled: true } } }),
|
|
);
|
|
const inline = (environment: Record<string, string>) =>
|
|
JSON.stringify({ mcp: { rea: { environment } } });
|
|
const hopper = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
|
|
const scope = await existingMaintenanceScope(
|
|
home,
|
|
command[1] ?? "",
|
|
{
|
|
KILO_CONFIG_CONTENT: inline({ HOPPER_LAUNCHER_PATH: hopper }),
|
|
},
|
|
{ platform: HOST_PLATFORM.platform },
|
|
);
|
|
// Setup may discover this launcher and write the same value, so update
|
|
// can neither maintain nor refuse the client: its alignment is unknown.
|
|
expect(scope.clients).not.toContain("kilo");
|
|
expect(scope.unresolved).toEqual([
|
|
expect.objectContaining({
|
|
client: "kilo",
|
|
state: "unknown",
|
|
remediation: expect.stringMatching(
|
|
/KILO_CONFIG_CONTENT sets HOPPER_LAUNCHER_PATH .*Run rea setup to check and refresh it\.$/,
|
|
),
|
|
}),
|
|
]);
|
|
|
|
// An explicit selection or another setting is a conflict update can prove.
|
|
for (const environment of [
|
|
{
|
|
HOPPER_LAUNCHER_PATH: "/opt/hopper",
|
|
KILO_CONFIG_CONTENT: inline({ HOPPER_LAUNCHER_PATH: hopper }),
|
|
},
|
|
{
|
|
KILO_CONFIG_CONTENT: inline({ HOPPER_LAUNCHER_PATH: hopper, FOO: "bar" }),
|
|
},
|
|
]) {
|
|
const refused = await existingMaintenanceScope(
|
|
home,
|
|
command[1] ?? "",
|
|
environment,
|
|
{ platform: HOST_PLATFORM.platform },
|
|
);
|
|
expect(refused.unresolved).toEqual([
|
|
expect.objectContaining({
|
|
client: "kilo",
|
|
state: "aligned",
|
|
remediation: expect.stringContaining(
|
|
"KILO_CONFIG_CONTENT overrides REA's rea registration",
|
|
),
|
|
}),
|
|
]);
|
|
}
|
|
});
|
|
|
|
it("reports a Kilo registration whose matching KILO_CONFIG_CONTENT sets a discovered provider path as needing setup", async () => {
|
|
const home = await createTestTempDirectory(
|
|
"rea-kilo-update-discovered-match-",
|
|
);
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
const hopper = "/opt/hopper/hopper";
|
|
await writeFile(
|
|
join(root, "kilo.json"),
|
|
JSON.stringify({
|
|
mcp: {
|
|
rea: {
|
|
type: "local",
|
|
command,
|
|
enabled: true,
|
|
environment: { HOPPER_LAUNCHER_PATH: hopper },
|
|
},
|
|
},
|
|
}),
|
|
);
|
|
const scope = await existingMaintenanceScope(
|
|
home,
|
|
command[1] ?? "",
|
|
{
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { environment: { HOPPER_LAUNCHER_PATH: hopper } } },
|
|
}),
|
|
},
|
|
{ platform: HOST_PLATFORM.platform },
|
|
);
|
|
// The entry matches today, but setup may discover another launcher that
|
|
// the inline layer would then override.
|
|
expect(scope.clients).not.toContain("kilo");
|
|
expect(scope.unresolved).toEqual([
|
|
expect.objectContaining({
|
|
client: "kilo",
|
|
state: "unknown",
|
|
remediation: expect.stringContaining(
|
|
"KILO_CONFIG_CONTENT sets HOPPER_LAUNCHER_PATH",
|
|
),
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it("leaves a Kilo file whose own launcher REA does not own out of update maintenance", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-update-foreign-file-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
await writeFile(
|
|
join(root, "kilo.json"),
|
|
JSON.stringify({
|
|
mcp: {
|
|
rea: { type: "local", command: ["/opt/other/server"], enabled: true },
|
|
},
|
|
}),
|
|
);
|
|
const scope = await existingMaintenanceScope(
|
|
home,
|
|
command[1] ?? "",
|
|
{
|
|
KILO_CONFIG_CONTENT: JSON.stringify({ mcp: { rea: { command } } }),
|
|
},
|
|
{ platform: HOST_PLATFORM.platform },
|
|
);
|
|
// The effective entry is REA's, but setup refuses to replace the file's
|
|
// foreign launcher, so maintenance must not select Kilo.
|
|
expect(scope.clients).not.toContain("kilo");
|
|
expect(scope.unresolved).toEqual([
|
|
expect.objectContaining({ client: "kilo" }),
|
|
]);
|
|
});
|
|
|
|
it("matches a discovered setting by Windows environment identity in KILO_CONFIG_CONTENT", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-update-discovered-win-");
|
|
const root = join(home, ".config", "kilo");
|
|
await mkdir(root, { recursive: true });
|
|
await writeFile(
|
|
join(root, "kilo.json"),
|
|
JSON.stringify({ mcp: { rea: { type: "local", command, enabled: true } } }),
|
|
);
|
|
const environment = {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { environment: { Java_Home: "/opt/java" } } },
|
|
}),
|
|
};
|
|
const kilo = await kiloRow(home, environment);
|
|
if (kilo === undefined) throw new Error("Kilo row missing");
|
|
// `Java_Home` is the JAVA_HOME setup discovers on Windows, and a distinct
|
|
// name elsewhere.
|
|
expect(
|
|
await clientRefreshRefusal(kilo, {}, command, {
|
|
platform: "win32",
|
|
currentCommandPath: command[1] ?? "",
|
|
}),
|
|
).toMatchObject({
|
|
alignment: "unknown",
|
|
remediation: expect.stringContaining("KILO_CONFIG_CONTENT sets JAVA_HOME"),
|
|
});
|
|
expect(
|
|
await clientRefreshRefusal(kilo, {}, command, {
|
|
platform: "linux",
|
|
currentCommandPath: command[1] ?? "",
|
|
}),
|
|
).toMatchObject({
|
|
alignment: "refused",
|
|
});
|
|
});
|
|
|
|
it("inspects REA's Kilo entry that only KILO_CONFIG_CONTENT sets when no Kilo folder exists", async () => {
|
|
const home = await createTestTempDirectory("rea-kilo-inline-evidence-");
|
|
const statuses = await readClientRegistrationStatuses(
|
|
home,
|
|
command[1] ?? "",
|
|
{
|
|
platform: HOST_PLATFORM.platform,
|
|
environment: {
|
|
KILO_CONFIG_CONTENT: JSON.stringify({
|
|
mcp: { rea: { type: "local", command, enabled: true } },
|
|
}),
|
|
},
|
|
},
|
|
);
|
|
expect(statuses).toContainEqual(
|
|
expect.objectContaining({ client: "kilo", state: "aligned" }),
|
|
);
|
|
});
|