mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 04:45:33 -08:00
467 lines
22 KiB
JavaScript
467 lines
22 KiB
JavaScript
// Web console tests, helper hops, concurrent writers, bad usage, foreign origins.
|
|
// Run with: node --test scripts/test-web-console-concurrency.mjs
|
|
//
|
|
// Shared setup (a per-process console home, the CLI runner, fixtures) lives in
|
|
// web-console-test-helpers.mjs; see the comment at its top.
|
|
|
|
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { execFileSync, spawn, spawnSync } from "node:child_process";
|
|
import http from "node:http";
|
|
import { meterView } from "../src/web-console/public/meter.js";
|
|
import { STATE_LOCK_FILE, lockStale } from "../src/web-console/files.mjs";
|
|
import { cwdHash, readLedger, repoRoots } from "../src/web-console/sessions.mjs";
|
|
import { validate } from "../src/web-console/patches.mjs";
|
|
import { WORKSPACE_FILE } from "../src/web-console/workspace.mjs";
|
|
import {
|
|
ROOT,
|
|
CONSOLE_CLI,
|
|
HOME,
|
|
ENV,
|
|
cookieFor,
|
|
cli,
|
|
payload,
|
|
BASE,
|
|
cliIn,
|
|
readState,
|
|
openSession,
|
|
sleep,
|
|
postPatch,
|
|
until,
|
|
EXPORT_A,
|
|
consoleSession,
|
|
tempFolder,
|
|
reportedHelper,
|
|
} from "./web-console-test-helpers.mjs";
|
|
|
|
test("helpers: a dashboard hop clears them, a same-workflow or paused resume keeps them, and the meter never moves", async () => {
|
|
const s = consoleSession(["--workflow", "implement"]);
|
|
try {
|
|
const meterBefore = (await s.get("/state")).meter;
|
|
assert.equal(postPatch(s, { helpers: [reportedHelper("h1"), reportedHelper("h2")] }).status, 0);
|
|
assert.deepEqual((await s.get("/state")).meter, meterBefore, "helper reports add nothing to the meter");
|
|
assert.equal(readLedger(s.session).some((e) => JSON.stringify(e).includes("h1")), false, "nothing about helpers reaches the ledger");
|
|
|
|
cli(["open", "--resume", s.sid, "--no-open"]);
|
|
assert.equal(readState(s.session).helpers.length, 2, "a resume with no --workflow keeps them");
|
|
cli(["open", "--resume", s.sid, "--no-open", "--workflow", "implement"]);
|
|
assert.equal(readState(s.session).helpers.length, 2, "a resume into the same workflow keeps them");
|
|
|
|
// A finish is refused while a helper still shows as running, so the pause settles them.
|
|
assert.equal(
|
|
postPatch(s, { helpers: [reportedHelper("h1", { state: "done" }), reportedHelper("h2", { state: "failed" })], finish: { headline: "Paused at Task 2" } }).status,
|
|
0
|
|
);
|
|
cli(["open", "--resume", s.sid, "--no-open"]);
|
|
const resumed = readState(s.session);
|
|
assert.equal("finish" in resumed, false, "the pause came down");
|
|
assert.equal(resumed.helpers.length, 2, "taking a pause down keeps them");
|
|
|
|
cli(["open", "--resume", s.sid, "--no-open", "--workflow", "dashboard"]);
|
|
assert.equal("helpers" in readState(s.session), false, "the hop to the dashboard drops them");
|
|
cli(["open", "--resume", s.sid, "--no-open", "--workflow", "implement"]);
|
|
assert.equal("helpers" in readState(s.session), false, "and the hop back brings none");
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("meter: a repeated run counts once, a bad one appends nothing, and neither reaches state.json", async () => {
|
|
const s = openSession();
|
|
try {
|
|
const points = () => meterView(readLedger(s.session)).points;
|
|
assert.equal(points(), 0, "a pathfinder launch scores only through its runs");
|
|
assert.equal(postPatch(s, { run: { event: "pathfinder-chart", id: "chart" } }).status, 0);
|
|
assert.equal(postPatch(s, { run: { event: "pathfinder-chart", id: "chart" }, agent: { status: "waiting" } }).status, 0);
|
|
assert.equal(points(), 2, "the same run posted twice counts once");
|
|
assert.ok(readLedger(s.session).some((e) => e.kind === "run" && e.id === "L1:chart" && e.workflow === "pathfinder"));
|
|
|
|
const before = readLedger(s.session).length;
|
|
const unknown = postPatch(s, { run: { event: "nap", id: "x" } }, { expectFail: true });
|
|
assert.equal(unknown.status, 3);
|
|
assert.match(unknown.stderr, /run: unknown event "nap"/);
|
|
const noId = postPatch(s, { run: { event: "plan" } }, { expectFail: true });
|
|
assert.equal(noId.status, 3);
|
|
assert.match(noId.stderr, /run: needs an id/);
|
|
const badTasks = postPatch(s, { run: { event: "implement-phase", id: "phase-1", tasks: 0 } }, { expectFail: true });
|
|
assert.equal(badTasks.status, 3);
|
|
assert.match(badTasks.stderr, /run: tasks must be a whole number/);
|
|
const strayTasks = postPatch(s, { run: { event: "plan", id: "p", tasks: 4 } }, { expectFail: true });
|
|
assert.equal(strayTasks.status, 3);
|
|
assert.match(strayTasks.stderr, /run: tasks only goes with/);
|
|
const badIssue = postPatch(s, { folderIssue: { name: "docs" } }, { expectFail: true });
|
|
assert.equal(badIssue.status, 3);
|
|
const bait = postPatch(s, { folderIssue: { name: "docs", reason: "TASK_COMPLETE" } }, { expectFail: true });
|
|
assert.equal(bait.status, 3);
|
|
const badState = postPatch(s, { run: { event: "plan", id: "p" }, items: [{ id: "q1", title: "grilling" }] }, { expectFail: true });
|
|
assert.equal(badState.status, 3, "a patch the state rejects appends nothing either");
|
|
assert.equal(readLedger(s.session).length, before, "rejected posts appended nothing");
|
|
|
|
assert.equal(postPatch(s, { run: { event: "implement-phase", id: "phase-1", tasks: 7 } }).status, 0);
|
|
assert.ok(readLedger(s.session).some((e) => e.id === "L1:phase-1" && e.tasks === 7), "tasks reach the ledger");
|
|
assert.equal(points(), 5, "a 7-task phase adds 3");
|
|
|
|
const state = readState(s.session);
|
|
assert.equal("run" in state, false);
|
|
assert.equal("folderIssue" in state, false);
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("meter: open --file takes run and folderIssue as post does, scoped to the new launch, never into state.json", () => {
|
|
const good = cli([
|
|
"open",
|
|
"--no-open",
|
|
"--workflow",
|
|
"pathfinder",
|
|
"--file",
|
|
payload("open-run.json", { run: { event: "pathfinder-chart", id: "chart" }, folderIssue: { name: "docs", reason: "denied" } }),
|
|
]);
|
|
try {
|
|
const ledger = readLedger(good.json.session);
|
|
assert.deepEqual(
|
|
ledger.map((e) => [e.kind, e.id]),
|
|
[["launch", "L1"], ["run", "L1:chart"], ["folder-issue", "L1:docs"]]
|
|
);
|
|
assert.equal(meterView(ledger).points, 2);
|
|
const state = readState(good.json.session);
|
|
assert.equal("run" in state, false);
|
|
assert.equal("folderIssue" in state, false);
|
|
} finally {
|
|
cli(["stop", "--session", good.json.sid, "--force"]);
|
|
}
|
|
const bad = cli(["open", "--no-open", "--file", payload("open-run-bad.json", { run: { event: "nap", id: "x" } })], { expectFail: true });
|
|
assert.equal(bad.status, 3);
|
|
assert.match(bad.stderr, /run: unknown event "nap"/);
|
|
});
|
|
|
|
test("meter: a folder issue shows in the frame's workspace.issues until the next launch", async () => {
|
|
const s = consoleSession(["--workflow", "pathfinder"]);
|
|
try {
|
|
assert.equal(postPatch(s, { folderIssue: { name: "docs", reason: "permission denied" } }).status, 0);
|
|
assert.equal(postPatch(s, { folderIssue: { name: "docs", reason: "still denied", hint: "run /add-dir" } }).status, 0);
|
|
const issue = [{ name: "docs", reason: "still denied", hint: "run /add-dir" }];
|
|
assert.deepEqual((await s.get("/workspace")).issues, issue, "the latest report per folder");
|
|
assert.deepEqual((await s.get("/state")).workspace.issues, issue);
|
|
|
|
cli(["open", "--resume", s.sid, "--no-open", "--workflow", "implement"]);
|
|
assert.deepEqual((await s.get("/workspace")).issues, [], "a new skill run starts clean");
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
/* ------------------------------------------- review fixes: two writers, one page */
|
|
|
|
// Browsers scope a cookie by host and ignore the port. With one shared name,
|
|
// the second session's link overwrote the first session's token, and the
|
|
// first tab got nothing but 403s from then on.
|
|
test("two sessions keep their own cookies: each server reads only the one named for its port", async () => {
|
|
const a = openSession();
|
|
const b = openSession();
|
|
try {
|
|
for (const s of [a, b]) {
|
|
const token = s.url.match(/\/s\/([^/]+)\//)[1];
|
|
const res = await fetch(s.url, { redirect: "manual" });
|
|
assert.ok(res.headers.get("set-cookie").startsWith(`${cookieFor(s.base, token)};`));
|
|
}
|
|
// What a browser holding both sends to either server.
|
|
const both = `${a.cookie}; ${b.cookie}`;
|
|
for (const s of [a, b]) {
|
|
assert.equal((await fetch(`${s.base}/state`, { headers: { cookie: both, connection: "close" } })).status, 200);
|
|
}
|
|
// The old shared name is no longer a key to anything.
|
|
const aToken = a.url.match(/\/s\/([^/]+)\//)[1];
|
|
const shared = await fetch(`${a.base}/state`, { headers: { cookie: `p2c_console=${aToken}`, connection: "close" } });
|
|
assert.equal(shared.status, 403);
|
|
// Another session's cookie opens nothing here either.
|
|
const crossed = b.cookie.replace(/^p2c_console_\d+/, `p2c_console_${new URL(a.base).port}`);
|
|
assert.equal((await fetch(`${a.base}/state`, { headers: { cookie: crossed, connection: "close" } })).status, 403);
|
|
} finally {
|
|
cli(["stop", "--session", a.sid, "--force"]);
|
|
cli(["stop", "--session", b.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// state.json has two writers, `post` and the server's /submit. Both are held
|
|
// at the lock here until each has read nothing yet, then let go together:
|
|
// whichever writes second must be building on the first one's write.
|
|
test("a post and a submit that overlap both survive: the state lock serializes them", async () => {
|
|
const s = openSession();
|
|
try {
|
|
const lock = path.join(s.session, STATE_LOCK_FILE);
|
|
fs.writeFileSync(lock, String(process.pid));
|
|
const patchFile = payload(`overlap-${Date.now()}.json`, {
|
|
items: [{ id: "q2", kind: "text", title: "Team name", required: false }],
|
|
agent: { status: "waiting", activity: "Asking about the team" },
|
|
});
|
|
const posting = new Promise((resolve) => {
|
|
const child = spawn(process.execPath, [CONSOLE_CLI, "post", "--session", s.sid, "--file", patchFile], { env: ENV, cwd: ROOT });
|
|
let err = "";
|
|
child.stderr.on("data", (c) => (err += c));
|
|
child.on("exit", (code) => resolve({ code, err }));
|
|
});
|
|
const submitting = s.send("/submit", EXPORT_A);
|
|
await sleep(400);
|
|
assert.ok(fs.existsSync(lock), "nobody broke a live, young lock");
|
|
fs.rmSync(lock);
|
|
const [posted, submitted] = await Promise.all([posting, submitting]);
|
|
assert.equal(posted.code, 0, posted.err);
|
|
assert.equal(submitted.status, 200);
|
|
|
|
const state = readState(s.session);
|
|
const q1 = state.items.find((i) => i.id === "q1");
|
|
assert.ok(state.items.some((i) => i.id === "q2"), "the post's new question is kept");
|
|
assert.equal(state.agent.activity, "Asking about the team");
|
|
assert.equal(q1.submitted && q1.submitted.k, "A", "the send's record is kept");
|
|
assert.equal(state.phase, "submitted");
|
|
assert.equal(fs.existsSync(lock), false, "and the lock is let go");
|
|
assert.equal(cli(["wait", "--session", s.sid, "--seconds", "5"]).status, 0);
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("a lock left by a writer that died is broken rather than waited on for good", () => {
|
|
const s = openSession();
|
|
try {
|
|
const lock = path.join(s.session, STATE_LOCK_FILE);
|
|
// A pid no process has: the holder is gone.
|
|
fs.writeFileSync(lock, "999999999");
|
|
const res = postPatch(s, { agent: { status: "working" } });
|
|
assert.equal(res.status, 0, res.stderr);
|
|
assert.equal(readState(s.session).agent.status, "working");
|
|
assert.equal(fs.existsSync(lock), false);
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// Age alone used to break a lock: a writer slowed past LOCK_STALE_MS by a busy
|
|
// machine lost its lock to the next writer, and both wrote. The holder's pid
|
|
// decides now; age only breaks a lock that names no live holder.
|
|
test("a lock whose holder is still running is kept past the stale age; age breaks only an unnamed one", async () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-lock-"));
|
|
const lock = path.join(dir, STATE_LOCK_FILE);
|
|
const holder = spawn(process.execPath, ["-e", "setTimeout(() => {}, 60000)"], { stdio: "ignore", windowsHide: true });
|
|
try {
|
|
await new Promise((r) => holder.once("spawn", r));
|
|
const old = new Date(Date.now() - 60000);
|
|
fs.writeFileSync(lock, String(holder.pid));
|
|
fs.utimesSync(lock, old, old);
|
|
assert.equal(lockStale(lock), false, "a live holder keeps its lock, however old");
|
|
|
|
holder.kill();
|
|
await new Promise((r) => (holder.exitCode !== null || holder.signalCode ? r() : holder.once("exit", r)));
|
|
assert.equal(lockStale(lock), true, "a gone holder frees it");
|
|
|
|
fs.writeFileSync(lock, "");
|
|
assert.equal(lockStale(lock), false, "an unnamed young lock is a holder mid-create");
|
|
fs.utimesSync(lock, old, old);
|
|
assert.equal(lockStale(lock), true, "an unnamed old lock is a crash left behind");
|
|
} finally {
|
|
holder.kill();
|
|
fs.rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
// A young handle and a live pid are what a server that died a minute ago
|
|
// leaves behind for any process to inherit. Only /health is proof.
|
|
test("stop never kills a live process that does not answer /health as ours", () => {
|
|
const bystander = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { stdio: "ignore" });
|
|
const sidForged = "20000101-000000-beef01";
|
|
// Under the test home, as the CLI sees it: this process has no override of
|
|
// its own, and files.mjs would name the real runtime dir.
|
|
const dir = path.join(HOME, "runtime", cwdHash(repoRoots(ROOT).project));
|
|
fs.mkdirSync(dir, { recursive: true });
|
|
const forged = path.join(dir, `${sidForged}.json`);
|
|
try {
|
|
fs.writeFileSync(
|
|
forged,
|
|
JSON.stringify({ v: 1, sid: sidForged, pid: bystander.pid, port: 1, url: "http://127.0.0.1:1/", startedAt: new Date().toISOString() })
|
|
);
|
|
const res = cli(["stop", "--session", sidForged, "--force"]);
|
|
assert.equal(res.json.stopped, 0);
|
|
assert.equal(res.json.skippedStaleHandles, 1);
|
|
assert.equal(fs.existsSync(forged), false, "the handle goes");
|
|
assert.doesNotThrow(() => process.kill(bystander.pid, 0), "the process stays");
|
|
} finally {
|
|
bystander.kill();
|
|
fs.rmSync(forged, { force: true });
|
|
}
|
|
});
|
|
|
|
// A fresh `open` starts the server before it writes the state. The server used
|
|
// to seed workspace.json at boot from the folder holding .git, which for a
|
|
// linked worktree is the main checkout.
|
|
test("open from a linked worktree seeds the workspace with the worktree, not the main checkout", () => {
|
|
const base = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-wt-"));
|
|
const repo = path.join(base, "repo");
|
|
const wt = path.join(base, "wt");
|
|
fs.mkdirSync(repo);
|
|
const git = (cwd, ...a) => execFileSync("git", a, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
|
|
git(repo, "init", "-q");
|
|
git(repo, "-c", "user.email=t@t", "-c", "user.name=t", "commit", "-q", "--allow-empty", "-m", "x");
|
|
git(repo, "worktree", "add", "-q", wt);
|
|
const { worktree, project } = repoRoots(wt);
|
|
assert.notEqual(worktree, project);
|
|
let sidOpened = null;
|
|
try {
|
|
const res = cliIn(wt, ["open", "--workflow", "plan", "--no-open"]);
|
|
sidOpened = res.json.sid;
|
|
const onDisk = JSON.parse(fs.readFileSync(path.join(res.json.session, WORKSPACE_FILE), "utf8"));
|
|
assert.deepEqual(onDisk.folders.map((f) => f.path), [worktree], "workspace.json names the worktree");
|
|
} finally {
|
|
if (sidOpened) cliIn(wt, ["stop", "--session", sidOpened, "--force"]);
|
|
// A stopped server can take a while to let go of its working directory on
|
|
// Windows, and longer while other test files load the machine: under a
|
|
// full-suite run this needed more than the 5s a 20x250ms retry gave it.
|
|
fs.rmSync(base, { recursive: true, force: true, maxRetries: 40, retryDelay: 250 });
|
|
}
|
|
});
|
|
|
|
/* ------------------------------------------- review fixes: the CLI's edges */
|
|
|
|
test("validate refuses a text pattern that does not compile, and post exits 3 on it", () => {
|
|
const item = (pattern) => ({ items: [{ id: "t1", kind: "text", title: "Ticket number", pattern }] });
|
|
assert.deepEqual(validate(item("^[A-Z]+-\\d+$")), []);
|
|
assert.match(validate(item("([")).join("\n"), /pattern: is not a valid JavaScript regular expression/);
|
|
assert.match(validate(item(7)).join("\n"), /pattern: must be a string/);
|
|
|
|
const s = openSession();
|
|
try {
|
|
const before = fs.readFileSync(path.join(s.session, "state.json"), "utf8");
|
|
const bad = postPatch(s, { items: [{ id: "t1", kind: "text", title: "Ticket number", pattern: "([", required: false }] }, { expectFail: true });
|
|
assert.equal(bad.status, 3);
|
|
assert.match(bad.stderr, /pattern/);
|
|
assert.equal(fs.readFileSync(path.join(s.session, "state.json"), "utf8"), before, "nothing was written");
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("a flag that needs a value and has none is bad usage, exit 2, never a crash", () => {
|
|
for (const argv of [
|
|
["open", "--resume"],
|
|
["open", "--session", "--no-open"],
|
|
["wait", "--session"],
|
|
["post", "--session", "20260101-000000-abcdef", "--file"],
|
|
["keep", "--session", "20260101-000000-abcdef", "--upload", "x", "--name", "--spec", "specs/x"],
|
|
["status", "--session"],
|
|
["stop", "--session"],
|
|
]) {
|
|
const res = cli(argv, { expectFail: true });
|
|
assert.equal(res.status, 2, argv.join(" "));
|
|
assert.match(res.stderr, /needs a value/, argv.join(" "));
|
|
assert.doesNotMatch(res.stderr, /TypeError|at .*\.mjs/, argv.join(" "));
|
|
}
|
|
});
|
|
|
|
test("wait reads --seconds 6s as six seconds, not as nothing", () => {
|
|
const s = openSession();
|
|
try {
|
|
const t0 = Date.now();
|
|
const res = cli(["wait", "--session", s.sid, "--seconds", "6s"]);
|
|
assert.equal(res.status, 10);
|
|
assert.ok(Date.now() - t0 >= 5000, "the slice ran its length");
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("only an installed console's open leaves the console-dir pointer; status, help, a bad command and a source checkout's open do not", () => {
|
|
const home = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-pointer-"));
|
|
const env = { PLAN2CODE_CONSOLE_HOME: home, PLAN2CODE_MODELS_DIR: path.join(home, "plan2code") };
|
|
const pointer = path.join(home, "console-dir");
|
|
fs.writeFileSync(path.join(home, "update-check.json"), JSON.stringify({ checkedAt: Date.now(), latest: null }));
|
|
try {
|
|
cli(["status"], { env });
|
|
cli(["help"], { env });
|
|
const usage = cli(["nope"], { env, expectFail: true });
|
|
assert.match(usage.stderr, /keep/, "the usage line names every command");
|
|
assert.equal(fs.existsSync(pointer), false);
|
|
// A source checkout never points every skill stub at itself.
|
|
const fromSource = cli(["open", "--no-open"], { env });
|
|
assert.equal(fs.existsSync(pointer), false, "a source checkout leaves no pointer");
|
|
cli(["stop", "--session", fromSource.json.sid, "--force"], { env });
|
|
// An installed console (a version folder) does.
|
|
const installed = path.join(home, "9.9.9");
|
|
fs.cpSync(path.join(ROOT, "src", "web-console"), installed, { recursive: true });
|
|
const res = spawnSync(process.execPath, [path.join(installed, "console.mjs"), "open", "--no-open"], { env: { ...ENV, ...env }, encoding: "utf8", cwd: ROOT });
|
|
assert.equal(res.status, 0, res.stderr);
|
|
assert.equal(fs.readFileSync(pointer, "utf8").trim(), installed);
|
|
const sid = JSON.parse(res.stdout.trim().split(/\r?\n/)[0]).sid;
|
|
spawnSync(process.execPath, [path.join(installed, "console.mjs"), "stop", "--session", sid, "--force"], { env: { ...ENV, ...env }, encoding: "utf8", cwd: ROOT });
|
|
} finally {
|
|
fs.rmSync(home, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
/* ------------------------------------------- review fixes: the Origin guard */
|
|
|
|
// Every route that changes something refuses a foreign Origin before it reads
|
|
// a byte of the body. /workspace/browse is the one that could open a native
|
|
// dialog; the echo stands in for it, so a guard that failed would answer 200
|
|
// here rather than put a picker on the screen.
|
|
test("every state-changing route refuses a foreign Origin, and nothing changes", async () => {
|
|
const picked = tempFolder();
|
|
const s = consoleSession(["--workflow", "plan", "--file", payload(`origin-${Date.now()}.json`, BASE)], {
|
|
env: { PLAN2CODE_PICKER_ECHO: picked },
|
|
});
|
|
const files = ["state.json", "result.json", "draft.json", WORKSPACE_FILE, "chat.ndjson"];
|
|
const snapshot = () =>
|
|
Object.fromEntries(
|
|
[...files.map((f) => path.join(s.session, f)), path.join(HOME, "looks.json")].map((f) => [
|
|
f,
|
|
fs.existsSync(f) ? fs.readFileSync(f, "utf8") : null,
|
|
])
|
|
);
|
|
const routes = [
|
|
["POST", "/submit", EXPORT_A],
|
|
["POST", "/cancel", {}],
|
|
["POST", "/chat", { text: "Why CSV?", conversation: 1 }],
|
|
["POST", "/chat/decision", { re: "r1", decision: "approve", conversation: 1 }],
|
|
["POST", "/draft", { staged: { q1: { k: "B" } } }],
|
|
["POST", "/looks", { looks: { theme: "light" } }],
|
|
["POST", "/models", { models: { devin: [{ id: "x" }] } }],
|
|
["POST", "/agents", { agents: [{ name: "X", command: "x" }] }],
|
|
["POST", "/agents/test", { command: "node" }],
|
|
["POST", "/workspace/add", { path: picked }],
|
|
["POST", "/workspace/edit", { id: "f0", name: "renamed" }],
|
|
["POST", "/workspace/remove", { id: "f0" }],
|
|
["POST", "/workspace/browse", {}],
|
|
["POST", "/bye", {}],
|
|
["POST", "/upload", null],
|
|
["DELETE", "/uploads/00000000-0000-0000-0000-000000000000.jpg", null],
|
|
];
|
|
try {
|
|
await s.get("/workspace");
|
|
const before = snapshot();
|
|
for (const [method, route, body] of routes) {
|
|
const res = await fetch(`${s.base}${route}`, {
|
|
method,
|
|
headers: { "content-type": "application/json", cookie: s.cookie, origin: "http://evil.example.com", connection: "close" },
|
|
body: body === null ? undefined : JSON.stringify(body),
|
|
});
|
|
assert.equal(res.status, 403, `${method} ${route}`);
|
|
}
|
|
assert.deepEqual(snapshot(), before, "no file moved");
|
|
// And the same requests from the page's own origin do get through, so the
|
|
// 403s above are the guard and not something else.
|
|
const own = await fetch(`${s.base}/workspace/browse`, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie: s.cookie, origin: s.base, connection: "close" },
|
|
body: "{}",
|
|
});
|
|
assert.equal(own.status, 200);
|
|
assert.deepEqual(await own.json(), { path: picked });
|
|
} finally {
|
|
cli(["stop", "--session", s.sid, "--force"]);
|
|
fs.rmSync(picked, { recursive: true, force: true });
|
|
}
|
|
});
|