mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 04:45:33 -08:00
229 lines
11 KiB
JavaScript
229 lines
11 KiB
JavaScript
// Web console tests: hardening fixes (cookies per port, handle files, tokens
|
|
// that look like flags, failed writes, bad CLI input). Each test opens its own
|
|
// session. Shared setup: ./web-console-test-helpers.mjs.
|
|
|
|
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import { spawn, spawnSync } from "node:child_process";
|
|
import { parseArgs } from "../src/web-console/files.mjs";
|
|
import { BASE, cli, consoleSession, cookieFor, ENV, HOME, payload, ROOT } from "./web-console-test-helpers.mjs";
|
|
|
|
const SERVER_JS = path.join(ROOT, "src", "web-console", "server.mjs");
|
|
|
|
test("another console's cookie beside ours does not lock this one out", async () => {
|
|
const s = consoleSession(["--file", payload("cookie-pair.json", BASE)]);
|
|
try {
|
|
const token = s.opened.url.match(/\/s\/([^/]+)\//)[1];
|
|
const port = Number(new URL(s.base).port);
|
|
const other = `p2c_console_${port + 1}=someone-else`;
|
|
const both = await fetch(s.base + "/state", { headers: { cookie: `${other}; ${cookieFor(s.base, token)}` } });
|
|
assert.equal(both.status, 200);
|
|
await both.arrayBuffer();
|
|
const theirsOnly = await fetch(s.base + "/state", { headers: { cookie: other } });
|
|
assert.equal(theirsOnly.status, 403);
|
|
await theirsOnly.arrayBuffer();
|
|
// The old shared name is no longer honored.
|
|
const legacy = await fetch(s.base + "/state", { headers: { cookie: `p2c_console=${token}` } });
|
|
assert.equal(legacy.status, 403);
|
|
await legacy.arrayBuffer();
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("a server removes its own handle file when it exits, and only its own", async () => {
|
|
const project = fs.mkdtempSync(path.join(HOME, "handle-exit-"));
|
|
const dir = fs.mkdtempSync(path.join(HOME, "handle-exit-session-"));
|
|
fs.writeFileSync(path.join(dir, "state.json"), JSON.stringify({ sid: path.basename(dir), phase: "collecting" }));
|
|
const handleDir = path.join(HOME, "runtime");
|
|
// A clean exit on request, the same on every platform: kill() on Windows is
|
|
// TerminateProcess, which runs no exit hook at all. The preload stands in
|
|
// for the idle deadline, whose process.exit() is what this hook is for.
|
|
const preload = path.join(HOME, "exit-on-message.cjs");
|
|
fs.writeFileSync(preload, 'process.on("message", (m) => { if (m === "exit") process.exit(0); });\n');
|
|
const start = () =>
|
|
new Promise((resolve, reject) => {
|
|
const child = spawn(process.execPath, ["-r", preload, SERVER_JS, `--session=${dir}`, "--token=t", `--project=${project}`], {
|
|
env: ENV,
|
|
stdio: ["ignore", "pipe", "ignore", "ipc"],
|
|
windowsHide: true,
|
|
});
|
|
let buf = "";
|
|
child.stdout.on("data", (c) => {
|
|
buf += c;
|
|
if (buf.includes('"ready"')) resolve(child);
|
|
});
|
|
child.on("exit", () => reject(new Error("server exited before it was ready")));
|
|
});
|
|
const handleOf = () => {
|
|
for (const bucket of fs.readdirSync(handleDir)) {
|
|
const file = path.join(handleDir, bucket, path.basename(dir) + ".json");
|
|
if (fs.existsSync(file)) return file;
|
|
}
|
|
return null;
|
|
};
|
|
const stopped = (child) => new Promise((r) => (child.exitCode !== null ? r() : child.once("exit", r)));
|
|
|
|
const first = await start();
|
|
const file = handleOf();
|
|
assert.ok(file, "the server wrote its handle");
|
|
first.send("exit");
|
|
await stopped(first);
|
|
assert.equal(fs.existsSync(file), false, "an exit takes the handle with it");
|
|
|
|
// A handle rewritten by a replacement server is left alone.
|
|
const second = await start();
|
|
const mine = JSON.parse(fs.readFileSync(file, "utf8"));
|
|
fs.writeFileSync(file, JSON.stringify({ ...mine, pid: process.pid }));
|
|
second.send("exit");
|
|
await stopped(second);
|
|
assert.equal(fs.existsSync(file), true, "another process's handle survives this one's exit");
|
|
fs.rmSync(file, { force: true });
|
|
});
|
|
|
|
// newToken() is base64url, so one token in 32 or so starts with "-", and
|
|
// some with "--". Passed as two words, parseArgs read it as the next flag.
|
|
test("a token that starts with -- survives the trip to the server", async () => {
|
|
assert.equal(parseArgs(["--token", "--abc"]).token, true, "the two-word form is the hazard");
|
|
const parsed = parseArgs(["--session=/s", "--token=--abc=d", "--project=/p", "--handoff"]);
|
|
assert.deepEqual([parsed.session, parsed.token, parsed.project, parsed.handoff], ["/s", "--abc=d", "/p", true]);
|
|
|
|
const dir = fs.mkdtempSync(path.join(HOME, "dash-token-"));
|
|
fs.writeFileSync(path.join(dir, "state.json"), JSON.stringify({ sid: path.basename(dir), phase: "collecting" }));
|
|
|
|
// A server that ends up with no string token refuses to start at all.
|
|
for (const tokenArgs of [[], ["--token", "--dashy"], ["--token="]]) {
|
|
const res = spawnSync(process.execPath, [SERVER_JS, `--session=${dir}`, ...tokenArgs, `--project=${dir}`], {
|
|
env: ENV,
|
|
encoding: "utf8",
|
|
timeout: 10000,
|
|
windowsHide: true,
|
|
});
|
|
assert.equal(res.status, 2, `refused: ${JSON.stringify(tokenArgs)}`);
|
|
assert.match(res.stderr, /--token=<token> is required/);
|
|
}
|
|
|
|
const child = spawn(process.execPath, [SERVER_JS, `--session=${dir}`, "--token=--dashy", `--project=${dir}`], {
|
|
env: ENV,
|
|
stdio: ["ignore", "pipe", "ignore"],
|
|
windowsHide: true,
|
|
});
|
|
try {
|
|
const ready = await new Promise((resolve, reject) => {
|
|
let buf = "";
|
|
child.stdout.on("data", (c) => {
|
|
buf += c;
|
|
const line = buf.split("\n").find((l) => l.includes('"ready"'));
|
|
if (line) resolve(JSON.parse(line));
|
|
});
|
|
child.on("exit", () => reject(new Error("server exited before it was ready")));
|
|
});
|
|
assert.ok(ready.url.endsWith("/s/--dashy/"));
|
|
const res = await fetch(ready.url, { redirect: "manual" });
|
|
assert.equal(res.status, 302);
|
|
assert.ok(res.headers.get("set-cookie").startsWith(`p2c_console_${ready.port}=--dashy;`));
|
|
} finally {
|
|
child.kill();
|
|
}
|
|
});
|
|
|
|
test("a cancel that could not be written answers 500 and tells nobody", async () => {
|
|
const s = consoleSession(["--file", payload("cancel-500.json", BASE)]);
|
|
try {
|
|
// A folder where the server's temp file goes, so the atomic write cannot
|
|
// even start. (A folder at result.json itself reads as a pending result.)
|
|
const blocker = path.join(s.session, `result.json.${s.opened.pid}.tmp`);
|
|
fs.mkdirSync(blocker);
|
|
fs.writeFileSync(path.join(blocker, "x"), "");
|
|
const res = await s.send("/cancel", {});
|
|
assert.equal(res.status, 500);
|
|
await res.arrayBuffer();
|
|
const events = fs.readFileSync(path.join(s.session, "events.ndjson"), "utf8");
|
|
assert.doesNotMatch(events, /"type":"cancel"/, "no cancel event for a cancel that never landed");
|
|
fs.rmSync(blocker, { recursive: true, force: true });
|
|
assert.equal((await s.send("/cancel", {})).status, 200, "and once it can land, it does");
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("wait refuses a --seconds that is not a number instead of spinning", () => {
|
|
const s = consoleSession(["--file", payload("wait-seconds.json", BASE)]);
|
|
try {
|
|
for (const bad of ["abc", "NaN", ""]) {
|
|
const res = cli(["wait", "--session", s.sid, `--seconds=${bad}`], { expectFail: true });
|
|
assert.equal(res.status, 2, `--seconds=${bad}`);
|
|
assert.match(res.stderr, /--seconds must be a number/);
|
|
}
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("a fresh open whose --file is refused leaves no session folder behind", () => {
|
|
const sessionsDir = path.join(HOME, "sessions");
|
|
fs.mkdirSync(sessionsDir, { recursive: true });
|
|
const before = new Set(fs.readdirSync(sessionsDir));
|
|
const unreadable = path.join(HOME, "not-json.json");
|
|
fs.writeFileSync(unreadable, "{ nope");
|
|
const tooMany = { items: [1, 2, 3, 4].map((n) => ({ id: "x" + n, kind: "text", title: "Question " + n, body: "b" })) };
|
|
const cases = [
|
|
[["--file", unreadable], 2],
|
|
[["--file", path.join(HOME, "no-such-file.json")], 2],
|
|
[["--file", payload("open-too-many.json", tooMany)], 3],
|
|
[["--file", payload("open-bad-run.json", { run: { event: "nap", id: "x" } })], 3],
|
|
];
|
|
for (const [extra, code] of cases) {
|
|
const res = cli(["open", "--no-open", ...extra], { expectFail: true });
|
|
assert.equal(res.status, code, extra.join(" "));
|
|
}
|
|
const after = fs.readdirSync(sessionsDir).filter((n) => !before.has(n));
|
|
assert.deepEqual(after, [], "no orphan session folders");
|
|
});
|
|
|
|
// Show me it working: an image block may only point at a picture the agent
|
|
// saved directly inside the session's shots/ folder, and only a real one.
|
|
test("an image block outside the session's shots folder, or not an image, is refused", () => {
|
|
const s = consoleSession(["--file", payload("shots-safety.json", BASE)]);
|
|
try {
|
|
const shots = path.join(s.session, "shots");
|
|
fs.mkdirSync(shots, { recursive: true });
|
|
const png = Buffer.concat([Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]), Buffer.alloc(32)]);
|
|
const outside = path.join(HOME, "outside-shot.png");
|
|
fs.writeFileSync(outside, png);
|
|
fs.writeFileSync(path.join(s.session, "beside.png"), png);
|
|
fs.writeFileSync(path.join(shots, "renamed.png"), "just some text, not a picture\n");
|
|
fs.writeFileSync(path.join(shots, "huge.png"), Buffer.concat([png, Buffer.alloc(6 * 1024 * 1024)]));
|
|
const cases = [
|
|
["../../outside-shot.png", /outside the session's shots\/ folder/],
|
|
[outside, /outside the session's shots\/ folder/],
|
|
["beside.png", /outside the session's shots\/ folder/],
|
|
["shots/missing.png", /does not exist/],
|
|
["shots/renamed.png", /not a PNG image/],
|
|
["shots/huge.png", /larger than 5 MB/],
|
|
];
|
|
let linked = false;
|
|
try {
|
|
fs.symlinkSync(outside, path.join(shots, "link.png"), "file");
|
|
linked = true;
|
|
} catch {
|
|
// Windows without the symlink privilege: the realpath check is still covered by the cases above.
|
|
}
|
|
if (linked) cases.push(["shots/link.png", /outside the session's shots\/ folder/]);
|
|
for (const [image, why] of cases) {
|
|
const patch = { docs: [{ id: "shown", title: "Shown", blocks: [{ id: "b1", image, alt: "The page" }] }] };
|
|
const res = cli(["post", "--session", s.sid, "--file", payload("shots-bad.json", patch)], { expectFail: true });
|
|
assert.equal(res.status, 3, image);
|
|
assert.match(res.stderr, why, image);
|
|
}
|
|
const both = { docs: [{ id: "shown", title: "Shown", blocks: [{ id: "b1", image: "shots/renamed.png", md: "x" }] }] };
|
|
const res = cli(["post", "--session", s.sid, "--file", payload("shots-both.json", both)], { expectFail: true });
|
|
assert.equal(res.status, 3);
|
|
assert.match(res.stderr, /cannot also carry "md" or "file"/);
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|