morlutoandGitHub
53fe7d6d3b
* fix(platform): accept absolute paths for any host and stop blaming the ceiling for a missing grant Addresses #548 and #545. #548: processScenarioSchema required a leading "/" for executable, working_directory and filesystem_roots, so no process scenario could be expressed on Windows at all. The report suggested node:path's isAbsolute, but that answers for the host running the check: on Linux `C:\tools` is not absolute, so a scenario captured on Windows would fail validation when it is replayed, compared, or asserted in a test on another host. A boundary schema must not vary with its evaluator, so the check accepts the POSIX form, a Windows drive path and a UNC share everywhere. The rejection message now names the constraint instead of leaving the caller to infer it from "invalid request". The HTTP `path` field inside `checkpoints` is an URL path and is deliberately left alone. I checked whether this merely moved the failure downstream: containment is enforced by isPathWithinRoot, which already uses host-aware path.relative, so validation really was the only blocker. #545: when a scope is inside the administrator ceiling but no grant was ever issued, the denial still pointed at widening the ceiling -- advice that cannot help, since the ceiling already permits the operation. The `missing` payload is computed against candidate *grants*, so it describes what a grant must cover, not a ceiling gap. `PermissionRemediation` gains a `grant` variant saying exactly that, and PermissionAuthority selects it when the denial is not a ceiling violation. An explicitly requested remediation is still honoured, and a genuine ceiling violation still says "configure". * refactor(config): take the environment as an input at every configuration read Completes B-2. Every `parseConfig(process.env)` site now reads from an injected environment, so configuration-driven behaviour is a function of an argument rather than of the machine running it. The twelve sites were not equivalent, and treating them as one number would have hidden the difference: - **src/application/ (3 sites) were genuine defects.** `runSessionStatus` already injected its `logger` but hardcoded `process.env` for config, so the MCP path's `dependencies.env` never reached it; `captureProcessScenarioFile` and `runAnalysis` had the same problem. `runAnalysis` gained `environment` on the options object it already had, which is where its other injected dependencies live. - **The CLI command layer (9 sites) is a documented boundary,** where `process.env` is legitimate. Rather than 9 independent ambient reads, they now share one seam: `createCli(environment)` passes it to the seven registrars that need configuration, and the nested helpers (`electronContext`, `runtimeContext`, `loadConfiguredAuthority`, `inspectJavaScriptReplay`) take it explicitly. Every new parameter defaults to `process.env`, so all existing call sites are unchanged and production behaviour is identical. The point is that the ambient read is now a documented default at a boundary rather than a hidden dependency deep inside behaviour. `process.env` now survives in `src/` only as those default parameters — nothing reads it at the point of use. * style(cli): apply prettier formatting to the runtime observation command
39 lines
1.4 KiB
TypeScript
39 lines
1.4 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
|
|
import { createCli } from "./cli.js";
|
|
import { createSystemDoctorHost } from "./doctorRuntime.js";
|
|
import { captureProcessScenarioFile } from "./application/ProcessCli.js";
|
|
import { runCapabilityStatus } from "./application/DirectAnalysisStatus.js";
|
|
|
|
describe("the CLI takes its environment as an input", () => {
|
|
it("builds from an explicitly supplied environment", () => {
|
|
expect(createCli({ REA_LOG_LEVEL: "debug" })).toBeDefined();
|
|
expect(createCli({})).toBeDefined();
|
|
});
|
|
|
|
it("still builds with no environment supplied", () => {
|
|
// The default keeps production behaviour identical.
|
|
expect(createCli()).toBeDefined();
|
|
expect(createSystemDoctorHost()).toBeDefined();
|
|
});
|
|
|
|
it("builds a doctor host from an explicit environment", () => {
|
|
expect(createSystemDoctorHost({})).toBeDefined();
|
|
});
|
|
|
|
it("drives a process scenario failure from the supplied environment", async () => {
|
|
await expect(
|
|
captureProcessScenarioFile("/nonexistent/scenario.json", {}),
|
|
).resolves.toBeDefined();
|
|
});
|
|
|
|
it("reports session status from a supplied environment", async () => {
|
|
// An invalid configuration must surface through the caller's supplied
|
|
// environment rather than whatever the process happens to carry.
|
|
const result = await runCapabilityStatus(undefined, {
|
|
REA_LOG_LEVEL: "not-a-level",
|
|
});
|
|
expect(result).toMatchObject({ error: expect.anything() });
|
|
});
|
|
});
|