mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 04:45:33 -08:00
1659 lines
83 KiB
JavaScript
1659 lines
83 KiB
JavaScript
// Web console tests, independent sessions: first paint, streams, hand-off, cleanup, overview.
|
|
// Run with: node --test scripts/test-web-console-server.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 } from "node:child_process";
|
|
import http from "node:http";
|
|
import {
|
|
ACCENTS,
|
|
CARD_WIDTHS,
|
|
cardWidth,
|
|
DEFAULT_ACCENT,
|
|
DEFAULT_CARD_WIDTH,
|
|
} from "../src/web-console/public/palette.js";
|
|
import { activityLabel, BUILD_WORKFLOWS, taskLabel, workingLine } from "../src/web-console/public/labels.js";
|
|
import {
|
|
bindLoopback,
|
|
cleanupFindings,
|
|
handOff,
|
|
PROTECTED_CONSOLE_FILES,
|
|
readOverview,
|
|
readSpecFile,
|
|
removeCleanup,
|
|
removeScratch,
|
|
removeSessions,
|
|
repoRoots,
|
|
SESSION_MAX_AGE_MS,
|
|
staleScratch,
|
|
STRAY_GRACE_MS,
|
|
staleSessions,
|
|
terminalLine,
|
|
} from "../src/web-console/sessions.mjs";
|
|
import { validate } from "../src/web-console/patches.mjs";
|
|
// Scrubs this process's git config, so the Cleanup fixtures and git-repo.mjs agree.
|
|
import { gitInit } from "./skill-script-helpers.mjs";
|
|
import { joinedCss } from "./css-helpers.mjs";
|
|
import {
|
|
ROOT,
|
|
HANDOFFS_DIR,
|
|
HOME,
|
|
ENV,
|
|
MODELS_DIR,
|
|
cookieFor,
|
|
cli,
|
|
payload,
|
|
BASE,
|
|
backdate,
|
|
cliIn,
|
|
sessionUrl,
|
|
readState,
|
|
sleep,
|
|
until,
|
|
} from "./web-console-test-helpers.mjs";
|
|
|
|
// Every page load used to fetch /state, then /looks, then open the stream,
|
|
// before drawing anything real. The first state now rides in the page.
|
|
test("the page carries its first state, title and badge, so the first paint needs no fetch", async () => {
|
|
const hostile = "Lunch </script><script>alert(1)</script> $& $' app";
|
|
const res = cli(["open", "--workflow", "implement", "--title", hostile, "--no-open"]);
|
|
const m = res.json.url.match(/^(http:\/\/127\.0\.0\.1:\d+)\/s\/([^/]+)\//);
|
|
const html = await (await fetch(m[1] + "/", { headers: { cookie: cookieFor(m[1], m[2]) } })).text();
|
|
|
|
const block = html.match(/<script type="application\/json" id="boot">([\s\S]*?)<\/script>/);
|
|
assert.ok(block, "the boot block is in the page");
|
|
const boot = JSON.parse(block[1]);
|
|
assert.equal(boot.state.sid, res.json.sid);
|
|
assert.equal(boot.state.title, hostile, "the title survives the round trip exactly");
|
|
assert.equal(typeof boot.rev, "number");
|
|
assert.ok(boot.have, "the page gets the key it hands back to /events");
|
|
assert.ok("draft" in boot && "looks" in boot);
|
|
|
|
// Agent-written text cannot close the data block or start a script: every
|
|
// `<` inside it is escaped, so the only </script> is the block's own.
|
|
assert.equal(block[1].includes("<"), false);
|
|
assert.equal((html.match(/<script\b/g) || []).length, 2, "the boot block and app.js, nothing else");
|
|
// Written into the markup, escaped, with `$&` and `$'` left as typed.
|
|
assert.ok(html.includes(`<h1 id="title">Lunch </script><script>alert(1)</script> $& $' app</h1>`));
|
|
assert.ok(html.includes('<span class="badge" id="badge">Building</span>'));
|
|
assert.ok(html.includes("Starting Implement"), "the static starting screen names the skill");
|
|
assert.ok(html.includes('rel="modulepreload" href="/app.js"'));
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
});
|
|
|
|
test("open without --title names the session after the project folder", () => {
|
|
const res = cli(["open", "--workflow", "pathfinder", "--no-open"]);
|
|
const state = JSON.parse(fs.readFileSync(path.join(res.json.session, "state.json"), "utf8"));
|
|
assert.equal(state.title, path.basename(ROOT));
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
});
|
|
|
|
// A saved dark theme and accent used to flash the default light accent for as
|
|
// long as it took the script to fetch /looks. The server paints them now.
|
|
test("saved looks are painted by the server before any script runs", async () => {
|
|
const looksFile = path.join(HOME, "looks.json");
|
|
const before = fs.existsSync(looksFile) ? fs.readFileSync(looksFile) : null;
|
|
fs.writeFileSync(
|
|
looksFile,
|
|
JSON.stringify({ looks: { theme: "dark", accent: "violet", sound: true, width: "wide" } })
|
|
);
|
|
try {
|
|
const res = cli(["open", "--workflow", "plan", "--no-open"]);
|
|
const m = res.json.url.match(/^(http:\/\/127\.0\.0\.1:\d+)\/s\/([^/]+)\//);
|
|
const cookie = cookieFor(m[1], m[2]);
|
|
const html = await (await fetch(m[1] + "/", { headers: { cookie } })).text();
|
|
assert.match(html, /<html lang="en" data-theme="dark" data-looks-accent="violet" data-width="wide">/);
|
|
const css = await (await fetch(m[1] + "/app.css", { headers: { cookie } })).text();
|
|
assert.ok(css.includes(`:root[data-looks-accent="violet"][data-theme="dark"]{--accent:${ACCENTS.violet.dark[0]}`));
|
|
assert.ok(!css.includes(`data-looks-accent="${DEFAULT_ACCENT}"`), "the default needs no rule");
|
|
const boot = JSON.parse(html.match(/id="boot">([\s\S]*?)<\/script>/)[1]);
|
|
assert.equal(boot.looks.accent, "violet");
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
} finally {
|
|
if (before) fs.writeFileSync(looksFile, before);
|
|
else fs.rmSync(looksFile, { force: true });
|
|
}
|
|
});
|
|
|
|
test("static assets revalidate with an ETag instead of downloading again", async () => {
|
|
const res = cli(["open", "--workflow", "review", "--no-open"]);
|
|
const m = res.json.url.match(/^(http:\/\/127\.0\.0\.1:\d+)\/s\/([^/]+)\//);
|
|
const cookie = cookieFor(m[1], m[2]);
|
|
const first = await fetch(m[1] + "/app.js", { headers: { cookie } });
|
|
assert.equal(first.status, 200);
|
|
assert.equal(first.headers.get("cache-control"), "no-cache");
|
|
const etag = first.headers.get("etag");
|
|
assert.ok(etag);
|
|
await first.arrayBuffer();
|
|
const again = await fetch(m[1] + "/app.js", { headers: { cookie, "if-none-match": etag } });
|
|
assert.equal(again.status, 304);
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
});
|
|
|
|
// The page drew from the inline state; the stream's opening frame would only
|
|
// make it draw the same screen again. It is skipped when the page's `have`
|
|
// still matches, and sent whenever anything differs.
|
|
test("the stream skips its opening frame only when the page already has that exact state", async () => {
|
|
const res = cli(["open", "--file", payload("have.json", BASE), "--no-open"]);
|
|
const m = res.json.url.match(/^(http:\/\/127\.0\.0\.1:(\d+))\/s\/([^/]+)\//);
|
|
const cookie = cookieFor(m[1], m[3]);
|
|
await (await fetch(m[1] + "/state", { headers: { cookie } })).json();
|
|
|
|
const firstChunk = (have) =>
|
|
new Promise((resolve, reject) => {
|
|
const req = http.request(
|
|
{
|
|
host: "127.0.0.1",
|
|
port: Number(m[2]),
|
|
path: "/events" + (have ? "?have=" + encodeURIComponent(have) : ""),
|
|
headers: { cookie },
|
|
},
|
|
(r) => {
|
|
let buf = "";
|
|
r.setEncoding("utf8");
|
|
r.on("data", (c) => (buf += c));
|
|
setTimeout(() => {
|
|
req.destroy();
|
|
resolve(buf);
|
|
}, 300);
|
|
}
|
|
);
|
|
req.on("error", reject);
|
|
req.end();
|
|
});
|
|
|
|
assert.match(await firstChunk(null), /event: state/, "no key: the frame goes");
|
|
assert.match(await firstChunk("0.0.00"), /event: state/, "a stale key: the frame goes");
|
|
// The ledger poll's first tick pushes a frame to every connected client
|
|
// whatever the key (the newLaunch check in checkLedger), and it lands inside
|
|
// the 300 ms read above when the connection is mid-window. Wait that tick
|
|
// out and re-read the key, or its broadcast reads as the skipped frame.
|
|
await sleep(1200);
|
|
const still = await (await fetch(m[1] + "/state", { headers: { cookie } })).json();
|
|
assert.doesNotMatch(await firstChunk(still.have), /event: state/, "the page's own key: skipped");
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
});
|
|
|
|
// `open` binds the port and sends the browser before the server has booted.
|
|
// Whatever connects in that gap must be served, not refused: queued requests
|
|
// wait in the socket, and one `open` already accepted is passed across.
|
|
test("a request that arrives before the server takes the socket is still answered", async () => {
|
|
const dir = fs.mkdtempSync(path.join(HOME, "handoff-"));
|
|
fs.writeFileSync(path.join(dir, "state.json"), JSON.stringify({ sid: path.basename(dir), phase: "collecting" }));
|
|
const pre = await bindLoopback();
|
|
const port = pre.address().port;
|
|
// In flight before the server process even exists.
|
|
const early = fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(10000) }).then((r) => r.json());
|
|
await new Promise((r) => setTimeout(r, 50));
|
|
const child = spawn(
|
|
process.execPath,
|
|
[path.join(ROOT, "src", "web-console", "server.mjs"), "--session", dir, "--token", "t", "--project", dir, "--handoff"],
|
|
{ env: ENV, stdio: ["ignore", "ignore", "ignore", "ipc"], windowsHide: true }
|
|
);
|
|
try {
|
|
await handOff(child, pre);
|
|
assert.equal((await early).sid, path.basename(dir));
|
|
const late = await (await fetch(`http://127.0.0.1:${port}/health`)).json();
|
|
assert.equal(late.sid, path.basename(dir), "the server kept the port after the handover");
|
|
} finally {
|
|
child.kill();
|
|
}
|
|
});
|
|
|
|
// Each skill's Interface step has to put `open` before any reading: a skill
|
|
// that says "read console.md" first costs the person a whole model turn of
|
|
// staring at a terminal before the page appears.
|
|
test("every skill opens the console before it reads anything", () => {
|
|
const skills = fs.readdirSync(path.join(ROOT, "src")).filter((f) => /^plan2code(-.*)?\.md$/.test(f));
|
|
assert.ok(skills.length >= 13);
|
|
for (const f of skills) {
|
|
const text = fs.readFileSync(path.join(ROOT, "src", f), "utf8");
|
|
const open = text.search(/console\.mjs" open(?! --resume)/);
|
|
assert.ok(open > -1, `${f} names the open command`);
|
|
const firstRead = text.search(/read (?:<D>\/)?console\.md/i);
|
|
if (firstRead > -1) assert.ok(open < firstRead, `${f} opens before it reads console.md`);
|
|
}
|
|
});
|
|
|
|
/* ------------------------------------------- polish 2: plumbing (phase 1) */
|
|
|
|
|
|
|
|
test("the card-width presets validate a saved width and fall back to comfortable", () => {
|
|
for (const key of Object.keys(CARD_WIDTHS)) assert.equal(cardWidth(key), key);
|
|
for (const junk of [undefined, "huge", "__proto__", 42]) assert.equal(cardWidth(junk), "comfortable");
|
|
assert.equal(DEFAULT_CARD_WIDTH, "comfortable");
|
|
assert.deepEqual(
|
|
Object.values(CARD_WIDTHS).map((w) => w.px),
|
|
[720, 880, 1080, 1440]
|
|
);
|
|
});
|
|
|
|
test("a build's phase-numbered task label is rewritten to count within the phase", () => {
|
|
assert.equal(taskLabel("Task 4.2 of 6: x"), "Task 2 of 6: x");
|
|
assert.equal(taskLabel("Task 12.10 of 14"), "Task 10 of 14");
|
|
for (const same of ["Task 2 of 6: x", "Reading files", "", null]) assert.equal(taskLabel(same), same);
|
|
assert.deepEqual([...BUILD_WORKFLOWS].sort(), ["implement", "implement-review"]);
|
|
});
|
|
|
|
test("only a build's activity line is rewritten", () => {
|
|
assert.equal(activityLabel("Task 4.2 of 6: x", "implement"), "Task 2 of 6: x");
|
|
assert.equal(activityLabel("Task 4.2 of 6: x", "implement-review"), "Task 2 of 6: x");
|
|
assert.equal(activityLabel("Task 4.2 of 6: x", "plan"), "Task 4.2 of 6: x");
|
|
assert.equal(activityLabel("Task 4.2 of 6: x", "quick-task"), "Task 4.2 of 6: x");
|
|
assert.equal(activityLabel("Task 4.2 of 6: x", "dashboard"), "Task 4.2 of 6: x");
|
|
});
|
|
|
|
test("a working agent's line falls back to its headline note", () => {
|
|
const working = { status: "working" };
|
|
assert.equal(workingLine({ ...working, activity: " Task 4.2 of 6: x " }, { note: "n" }, "implement"), "Task 2 of 6: x");
|
|
assert.equal(workingLine(working, { stage: "Writing the spec", note: " Turning the plan into files. " }, "document"), "Turning the plan into files.");
|
|
assert.equal(workingLine(working, { stage: "Writing the spec" }, "document"), "");
|
|
assert.equal(workingLine({ status: "waiting", activity: "x" }, { note: "n" }, "document"), "");
|
|
assert.equal(workingLine(undefined, undefined, "document"), "");
|
|
});
|
|
|
|
test("the terminal line is the exact text every command hands back", () => {
|
|
assert.equal(terminalLine("http://127.0.0.1:1/s/abc/"), "→ Look at the web console: http://127.0.0.1:1/s/abc/");
|
|
// Under the desktop app the page is beside the terminal: no address to print.
|
|
const inApp = terminalLine("http://127.0.0.1:1/s/abc/", { PLAN2CODE_IN_APP: "1" });
|
|
assert.equal(inApp.includes("127.0.0.1"), false, "no address under the app");
|
|
assert.equal(terminalLine("http://127.0.0.1:1/s/abc/", {}), "→ Look at the web console: http://127.0.0.1:1/s/abc/");
|
|
});
|
|
|
|
test("repoRoots reads the branch off disk: named, detached, a linked worktree's own, and none", () => {
|
|
const base = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-branch-"));
|
|
try {
|
|
const named = path.join(base, "named");
|
|
fs.mkdirSync(path.join(named, ".git"), { recursive: true });
|
|
fs.writeFileSync(path.join(named, ".git", "HEAD"), "ref: refs/heads/feature/x\n");
|
|
assert.equal(repoRoots(named).branch, "feature/x");
|
|
|
|
const detached = path.join(base, "detached");
|
|
fs.mkdirSync(path.join(detached, ".git"), { recursive: true });
|
|
fs.writeFileSync(path.join(detached, ".git", "HEAD"), "a".repeat(40) + "\n");
|
|
assert.equal(repoRoots(detached).branch, "");
|
|
|
|
// A linked worktree: `.git` is a file naming its own git dir, whose HEAD
|
|
// is on a different branch from the main checkout's.
|
|
const wtGit = path.join(named, ".git", "worktrees", "wt");
|
|
fs.mkdirSync(wtGit, { recursive: true });
|
|
fs.writeFileSync(path.join(wtGit, "HEAD"), "ref: refs/heads/other\n");
|
|
fs.writeFileSync(path.join(wtGit, "commondir"), "../..\n");
|
|
const wt = path.join(base, "wt");
|
|
fs.mkdirSync(wt);
|
|
fs.writeFileSync(path.join(wt, ".git"), `gitdir: ${wtGit}\n`);
|
|
assert.equal(repoRoots(wt).branch, "other");
|
|
|
|
const plain = path.join(base, "plain");
|
|
fs.mkdirSync(plain);
|
|
assert.equal(repoRoots(plain).branch, "");
|
|
} finally {
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
// With git's relocation variables set, repoRoots asks git. A repository with
|
|
// no commits yet must still key on the right project and name its branch.
|
|
test("repoRoots asks git when GIT_DIR is set, even before the first commit", () => {
|
|
const base = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-gitdir-"));
|
|
const repo = path.join(base, "repo");
|
|
fs.mkdirSync(repo);
|
|
execFileSync("git", ["init", "-q", "-b", "fresh-start"], { cwd: repo, stdio: "ignore" });
|
|
const before = process.env.GIT_DIR;
|
|
process.env.GIT_DIR = path.join(repo, ".git");
|
|
try {
|
|
const roots = repoRoots(repo);
|
|
const full = fs.realpathSync.native(repo);
|
|
assert.deepEqual(roots, { project: full, worktree: full, branch: "fresh-start" });
|
|
} finally {
|
|
if (before === undefined) delete process.env.GIT_DIR;
|
|
else process.env.GIT_DIR = before;
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("the session sweep removes only month-old session dirs, never the one being opened", async () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-sessions-"));
|
|
try {
|
|
const make = (name, { stale = true, state = true } = {}) => {
|
|
const d = path.join(dir, name);
|
|
fs.mkdirSync(d, { recursive: true });
|
|
if (state) {
|
|
fs.writeFileSync(path.join(d, "state.json"), "{}");
|
|
if (stale) backdate(path.join(d, "state.json"));
|
|
}
|
|
return d;
|
|
};
|
|
const old = make("20250801-101010-aaaaaa");
|
|
const fresh = make("20260920-101010-bbbbbb", { stale: false });
|
|
const skip = make("20250801-101010-cccccc");
|
|
const notes = make("notes");
|
|
const noState = make("20250801-101010-dddddd", { state: false });
|
|
const plainFile = path.join(dir, "20250801-101010-eeeeee");
|
|
fs.writeFileSync(plainFile, "x");
|
|
backdate(plainFile);
|
|
|
|
const stale = staleSessions(dir, Date.now(), SESSION_MAX_AGE_MS, "20250801-101010-cccccc");
|
|
assert.deepEqual(stale, ["20250801-101010-aaaaaa"]);
|
|
assert.deepEqual(await removeSessions(dir, [...stale, "../escape", "notes"]), ["20250801-101010-aaaaaa"]);
|
|
assert.equal(fs.existsSync(old), false);
|
|
for (const p of [fresh, skip, notes, noState, plainFile]) assert.ok(fs.existsSync(p), p);
|
|
assert.deepEqual(staleSessions(path.join(dir, "missing"), Date.now(), SESSION_MAX_AGE_MS, ""), []);
|
|
} finally {
|
|
fs.rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("the scratch sweep removes old patches and helpers, never looks, the pointer, the update cache or a directory", async () => {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-scratch-"));
|
|
try {
|
|
const file = (name, stale = true) => {
|
|
const p = path.join(dir, name);
|
|
fs.writeFileSync(p, "{}");
|
|
if (stale) backdate(p);
|
|
return p;
|
|
};
|
|
const removable = [file("p2.json"), file("helper.mjs")];
|
|
const kept = [
|
|
file("looks.json"),
|
|
file("workspaces.json"),
|
|
file("loop-setup.json"),
|
|
file("spec-carry.json"),
|
|
file("loop-reports.json"),
|
|
file("subagents.json"),
|
|
file("pr-hosts.json"),
|
|
file("console-dir"),
|
|
file("update-check.json"),
|
|
file("notes.txt"),
|
|
file("p3.json", false),
|
|
];
|
|
const subdir = path.join(dir, "x.json");
|
|
fs.mkdirSync(subdir);
|
|
backdate(subdir);
|
|
kept.push(subdir);
|
|
|
|
const stale = staleScratch(dir, Date.now(), SESSION_MAX_AGE_MS).sort();
|
|
assert.deepEqual(stale, ["helper.mjs", "p2.json"]);
|
|
assert.deepEqual(
|
|
(await removeScratch(dir, [...stale, "looks.json", "workspaces.json", "loop-setup.json", "loop-reports.json", "subagents.json", "spec-carry.json", "pr-hosts.json", "../p.json", "console-dir", "update-check.json"])).sort(),
|
|
["helper.mjs", "p2.json"]
|
|
);
|
|
for (const p of removable) assert.equal(fs.existsSync(p), false, p);
|
|
for (const p of kept) assert.ok(fs.existsSync(p), p);
|
|
assert.deepEqual([...PROTECTED_CONSOLE_FILES].sort(), [
|
|
"console-dir",
|
|
"looks.json",
|
|
"loop-reports.json",
|
|
"loop-setup.json",
|
|
"pr-hosts.json",
|
|
"spec-carry.json",
|
|
"subagents.json",
|
|
"update-check.json",
|
|
"workspaces.json",
|
|
]);
|
|
} finally {
|
|
fs.rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("cleanup finds old sessions and strays in both folders, and keeps every protected name and this session", async () => {
|
|
const plan2code = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-cleanup-"));
|
|
const consoleDir = path.join(plan2code, "console");
|
|
try {
|
|
// Strays count only once they have sat for the grace period, so every one
|
|
// this test expects to be found is backdated.
|
|
const put = (p, body = "{}") => {
|
|
fs.mkdirSync(path.dirname(p), { recursive: true });
|
|
fs.writeFileSync(p, body);
|
|
return p;
|
|
};
|
|
const stray = (p, body) => {
|
|
put(p, body);
|
|
backdate(p);
|
|
return p;
|
|
};
|
|
const session = (sid, stale) => {
|
|
const state = put(path.join(consoleDir, "sessions", sid, "state.json"));
|
|
if (stale) backdate(state);
|
|
return path.dirname(state);
|
|
};
|
|
const old = session("20250801-101010-aaaaaa", true);
|
|
const current = session("20250801-101010-bbbbbb", true);
|
|
const fresh = session("20260920-101010-cccccc", false);
|
|
// A month-old state.json, but a draft saved today: still in use.
|
|
const drafted = session("20250801-101010-dddddd", true);
|
|
put(path.join(drafted, "draft.json"));
|
|
const kept = [
|
|
...["looks.json", "workspaces.json", "subagents.json", "console-dir", "update-check.json"].map((n) =>
|
|
put(path.join(consoleDir, n))
|
|
),
|
|
put(path.join(plan2code, "launcher.json")),
|
|
put(path.join(plan2code, "models.json")),
|
|
put(path.join(plan2code, "bin", "plan2code.js"), "x"),
|
|
current,
|
|
fresh,
|
|
drafted,
|
|
];
|
|
stray(path.join(consoleDir, "p1.json"), "12345");
|
|
put(path.join(consoleDir, "runtime", "x.json"));
|
|
// The shared console install, one folder per version, however old: never a stray.
|
|
const installed = stray(path.join(consoleDir, "3.0.4", "console.mjs"), "x");
|
|
backdate(path.dirname(installed));
|
|
kept.push(installed);
|
|
// A folder that is not a version stays a stray.
|
|
backdate(put(path.join(consoleDir, "3.0", "x.txt")));
|
|
backdate(path.join(consoleDir, "3.0"));
|
|
backdate(put(path.join(plan2code, "console-dev", "sessions", "x.txt"), "abc"));
|
|
backdate(path.join(plan2code, "console-dev"));
|
|
// An old folder with a file rewritten just now: the folder's own mtime
|
|
// never moves for that, so only its contents show it is in use.
|
|
const busy = put(path.join(plan2code, "busy", "log.txt"));
|
|
backdate(path.join(plan2code, "busy"));
|
|
kept.push(busy);
|
|
stray(path.join(plan2code, "notes.txt"));
|
|
// Handoffs are Plan2Code's own, however old: swept by age on open, never offered here.
|
|
backdate(put(path.join(plan2code, "handoffs", "2025-01-01-0900-handoff.md")));
|
|
backdate(path.join(plan2code, "handoffs"));
|
|
// The desktop app and its settings are Plan2Code's own too, however old.
|
|
backdate(put(path.join(plan2code, "app", "plan2code-app"), "x"));
|
|
backdate(path.join(plan2code, "app"));
|
|
backdate(put(path.join(plan2code, "app.json")));
|
|
backdate(put(path.join(plan2code, "agents.json")));
|
|
// UI Prototype drafts are swept by age by the skill's own script, never offered here.
|
|
backdate(put(path.join(plan2code, "prototypes", "my-app-0123456789ab", "invoices", "invoices-round-1.html"), "x"));
|
|
backdate(path.join(plan2code, "prototypes"));
|
|
// Learning's waiting items and pause are swept by the core's own 30-day rule, never offered here.
|
|
backdate(put(path.join(plan2code, "learning", "my-app-0123456789ab", "pause.json"), "{}"));
|
|
backdate(path.join(plan2code, "learning", "my-app-0123456789ab"));
|
|
backdate(path.join(plan2code, "learning"));
|
|
// In use right now: a held lock and a temp between its write and rename.
|
|
const live = [put(path.join(consoleDir, "workspaces.json.lock"), ""), put(path.join(plan2code, "models.json.123.tmp"))];
|
|
kept.push(...live);
|
|
stray(path.join(consoleDir, "looks.json.456.tmp"));
|
|
|
|
const opts = { consoleDir, plan2codeDir: plan2code, skipSid: "20250801-101010-bbbbbb" };
|
|
const { items, bytes } = await cleanupFindings(opts);
|
|
assert.deepEqual(items.map((i) => i.id).sort(), [
|
|
"console:3.0",
|
|
"console:looks.json.456.tmp",
|
|
"console:p1.json",
|
|
"root:console-dev",
|
|
"root:notes.txt",
|
|
"session:20250801-101010-aaaaaa",
|
|
]);
|
|
assert.equal(items.some((i) => i.id === "root:handoffs"), false, "the handoffs folder is never a stray");
|
|
for (const id of ["root:app", "root:app.json", "root:agents.json", "root:prototypes", "root:learning"]) assert.equal(items.some((i) => i.id === id), false, `${id} is never a stray`);
|
|
assert.equal(STRAY_GRACE_MS, 60 * 60 * 1000);
|
|
assert.equal(items.find((i) => i.id === "console:p1.json").bytes, 5);
|
|
assert.equal(items.find((i) => i.id === "root:console-dev").kind, "folder");
|
|
assert.equal(bytes, items.reduce((n, i) => n + i.bytes, 0));
|
|
|
|
// A console running from another home never reaches the folder above it.
|
|
const elsewhere = await cleanupFindings({ ...opts, plan2codeDir: path.join(plan2code, "other") });
|
|
assert.deepEqual(elsewhere.items.map((i) => i.where).sort(), ["console", "console", "console", "session"]);
|
|
|
|
// Only ids a fresh scan still finds are removed; anything else is ignored.
|
|
const done = await removeCleanup(
|
|
["console:p1.json", "session:20250801-101010-aaaaaa", "session:20250801-101010-dddddd", "root:busy", "root:console-dev", "console:looks.json", "root:bin", "session:20250801-101010-bbbbbb", "console:workspaces.json.lock", "root:models.json.123.tmp", "console:../escape", 7],
|
|
opts
|
|
);
|
|
assert.deepEqual(done.removed.sort(), ["console:p1.json", "root:console-dev", "session:20250801-101010-aaaaaa"]);
|
|
assert.deepEqual(done.failed, []);
|
|
assert.equal(done.bytes, 5 + 3 + 2);
|
|
assert.equal(fs.existsSync(old), false);
|
|
assert.equal(fs.existsSync(path.join(plan2code, "console-dev")), false);
|
|
assert.ok(fs.existsSync(path.join(plan2code, "notes.txt")), "not asked for, so not removed");
|
|
for (const p of kept) assert.ok(fs.existsSync(p), p);
|
|
assert.ok(fs.existsSync(path.join(consoleDir, "runtime", "x.json")));
|
|
} finally {
|
|
fs.rmSync(plan2code, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("cleanup lists the project's completed specs untouched for 30 days, and removes only those", async () => {
|
|
const base = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-cleanup-completed-"));
|
|
const consoleDir = path.join(base, "home", "console");
|
|
const project = path.join(base, "project");
|
|
const completed = path.join(project, "specs--completed");
|
|
try {
|
|
const put = (p, body = "{}") => {
|
|
fs.mkdirSync(path.dirname(p), { recursive: true });
|
|
fs.writeFileSync(p, body);
|
|
return p;
|
|
};
|
|
fs.mkdirSync(consoleDir, { recursive: true });
|
|
fs.mkdirSync(project, { recursive: true });
|
|
const g = gitInit(project);
|
|
const opts = { consoleDir, plan2codeDir: path.join(base, "home"), skipSid: "x", project };
|
|
|
|
// No specs--completed/ at all is just nothing to list.
|
|
assert.deepEqual((await cleanupFindings(opts)).items, []);
|
|
|
|
backdate(put(path.join(completed, "old-spec", "overview.md"), "abc"));
|
|
backdate(path.join(completed, "old-spec"));
|
|
put(path.join(completed, "fresh-spec", "overview.md"));
|
|
// An old folder with one file finalized today: still recent.
|
|
backdate(put(path.join(completed, "touched-spec", "phase-1.md")));
|
|
put(path.join(completed, "touched-spec", "overview.md"));
|
|
backdate(put(path.join(completed, "README.md")));
|
|
backdate(put(path.join(project, "specs", "live-spec", "overview.md")));
|
|
// Committed, so Cleanup may delete it (an untracked one is refused: see the next test).
|
|
g("add", "specs--completed/old-spec");
|
|
g("commit", "-q", "-m", "archive old-spec");
|
|
|
|
const { items } = await cleanupFindings(opts);
|
|
assert.deepEqual(items.map((i) => i.id), ["completed:old-spec"]);
|
|
assert.equal(items[0].where, "completed");
|
|
assert.equal(items[0].kind, "folder");
|
|
assert.equal(items[0].bytes, 3);
|
|
|
|
// Without a project, the archive is never looked at.
|
|
const { project: _p, ...noProject } = opts;
|
|
assert.deepEqual((await cleanupFindings(noProject)).items, []);
|
|
|
|
const done = await removeCleanup(["completed:old-spec", "completed:fresh-spec", "completed:../specs", "completed:README.md"], opts);
|
|
assert.deepEqual(done.removed, ["completed:old-spec"]);
|
|
assert.equal(fs.existsSync(path.join(completed, "old-spec")), false);
|
|
for (const p of ["fresh-spec", "touched-spec", "README.md"]) assert.ok(fs.existsSync(path.join(completed, p)), p);
|
|
assert.ok(fs.existsSync(path.join(project, "specs", "live-spec")));
|
|
} finally {
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("cleanup refuses a completed spec git does not track, says why, and still deletes a tracked one and everything else", async () => {
|
|
const base = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-cleanup-guard-"));
|
|
const home = path.join(base, "home");
|
|
const consoleDir = path.join(home, "console");
|
|
const project = path.join(base, "project");
|
|
const completed = path.join(project, "specs--completed");
|
|
try {
|
|
const put = (p, body = "{}") => {
|
|
fs.mkdirSync(path.dirname(p), { recursive: true });
|
|
fs.writeFileSync(p, body);
|
|
return p;
|
|
};
|
|
const oldSpec = (name, file = "overview.md") => {
|
|
backdate(put(path.join(completed, name, file), "abc"));
|
|
backdate(path.join(completed, name));
|
|
};
|
|
fs.mkdirSync(consoleDir, { recursive: true });
|
|
fs.mkdirSync(project, { recursive: true });
|
|
const g = gitInit(project);
|
|
// The default: Init gitignores the archive, so only a forced add tracks a spec.
|
|
put(path.join(project, ".gitignore"), "specs--completed/\n");
|
|
oldSpec("tracked-spec");
|
|
oldSpec("untracked-spec");
|
|
oldSpec("partly-spec");
|
|
oldSpec("edited-spec");
|
|
g("add", ".gitignore");
|
|
g("add", "-f", "specs--completed/tracked-spec", "specs--completed/partly-spec", "specs--completed/edited-spec");
|
|
g("commit", "-q", "-m", "archive");
|
|
// A file added after the commit: git could not give it back.
|
|
oldSpec("partly-spec", "notes.md");
|
|
// A tracked file edited after the commit: git could give back only the old text.
|
|
backdate(put(path.join(completed, "edited-spec", "overview.md"), "edited"));
|
|
backdate(path.join(completed, "edited-spec"));
|
|
// Not a spec: removed as before, in the same call.
|
|
backdate(put(path.join(consoleDir, "stray.json")));
|
|
|
|
const opts = { consoleDir, plan2codeDir: home, skipSid: "x", project };
|
|
const ids = ["completed:tracked-spec", "completed:untracked-spec", "completed:partly-spec", "completed:edited-spec", "console:stray.json"];
|
|
assert.deepEqual((await cleanupFindings(opts)).items.map((i) => i.id).sort(), [...ids].sort(), "the scan still lists all of them");
|
|
|
|
const done = await removeCleanup(ids, opts);
|
|
assert.deepEqual(done.removed.sort(), ["completed:tracked-spec", "console:stray.json"]);
|
|
assert.deepEqual(done.refused.sort(), ["completed:edited-spec", "completed:partly-spec", "completed:untracked-spec"]);
|
|
assert.deepEqual(done.failed, []);
|
|
assert.equal(fs.existsSync(path.join(completed, "tracked-spec")), false, "a tracked spec is deleted");
|
|
assert.equal(fs.existsSync(path.join(consoleDir, "stray.json")), false);
|
|
for (const name of ["untracked-spec", "partly-spec", "edited-spec"]) assert.ok(fs.existsSync(path.join(completed, name, "overview.md")), name + " is kept");
|
|
assert.ok(fs.existsSync(path.join(completed, "partly-spec", "notes.md")));
|
|
assert.match(done.refusal, /^Kept 3 completed specs git does not track as they stand, so deleting them would lose them for good: /);
|
|
assert.ok(done.refusal.includes("specs--completed/untracked-spec/"), done.refusal);
|
|
assert.ok(done.refusal.includes("specs--completed/partly-spec/"), done.refusal);
|
|
assert.ok(done.refusal.includes("specs--completed/edited-spec/"), done.refusal);
|
|
assert.equal(fs.readFileSync(path.join(completed, "edited-spec", "overview.md"), "utf8"), "edited", "the uncommitted edit survives");
|
|
assert.equal(done.refusal.includes("specs--completed/tracked-spec/"), false, "the deleted spec is not named");
|
|
|
|
// A project that is not a repository at all: nothing there is tracked.
|
|
const loose = path.join(base, "loose");
|
|
backdate(put(path.join(loose, "specs--completed", "only-spec", "overview.md")));
|
|
backdate(path.join(loose, "specs--completed", "only-spec"));
|
|
const alone = await removeCleanup(["completed:only-spec"], { ...opts, project: loose });
|
|
assert.deepEqual(alone.removed, []);
|
|
assert.deepEqual(alone.refused, ["completed:only-spec"]);
|
|
assert.equal(alone.refusal, "Kept specs--completed/only-spec/: git does not track it as it stands, so deleting it would lose it for good. Commit it first, or delete it yourself once it is backed up.");
|
|
assert.ok(fs.existsSync(path.join(loose, "specs--completed", "only-spec")));
|
|
|
|
// Nothing refused: no line.
|
|
assert.equal((await removeCleanup([], opts)).refusal, "");
|
|
} finally {
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("User Preferences: wider, its body scrolls and the button bar stays put, without touching dialogs that borrow .looks", () => {
|
|
const html = fs.readFileSync(path.join(ROOT, "src", "web-console", "public", "index.html"), "utf8");
|
|
const css = joinedCss();
|
|
const dialog = html.match(/<dialog class="modal looks prefs" id="looks-modal"[^>]*>([\s\S]*?)<\/dialog>/);
|
|
assert.ok(dialog, "the Preferences dialog carries the prefs class");
|
|
const body = dialog[1].indexOf('<div class="prefs-body">');
|
|
const actions = dialog[1].indexOf('<div class="modal-actions">');
|
|
assert.ok(body >= 0 && actions > body, "the fieldsets sit in .prefs-body, before the actions");
|
|
assert.ok(dialog[1].lastIndexOf("</fieldset>") < actions, "every fieldset is inside the scrolling body");
|
|
assert.match(css, /\.modal\.prefs \{ width: min\(1080px, var\(--card-width\), calc\(100vw - 32px\)\); max-width: none; \}/);
|
|
assert.match(css, /\.prefs-body \{[^}]*overflow-y: auto/);
|
|
assert.match(css, /\.modal\.prefs \.modal-actions \{[^}]*flex: none/);
|
|
assert.match(html, /<dialog class="modal looks subagents" id="subagents-modal"/, "Subagents keeps its own classes");
|
|
});
|
|
|
|
// A temp project with specs/a (overview) and specs/b (no overview), and a
|
|
// file outside the root for escapes to aim at.
|
|
function overviewProject() {
|
|
const base = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-overview-"));
|
|
const root = path.join(base, "project");
|
|
fs.mkdirSync(path.join(root, "specs", "a"), { recursive: true });
|
|
fs.mkdirSync(path.join(root, "specs", "b"), { recursive: true });
|
|
fs.writeFileSync(path.join(root, "specs", "a", "overview.md"), "# Overview A\n");
|
|
fs.writeFileSync(path.join(root, "specs", "a", "phase-1.md"), "- [ ] **Task 1.1:** x\n");
|
|
fs.writeFileSync(path.join(root, "specs", "b", "notes.md"), "notes\n");
|
|
// Planned, not documented: a Pathfinder map and a live draft beside the
|
|
// copy Revise plan keeps of the last one.
|
|
fs.mkdirSync(path.join(root, "specs", "c", "pathfinder"), { recursive: true });
|
|
fs.writeFileSync(path.join(root, "specs", "c", "pathfinder", "map.md"), "# Map C\n");
|
|
fs.writeFileSync(path.join(root, "specs", "c", "PLAN-DRAFT-20261020.md"), "# Draft C\n");
|
|
fs.writeFileSync(path.join(root, "specs", "c", "PLAN-DRAFT-20261020-prev.md"), "# Old draft C\n");
|
|
fs.mkdirSync(path.join(base, "outside"));
|
|
fs.writeFileSync(path.join(base, "outside", "overview.md"), "# SECRET\n");
|
|
return { base, root };
|
|
}
|
|
|
|
test("readOverview reads a spec's overview and nothing outside the root", async () => {
|
|
const { base, root } = overviewProject();
|
|
try {
|
|
assert.equal(await readOverview(root, "specs/a"), "# Overview A\n");
|
|
assert.equal(await readOverview(root, "specs/b"), null);
|
|
assert.equal(await readOverview(root, "../outside"), null);
|
|
assert.equal(await readOverview(root, path.join(base, "outside")), null);
|
|
assert.equal(await readOverview(root, ""), null);
|
|
assert.equal(await readOverview("", "specs/a"), null);
|
|
let linked = true;
|
|
try {
|
|
fs.symlinkSync(path.join(base, "outside"), path.join(root, "specs", "link"), "junction");
|
|
} catch (err) {
|
|
if (err.code !== "EPERM") throw err;
|
|
linked = false;
|
|
}
|
|
if (linked) assert.equal(await readOverview(root, "specs/link"), null);
|
|
|
|
// A root that is the drive (or filesystem) root itself still contains
|
|
// its own files: the root already ends in a separator.
|
|
const driveRoot = path.parse(root).root;
|
|
assert.equal(await readOverview(driveRoot, path.relative(driveRoot, path.join(root, "specs", "a"))), "# Overview A\n");
|
|
// A folder whose name merely starts with ".." is inside the root.
|
|
fs.mkdirSync(path.join(root, "..dots"));
|
|
fs.writeFileSync(path.join(root, "..dots", "overview.md"), "# Dots\n");
|
|
assert.equal(await readOverview(root, "..dots"), "# Dots\n");
|
|
} finally {
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("readSpecFile reads a spec's map and live plan draft, and names the file", async () => {
|
|
const { base, root } = overviewProject();
|
|
try {
|
|
assert.deepEqual(await readSpecFile(root, "specs/c", "map"), { file: "pathfinder/map.md", text: "# Map C\n" });
|
|
assert.deepEqual(await readSpecFile(root, "specs/c", "draft"), { file: "PLAN-DRAFT-20261020.md", text: "# Draft C\n" });
|
|
assert.deepEqual(await readSpecFile(root, "specs/a", "overview"), { file: "overview.md", text: "# Overview A\n" });
|
|
assert.equal(await readSpecFile(root, "specs/c", "overview"), null);
|
|
assert.equal(await readSpecFile(root, "specs/a", "map"), null);
|
|
assert.equal(await readSpecFile(root, "specs/a", "draft"), null);
|
|
assert.equal(await readSpecFile(root, "specs/c", "phase-1.md"), null, "only the known kinds");
|
|
assert.equal(await readSpecFile(root, "../outside", "draft"), null);
|
|
} finally {
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("GET /overview serves the session's spec, and on the dashboard only a scanned one", async () => {
|
|
const { base, root } = overviewProject();
|
|
const sids = [];
|
|
try {
|
|
const get = (s, q = "", cookie = s.cookie) =>
|
|
fetch(`${s.base}/overview${q}`, { headers: cookie ? { cookie, connection: "close" } : { connection: "close" } });
|
|
|
|
const plan = cliIn(root, ["open", "--workflow", "plan", "--spec", "specs/a", "--no-open"]);
|
|
sids.push(plan.json.sid);
|
|
const p = sessionUrl(plan.json.url);
|
|
const ok = await get(p, "?spec=specs/b");
|
|
assert.equal(ok.status, 200);
|
|
assert.match(ok.headers.get("content-type"), /^text\/markdown/);
|
|
assert.equal(ok.headers.get("cache-control"), "no-store");
|
|
assert.equal(await ok.text(), "# Overview A\n", "the spec query is ignored outside the dashboard");
|
|
assert.equal((await get(p, "", null)).status, 403);
|
|
|
|
const noOverview = cliIn(root, ["open", "--workflow", "plan", "--spec", "specs/b", "--no-open"]);
|
|
sids.push(noOverview.json.sid);
|
|
assert.equal((await get(sessionUrl(noOverview.json.url))).status, 204, "no overview.md is normal: 204, not a failed request in the console");
|
|
|
|
const dash = cliIn(root, ["open", "--workflow", "dashboard", "--no-open"]);
|
|
sids.push(dash.json.sid);
|
|
const d = sessionUrl(dash.json.url);
|
|
assert.equal((await get(d, "?spec=specs/a")).status, 200);
|
|
// A scanned spec with no overview.md: the page hides the tab on this 204 (anything but a 200).
|
|
assert.ok(readState(dash.json.session).scan.specs.some((s) => s.dir === "specs/b"), "specs/b is in the scan");
|
|
assert.equal((await get(d, "?spec=specs/b")).status, 204);
|
|
assert.equal((await get(d, "?spec=specs/../..")).status, 204);
|
|
assert.equal((await get(d, "?spec=specs/not-scanned")).status, 204);
|
|
// ?file= picks the map or the live draft, and names it for the page.
|
|
const map = await get(d, "?spec=specs/c&file=map");
|
|
assert.equal(map.status, 200);
|
|
assert.equal(map.headers.get("x-spec-file"), encodeURIComponent("pathfinder/map.md"));
|
|
assert.equal(await map.text(), "# Map C\n");
|
|
const draft = await get(d, "?spec=specs/c&file=draft");
|
|
assert.equal(draft.headers.get("x-spec-file"), "PLAN-DRAFT-20261020.md");
|
|
assert.equal(await draft.text(), "# Draft C\n");
|
|
assert.equal((await get(d, "?spec=specs/c")).status, 204, "no overview.md yet");
|
|
assert.equal((await get(d, "?spec=specs/c&file=nope")).status, 204);
|
|
} finally {
|
|
for (const s of sids) cliIn(root, ["stop", "--session", s, "--force"]);
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
// The Prototypes tab's routes: the list, one .md, and opening one .html in the
|
|
// default browser (PLAN2CODE_NO_BROWSER keeps the suite from starting one).
|
|
// The spec is chosen as /overview chooses it, and nothing outside the spec's
|
|
// prototypes/ folder is read or opened.
|
|
test("the Prototypes routes list, read and open only a scanned spec's prototypes", async () => {
|
|
const { base, root } = overviewProject();
|
|
const protos = path.join(root, "specs", "p", "prototypes");
|
|
fs.mkdirSync(protos, { recursive: true });
|
|
fs.writeFileSync(path.join(protos, "pick.md"), "# Pick\n");
|
|
fs.writeFileSync(path.join(protos, "pick.html"), "<p>pick</p>\n");
|
|
const sids = [];
|
|
try {
|
|
const dash = cliIn(root, ["open", "--workflow", "dashboard", "--no-open"]);
|
|
sids.push(dash.json.sid);
|
|
const d = sessionUrl(dash.json.url);
|
|
const get = (q, cookie = d.cookie) =>
|
|
fetch(`${d.base}${q}`, { headers: cookie ? { cookie, connection: "close" } : { connection: "close" } });
|
|
const open = (body, origin = d.base) =>
|
|
fetch(`${d.base}/open-prototype`, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie: d.cookie, origin, connection: "close" },
|
|
body: JSON.stringify(body),
|
|
});
|
|
|
|
const list = await get("/prototypes?spec=specs/p");
|
|
assert.equal(list.status, 200);
|
|
assert.deepEqual(await list.json(), { files: [{ name: "pick.html", kind: "html" }, { name: "pick.md", kind: "md" }] });
|
|
assert.equal((await get("/prototypes?spec=specs/p", null)).status, 403);
|
|
assert.equal((await get("/prototypes?spec=specs/a")).status, 204, "no prototypes folder: no tab");
|
|
assert.equal((await get("/prototypes?spec=specs/not-scanned")).status, 204);
|
|
|
|
const doc = await get("/prototype?spec=specs/p&name=pick.md");
|
|
assert.equal(doc.status, 200);
|
|
assert.equal(await doc.text(), "# Pick\n");
|
|
for (const name of ["pick.html", "../../a/overview.md", "missing.md"]) {
|
|
assert.equal((await get("/prototype?spec=specs/p&name=" + encodeURIComponent(name))).status, 204, name);
|
|
}
|
|
|
|
const ok = await open({ spec: "specs/p", name: "pick.html" });
|
|
assert.equal(ok.status, 200);
|
|
assert.deepEqual(await ok.json(), { ok: true });
|
|
for (const body of [
|
|
{ spec: "specs/p", name: "pick.md" },
|
|
{ spec: "specs/p", name: "../pick.html" },
|
|
{ spec: "specs/p", name: path.join(protos, "pick.html") },
|
|
{ spec: "specs/not-scanned", name: "pick.html" },
|
|
{ spec: "specs/p" },
|
|
]) {
|
|
assert.equal((await open(body)).status, 404, JSON.stringify(body));
|
|
}
|
|
assert.notEqual((await open({ spec: "specs/p", name: "pick.html" }, "https://evil.example")).status, 200, "another site's page cannot open files");
|
|
|
|
// Away from the dashboard, the session's own spec is used and ?spec= is ignored.
|
|
const plan = cliIn(root, ["open", "--workflow", "plan", "--spec", "specs/p", "--no-open"]);
|
|
sids.push(plan.json.sid);
|
|
const p = sessionUrl(plan.json.url);
|
|
const own = await fetch(`${p.base}/prototypes?spec=specs/a`, { headers: { cookie: p.cookie, connection: "close" } });
|
|
assert.equal(own.status, 200);
|
|
assert.equal((await own.json()).files.length, 2);
|
|
} finally {
|
|
for (const s of sids) cliIn(root, ["stop", "--session", s, "--force"]);
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("open records worktree and branch, and wakes only a freshly opened dashboard", () => {
|
|
const dash = cli(["open", "--workflow", "dashboard", "--no-open"]);
|
|
try {
|
|
assert.equal(dash.json.terminalLine, terminalLine(dash.json.url));
|
|
const state = readState(dash.json.session);
|
|
assert.equal(state.wake, true);
|
|
assert.equal(state.worktree, repoRoots(ROOT).worktree);
|
|
assert.equal(state.branch, repoRoots(ROOT).branch);
|
|
|
|
cli(["open", "--resume", dash.json.sid, "--workflow", "plan", "--no-open"]);
|
|
assert.equal("wake" in readState(dash.json.session), false);
|
|
cli(["open", "--resume", dash.json.sid, "--workflow", "dashboard", "--no-open"]);
|
|
assert.equal("wake" in readState(dash.json.session), false, "a return to the dashboard never replays");
|
|
cli(["open", "--resume", dash.json.sid, "--no-open"]);
|
|
assert.equal("wake" in readState(dash.json.session), false);
|
|
} finally {
|
|
cli(["stop", "--session", dash.json.sid, "--force"]);
|
|
}
|
|
|
|
const plan = cli(["open", "--workflow", "plan", "--no-open"]);
|
|
assert.equal("wake" in readState(plan.json.session), false);
|
|
cli(["stop", "--session", plan.json.sid, "--force"]);
|
|
});
|
|
|
|
test("open removes a month-old session without printing it", async () => {
|
|
const oldSid = "20250101-101010-abcdef";
|
|
const oldDir = path.join(HOME, "sessions", oldSid);
|
|
fs.mkdirSync(oldDir, { recursive: true });
|
|
fs.writeFileSync(path.join(oldDir, "state.json"), "{}");
|
|
backdate(path.join(oldDir, "state.json"));
|
|
const res = cli(["open", "--workflow", "plan", "--no-open"]);
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
assert.equal("swept" in res.json, false, "the sweep is housekeeping, not output");
|
|
for (let i = 0; i < 20 && fs.existsSync(oldDir); i++) await new Promise((r) => setTimeout(r, 100));
|
|
assert.equal(fs.existsSync(oldDir), false);
|
|
});
|
|
|
|
test("open removes a month-old handoff and both its files without printing them", async () => {
|
|
const id = "2025-01-01-0900-handoff";
|
|
fs.mkdirSync(HANDOFFS_DIR, { recursive: true });
|
|
const files = [path.join(HANDOFFS_DIR, id + ".md"), path.join(HANDOFFS_DIR, id + ".json")];
|
|
fs.writeFileSync(files[0], "# Handoff: old\n");
|
|
fs.writeFileSync(files[1], "{}");
|
|
for (const f of files) backdate(f);
|
|
const res = cli(["open", "--workflow", "plan", "--no-open"]);
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
assert.equal("swept" in res.json, false, "the sweep is housekeeping, not output");
|
|
for (let i = 0; i < 20 && files.some((f) => fs.existsSync(f)); i++) await new Promise((r) => setTimeout(r, 100));
|
|
assert.deepEqual(files.filter((f) => fs.existsSync(f)), []);
|
|
});
|
|
|
|
test("open prints the terminal line; post and wait leave it out until it changes; the collected result on disk does not carry it", async () => {
|
|
const res = cli(["open", "--file", payload("tl.json", BASE), "--no-open"]);
|
|
const s = sessionUrl(res.json.url);
|
|
try {
|
|
const posted = cli(["post", "--session", res.json.sid, "--file", payload("tl2.json", { agent: { status: "waiting" } })]);
|
|
assert.equal(res.json.terminalLine, terminalLine(res.json.url));
|
|
assert.equal("terminalLine" in posted.json, false, "unchanged, so not repeated");
|
|
|
|
const waiting = cli(["wait", "--session", res.json.sid, "--seconds", "5"]);
|
|
assert.equal(waiting.status, 10);
|
|
assert.deepEqual(waiting.json, { waiting: true, open: 1 });
|
|
|
|
const sent = await fetch(`${s.base}/submit`, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie: s.cookie, connection: "close" },
|
|
body: JSON.stringify({ actions: [{ i: "q1", type: "answer", kind: "choice", k: "A" }], reply: "Export format: a" }),
|
|
});
|
|
assert.equal(sent.status, 200);
|
|
const done = cli(["wait", "--session", res.json.sid, "--seconds", "10"]);
|
|
assert.equal(done.status, 0);
|
|
assert.equal("terminalLine" in done.json, false);
|
|
assert.equal(done.json.reply, "Export format: a");
|
|
const onDisk = JSON.parse(fs.readFileSync(path.join(res.json.session, "result.json"), "utf8"));
|
|
assert.equal("terminalLine" in onDisk, false);
|
|
assert.ok(onDisk.consumedAt);
|
|
|
|
const js = await fetch(`${s.base}/labels.js`, { headers: { cookie: s.cookie, connection: "close" } });
|
|
assert.equal(js.status, 200);
|
|
assert.match(js.headers.get("content-type"), /javascript/);
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("notes/quick-task.md has a quick-task build tick the Plan tab's steps live", () => {
|
|
const md = fs.readFileSync(path.join(ROOT, "src", "web-console", "notes", "quick-task.md"), "utf8");
|
|
const section = md;
|
|
assert.ok(!section.includes('"title":"Build progress"'), "no separate progress tab");
|
|
assert.match(section, /After each step/);
|
|
assert.ok(section.includes('{"id":"steps","state":"settled","md":"## Steps\\n\\n- [ ] **1.**'), "the plan's Steps start as a checklist");
|
|
assert.ok(section.includes('"docs":[{"id":"plan","blocks":[{"id":"steps"'), "a step post reposts the plan's steps block, its version moving by itself");
|
|
assert.ok(section.includes("- [x] **1.** Step one"));
|
|
});
|
|
|
|
test("notes/quick-task.md has the finished quick task offer Back to the dashboard as well as the review", () => {
|
|
const md = fs.readFileSync(path.join(ROOT, "src", "web-console", "notes", "quick-task.md"), "utf8");
|
|
const bullet = md.slice(md.indexOf("**Finish after the build:**"), md.indexOf("**Escalated / aborted:**"));
|
|
assert.ok(bullet.includes('"dashboard":true'));
|
|
assert.ok(bullet.includes("Review it now"));
|
|
});
|
|
|
|
// Show me it working: a screenshot saved under <session>/shots/ posts as an
|
|
// image block and is served back; nothing else is reachable through /shots/.
|
|
test("an image block under the session's shots folder round-trips, and /shots/ serves nothing else", async () => {
|
|
const res = cli(["open", "--workflow", "implement", "--no-open"]);
|
|
const m = res.json.url.match(/^(http:\/\/127\.0\.0\.1:\d+)\/s\/([^/]+)\//);
|
|
const cookie = cookieFor(m[1], m[2]);
|
|
try {
|
|
const shots = path.join(res.json.session, "shots");
|
|
fs.mkdirSync(shots, { recursive: true });
|
|
const png = Buffer.concat([Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]), Buffer.alloc(32, 7)]);
|
|
fs.writeFileSync(path.join(shots, "home-page.png"), png);
|
|
const patch = { docs: [{ id: "shown", title: "Shown working", blocks: [{ id: "s1", image: "shots/home-page.png", alt: "The home page with the new button" }] }] };
|
|
cli(["post", "--session", res.json.sid, "--file", payload("shots-ok.json", patch)]);
|
|
const block = readState(res.json.session).docs.find((d) => d.id === "shown").blocks[0];
|
|
assert.equal(block.image, "shots/home-page.png", "stored session-relative");
|
|
assert.equal(block.md, undefined);
|
|
|
|
// Its alt text is a caption, held to the same vocabulary rule as a title.
|
|
const jargon = { docs: [{ id: "shown", blocks: [{ id: "s1", image: "shots/home-page.png", alt: "Grilling the home page" }] }] };
|
|
const refused = cli(["post", "--session", res.json.sid, "--file", payload("shots-jargon.json", jargon)], { expectFail: true });
|
|
assert.equal(refused.status, 3);
|
|
assert.match(refused.stderr, /alt: contains internal vocabulary/);
|
|
// A changed picture or caption is a new version of the doc.
|
|
const before = readState(res.json.session).docs.find((d) => d.id === "shown").version;
|
|
const recaption = { docs: [{ id: "shown", blocks: [{ id: "s1", image: "shots/home-page.png", alt: "The home page, after the fix" }] }] };
|
|
cli(["post", "--session", res.json.sid, "--file", payload("shots-recaption.json", recaption)]);
|
|
assert.equal(readState(res.json.session).docs.find((d) => d.id === "shown").version, before + 1);
|
|
|
|
const got = await fetch(m[1] + "/shots/home-page.png", { headers: { cookie } });
|
|
assert.equal(got.status, 200);
|
|
assert.equal(got.headers.get("content-type"), "image/png");
|
|
assert.equal(got.headers.get("cache-control"), "no-store");
|
|
assert.deepEqual(Buffer.from(await got.arrayBuffer()), png);
|
|
|
|
const anon = await fetch(m[1] + "/shots/home-page.png");
|
|
assert.equal(anon.status, 403, "the cookie is still required");
|
|
await anon.arrayBuffer();
|
|
|
|
// Raw request lines: fetch would fold the `..` away before sending.
|
|
const raw = (p) =>
|
|
new Promise((resolve, reject) => {
|
|
const req = http.request({ host: "127.0.0.1", port: Number(new URL(m[1]).port), path: p, headers: { cookie } }, (r) => {
|
|
r.resume();
|
|
r.on("end", () => resolve(r.statusCode));
|
|
});
|
|
req.on("error", reject);
|
|
req.end();
|
|
});
|
|
for (const p of ["/shots/../state.json", "/shots/..%2fstate.json", "/shots/missing.png", "/shots/home-page.png?x=1"]) {
|
|
assert.equal(await raw(p), 404, p);
|
|
}
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// The Changes tab: a `diff` block names a .diff file saved directly in the
|
|
// session folder (changes.mjs diff). The server reads it like a file block,
|
|
// keeps the name and the text on the block and never lets it reach outside.
|
|
test("a diff block reads a .diff file in the session folder, refreshes and turns back into text", () => {
|
|
const res = cli(["open", "--workflow", "implement", "--no-open"]);
|
|
const sid = res.json.sid;
|
|
const dir = res.json.session;
|
|
const post = (name, patch, opts) => cli(["post", "--session", sid, "--file", payload(name, patch)], opts);
|
|
const doc = () => readState(dir).docs.find((d) => d.id === "changes");
|
|
try {
|
|
const first = "diff --git a/a.txt b/a.txt\n--- a/a.txt\n+++ b/a.txt\n@@ -1 +1 @@\n-old\n+new TASK_COMPLETE\n";
|
|
fs.writeFileSync(path.join(dir, "changes.diff"), first);
|
|
post("diff-ok.json", { docs: [{ id: "changes", title: "Changes", blocks: [{ id: "c1", diff: "changes.diff" }] }] });
|
|
const block = doc().blocks[0];
|
|
assert.equal(block.diff, "changes.diff");
|
|
assert.equal(block.text, first, "the file's text, loop markers in a diff are not the agent's words");
|
|
assert.equal(block.md, undefined, "a diff block holds no markdown");
|
|
assert.equal(block.state, "settled");
|
|
|
|
// The same file again is not a new version; a changed one is, re-sent or refreshed.
|
|
const v1 = doc().version;
|
|
post("diff-same.json", { docs: [{ id: "changes", blocks: [{ id: "c1", diff: "changes.diff" }] }] });
|
|
assert.equal(doc().version, v1);
|
|
const second = first + "+more\n";
|
|
fs.writeFileSync(path.join(dir, "changes.diff"), second);
|
|
post("diff-resend.json", { docs: [{ id: "changes", blocks: [{ id: "c1", diff: "changes.diff" }] }] });
|
|
assert.equal(doc().blocks[0].text, second);
|
|
assert.equal(doc().version, v1 + 1);
|
|
const third = second + "+again\n";
|
|
fs.writeFileSync(path.join(dir, "changes.diff"), third);
|
|
post("diff-refresh.json", { docs: [{ id: "changes", refresh: true }] });
|
|
assert.equal(doc().blocks[0].text, third);
|
|
assert.equal(doc().version, v1 + 2);
|
|
|
|
// An empty file is the page's empty state, not an error.
|
|
fs.writeFileSync(path.join(dir, "changes.diff"), "");
|
|
post("diff-empty.json", { docs: [{ id: "changes", refresh: true }] });
|
|
assert.equal(doc().blocks[0].text, "");
|
|
|
|
// A diff block cannot carry other content.
|
|
const both = post("diff-md.json", { docs: [{ id: "changes", blocks: [{ id: "c2", diff: "changes.diff", md: "text" }] }] }, { expectFail: true });
|
|
assert.equal(both.status, 3);
|
|
assert.match(both.stderr, /cannot also carry "md", "file" or "image"/);
|
|
|
|
// Text over it: the block stops being a diff and a refresh no longer reads it.
|
|
post("diff-to-md.json", { docs: [{ id: "changes", blocks: [{ id: "c1", md: "Plain words." }] }] });
|
|
assert.equal(doc().blocks[0].diff, undefined);
|
|
assert.equal(doc().blocks[0].text, undefined);
|
|
assert.equal(doc().blocks[0].md, "Plain words.");
|
|
const none = post("diff-none.json", { docs: [{ id: "changes", refresh: true }] }, { expectFail: true });
|
|
assert.match(none.stderr, /found no file or diff blocks to re-read/);
|
|
} finally {
|
|
cli(["stop", "--session", sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// When the changes could not be read, the agent sends the plain reason as the
|
|
// block's `error` instead of a diff; a diff sent later replaces it.
|
|
test("a diff block may carry one line of error instead of a diff, never both", () => {
|
|
const res = cli(["open", "--workflow", "implement", "--no-open"]);
|
|
const sid = res.json.sid;
|
|
const dir = res.json.session;
|
|
const post = (name, patch, opts) => cli(["post", "--session", sid, "--file", payload(name, patch)], opts);
|
|
const block = () => readState(dir).docs.find((d) => d.id === "changes").blocks[0];
|
|
try {
|
|
post("err-ok.json", { docs: [{ id: "changes", title: "Changes", blocks: [{ id: "c1", error: " No snapshot was taken at the start of this run. " }] }] });
|
|
assert.equal(block().error, "No snapshot was taken at the start of this run.");
|
|
assert.equal(block().diff, undefined);
|
|
assert.equal(block().text, undefined);
|
|
assert.equal(block().state, "settled");
|
|
|
|
for (const [name, b, why] of [
|
|
["err-both.json", { id: "c1", diff: "changes.diff", error: "x" }, /carries "diff" or "error", never both/],
|
|
["err-md.json", { id: "c1", error: "x", md: "text" }, /an error block cannot also carry "md", "file" or "image"/],
|
|
["err-lines.json", { id: "c1", error: "one\ntwo" }, /must be one line of prose/],
|
|
["err-blank.json", { id: "c1", error: " " }, /must be one line of prose/],
|
|
["err-type.json", { id: "c1", error: 3 }, /must be one line of prose/],
|
|
]) {
|
|
fs.writeFileSync(path.join(dir, "changes.diff"), "diff --git a/a b/a\n");
|
|
const r = post(name, { docs: [{ id: "changes", blocks: [b] }] }, { expectFail: true });
|
|
assert.equal(r.status, 3, name);
|
|
assert.match(r.stderr, why, name);
|
|
}
|
|
|
|
// A diff over it clears the error, and an error over a diff clears the text.
|
|
const text = "diff --git a/a.txt b/a.txt\n--- a/a.txt\n+++ b/a.txt\n@@ -1 +1 @@\n-old\n+new\n";
|
|
fs.writeFileSync(path.join(dir, "changes.diff"), text);
|
|
post("err-to-diff.json", { docs: [{ id: "changes", blocks: [{ id: "c1", diff: "changes.diff" }] }] });
|
|
assert.equal(block().text, text);
|
|
assert.equal(block().error, undefined);
|
|
post("diff-to-err.json", { docs: [{ id: "changes", blocks: [{ id: "c1", error: "The snapshot is gone." }] }] });
|
|
assert.equal(block().error, "The snapshot is gone.");
|
|
assert.equal(block().diff, undefined);
|
|
assert.equal(block().text, undefined);
|
|
} finally {
|
|
cli(["stop", "--session", sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
test("a diff block refuses a path, a wrong extension, a missing file and a link out of the session folder", () => {
|
|
const res = cli(["open", "--workflow", "implement", "--no-open"]);
|
|
const sid = res.json.sid;
|
|
const dir = res.json.session;
|
|
const outside = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-diff-outside-"));
|
|
const post = (name, diff) => cli(["post", "--session", sid, "--file", payload(name, { docs: [{ id: "changes", blocks: [{ id: "c1", diff }] }] })], { expectFail: true });
|
|
try {
|
|
fs.mkdirSync(path.join(dir, "sub"), { recursive: true });
|
|
fs.writeFileSync(path.join(dir, "sub", "changes.diff"), "x\n");
|
|
fs.writeFileSync(path.join(dir, "notes.txt"), "x\n");
|
|
fs.writeFileSync(path.join(outside, "secret.diff"), "x\n");
|
|
const cases = [
|
|
["sub/changes.diff", /needs a plain name/],
|
|
["sub\\changes.diff", /needs a plain name/],
|
|
["../changes.diff", /needs a plain name/],
|
|
[path.join(outside, "secret.diff"), /needs a plain name/],
|
|
["notes.txt", /needs a plain name/],
|
|
["missing.diff", /does not exist in the session folder. Run changes.mjs diff first/],
|
|
];
|
|
for (const [name, message] of cases) {
|
|
const r = post("diff-bad.json", name);
|
|
assert.equal(r.status, 3, name);
|
|
assert.match(r.stderr, message, name);
|
|
}
|
|
try {
|
|
fs.symlinkSync(path.join(outside, "secret.diff"), path.join(dir, "link.diff"), "file");
|
|
} catch {
|
|
console.log("skipped the link case: this platform cannot create a symbolic link here");
|
|
return;
|
|
}
|
|
const linked = post("diff-link.json", "link.diff");
|
|
assert.equal(linked.status, 3);
|
|
assert.match(linked.stderr, /is outside the session folder/);
|
|
} finally {
|
|
cli(["stop", "--session", sid, "--force"]);
|
|
fs.rmSync(outside, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("a diff file over 512 KB is cut at a whole line with the too-large line, never an error", () => {
|
|
const res = cli(["open", "--workflow", "implement", "--no-open"]);
|
|
const sid = res.json.sid;
|
|
const dir = res.json.session;
|
|
try {
|
|
const line = "+" + "x".repeat(99) + "\n";
|
|
fs.writeFileSync(path.join(dir, "big.diff"), line.repeat(Math.ceil((600 * 1024) / line.length)));
|
|
cli(["post", "--session", sid, "--file", payload("diff-big.json", { docs: [{ id: "changes", blocks: [{ id: "c1", diff: "big.diff" }] }] })]);
|
|
const text = readState(dir).docs.find((d) => d.id === "changes").blocks[0].text;
|
|
const notice = "\\ No more lines shown: this change is too large to show in full.\n";
|
|
assert.ok(text.endsWith(notice), "ends with the plain line");
|
|
const kept = text.slice(0, -notice.length);
|
|
assert.ok(Buffer.byteLength(kept) <= 512 * 1024, "within the cap");
|
|
assert.ok(kept.endsWith("\n") && kept.split("\n").every((l) => l === "" || l === line.trimEnd()), "only whole lines");
|
|
// A file changes.mjs already cut, and that carries the line, does not get a second one.
|
|
fs.writeFileSync(path.join(dir, "cut.diff"), "diff --git a/a b/a\n" + notice);
|
|
cli(["post", "--session", sid, "--file", payload("diff-cut.json", { docs: [{ id: "changes", blocks: [{ id: "c1", diff: "cut.diff" }] }] })]);
|
|
assert.equal(readState(dir).docs.find((d) => d.id === "changes").blocks[0].text.split(notice).length, 2);
|
|
} finally {
|
|
cli(["stop", "--session", sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// The server and changes.mjs each spell the too-large line: they must match.
|
|
test("the too-large line the server adds is the one changes.mjs adds", async () => {
|
|
const { capPatch } = await import("../src/skill-scripts/changes.mjs");
|
|
const { DIFF_TOO_LARGE } = await import("../src/web-console/patches.mjs");
|
|
const patch = "diff --git a/a b/a\n" + "+x\n".repeat(50) + "diff --git a/b b/b\n" + "+y\n".repeat(50);
|
|
const cut = capPatch(patch, 200);
|
|
assert.equal(cut.truncated, true);
|
|
assert.ok(cut.patch.includes(DIFF_TOO_LARGE + "\n"));
|
|
});
|
|
|
|
// /app.css is the files under public/styles/ joined in CSS_ORDER (one newline
|
|
// after each), then the accent rules. The files themselves are never served.
|
|
test("/app.css is the style files joined in CSS_ORDER with the accent rules last", async () => {
|
|
const { CSS_ORDER, asset, etagOf } = await import("../src/web-console/static.mjs");
|
|
const dir = path.join(ROOT, "src", "web-console", "public", "styles");
|
|
const res = cli(["open", "--workflow", "review", "--no-open"]);
|
|
const m = res.json.url.match(/^(http:\/\/127\.0\.0\.1:\d+)\/s\/([^/]+)\//);
|
|
const cookie = cookieFor(m[1], m[2]);
|
|
try {
|
|
const r = await fetch(m[1] + "/app.css", { headers: { cookie } });
|
|
assert.equal(r.status, 200);
|
|
assert.match(r.headers.get("content-type"), /^text\/css/);
|
|
const body = await r.text();
|
|
// One newline between files: each file's own last newline is that one.
|
|
const joined = CSS_ORDER.map((f) => fs.readFileSync(path.join(dir, f), "utf8").replace(/\n$/, "")).join("\n") + "\n";
|
|
assert.ok(body.startsWith(joined), "the body opens with the files, in CSS_ORDER, one newline between");
|
|
const accents = body.slice(joined.length);
|
|
assert.match(accents, /^\n*\/\* Generated by server\.mjs from palette\.js/, "the accent rules come last");
|
|
assert.ok(accents.includes(`:root[data-looks-accent="violet"]`));
|
|
// The tests' helper joins through the server's own function, so the two agree.
|
|
assert.equal(body, joinedCss() + accents, "joinedCss() plus the accent rules is the body the server returns");
|
|
// The ETag is a hash of the whole body, so a change to any one file moves it.
|
|
assert.equal(r.headers.get("etag"), etagOf(Buffer.from(body)));
|
|
assert.equal(asset("app.css").etag, etagOf(Buffer.from(body)));
|
|
for (const f of CSS_ORDER) {
|
|
const text = fs.readFileSync(path.join(dir, f), "utf8").replace(/\n$/, "");
|
|
assert.notEqual(etagOf(Buffer.from(body.replace(text, text + "\n/* changed */"))), r.headers.get("etag"), `a change to ${f} moves the ETag`);
|
|
}
|
|
for (const f of CSS_ORDER) {
|
|
const own = await fetch(m[1] + "/styles/" + f, { headers: { cookie } });
|
|
assert.equal(own.status, 404, `/styles/${f} is not served on its own`);
|
|
await own.arrayBuffer();
|
|
}
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// The skills the build writes carry public/styles/ with every file in CSS_ORDER,
|
|
// and a console started from that tree serves the same /app.css as this one.
|
|
test("the built shared console serves the same /app.css as the source console", async (t) => {
|
|
const { CSS_ORDER, asset } = await import("../src/web-console/static.mjs");
|
|
// The console is built once, as skills/_console/<version>/, and every skill forwards to it.
|
|
const version = JSON.parse(fs.readFileSync(path.join(ROOT, "version.json"), "utf8")).version;
|
|
const built = path.join(ROOT, "skills", "_console", version);
|
|
// npm test builds first; a bare run of this file may not have.
|
|
if (!fs.existsSync(path.join(built, "console.mjs"))) return t.skip("skills/ is not built: run npm run build:skills");
|
|
for (const f of CSS_ORDER) assert.ok(fs.existsSync(path.join(built, "public", "styles", f)), `the build is missing public/styles/${f}`);
|
|
const out = execFileSync(process.execPath, [path.join(built, "console.mjs"), "open", "--workflow", "review", "--no-open"], { env: ENV, encoding: "utf8", cwd: ROOT });
|
|
const json = JSON.parse(out.trim().split("\n").pop());
|
|
const m = json.url.match(/^(http:\/\/127\.0\.0\.1:\d+)\/s\/([^/]+)\//);
|
|
try {
|
|
const res = await fetch(m[1] + "/app.css", { headers: { cookie: cookieFor(m[1], m[2]) } });
|
|
assert.equal(res.status, 200);
|
|
assert.equal(await res.text(), asset("app.css").body.toString("utf8"));
|
|
} finally {
|
|
execFileSync(process.execPath, [path.join(built, "console.mjs"), "stop", "--session", json.sid, "--force"], { env: ENV, cwd: ROOT });
|
|
}
|
|
});
|
|
|
|
// The desktop app's webview opens no new windows, so a link the page shows
|
|
// there goes through /open-link, which hands it to the default browser. Only
|
|
// http and https: anything else would be the page asking the machine to run
|
|
// whatever a link names.
|
|
test("/open-link takes an http or https link and refuses every other kind", async () => {
|
|
const res = cli(["open", "--workflow", "git", "--no-open"]);
|
|
const m = res.json.url.match(/^(http:\/\/127\.0\.0\.1:\d+)\/s\/([^/]+)\//);
|
|
const cookie = cookieFor(m[1], m[2]);
|
|
const open = (url) =>
|
|
fetch(`${m[1]}/open-link`, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie, origin: m[1], connection: "close" },
|
|
body: JSON.stringify({ url }),
|
|
});
|
|
try {
|
|
const ok = await open("https://github.com/jparkerweb/plan2code/compare/main...feature?expand=1");
|
|
assert.equal(ok.status, 200);
|
|
assert.deepEqual(await ok.json(), { ok: true, url: "https://github.com/jparkerweb/plan2code/compare/main...feature?expand=1" });
|
|
for (const bad of ["javascript:alert(1)", "file:///C:/Windows/System32/calc.exe", "ms-settings:", "not a link", "", 42]) {
|
|
const no = await open(bad);
|
|
assert.equal(no.status, 400, `${JSON.stringify(bad)} was not refused`);
|
|
}
|
|
const foreign = await fetch(`${m[1]}/open-link`, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie, origin: "https://evil.example", connection: "close" },
|
|
body: JSON.stringify({ url: "https://example.com/" }),
|
|
});
|
|
assert.notEqual(foreign.status, 200, "another site's page cannot open links through the console");
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
/* ------------------------- first-run agent setup (the setup workflow) ------------------------- */
|
|
|
|
// `open --workflow setup` is the agent-less page the launcher opens when no agent
|
|
// can run: the session state carries the hand-over the launcher's agent posts
|
|
// back to /handover, and `open` prints it for the launcher to read.
|
|
test("open --workflow setup records the hand-over data and prints it, and a plain resume keeps its token", () => {
|
|
const res = cli(["open", "--workflow", "setup", "--for-cli", "devin", "--no-open"], { env: NO_APP });
|
|
try {
|
|
const state = readState(res.json.session);
|
|
assert.equal(state.workflow, "setup");
|
|
assert.equal(state.setup.forCli, "devin");
|
|
assert.match(state.setup.token, /^[A-Za-z0-9_-]{10,}$/);
|
|
assert.ok(state.setup.created);
|
|
assert.deepEqual(res.json.setup, { url: res.json.url, token: state.setup.token });
|
|
assert.match(res.json.setup.url, /\/s\/[A-Za-z0-9_-]+\/$/, "the page's own sign-in link");
|
|
|
|
cli(["open", "--resume", res.json.sid, "--workflow", "setup", "--no-open"], { env: NO_APP });
|
|
assert.equal(readState(res.json.session).setup.token, state.setup.token, "a plain resume keeps the token the launcher's agent holds");
|
|
|
|
// A resume naming --for-cli is a new hand-over: a fresh token and target.
|
|
const retarget = cli(["open", "--resume", res.json.sid, "--workflow", "setup", "--for-cli", "codex", "--no-open"], { env: NO_APP });
|
|
const now = readState(res.json.session).setup;
|
|
assert.equal(now.forCli, "codex");
|
|
assert.notEqual(now.token, state.setup.token);
|
|
assert.equal(retarget.json.setup.token, now.token);
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// The shipped and custom agent lists the setup page shows. Commands carry .cmd
|
|
// so one file name is found on every OS. The env points npm's global folder at
|
|
// a fixture dir and kills the saved PATH: a builtin goes "outside" through its
|
|
// installDirs, a custom agent through the npm folder (agentsGet looks custom
|
|
// commands up by name only, so installDirs never applies to them).
|
|
const NO_APP = {
|
|
PLAN2CODE_IN_APP: undefined,
|
|
PLAN2CODE_APP_TOKEN: undefined,
|
|
PLAN2CODE_APP_ANNOUNCE: undefined,
|
|
PLAN2CODE_EMBED_ORIGIN: undefined,
|
|
PLAN2CODE_CONSOLE_SID: undefined,
|
|
PLAN2CODE_APP_VERSION: undefined,
|
|
};
|
|
|
|
function agentFixtures(base) {
|
|
const outside = path.join(base, "outside");
|
|
fs.mkdirSync(outside);
|
|
fs.writeFileSync(path.join(outside, "testagent.cmd"), "@rem stand-in\r\n");
|
|
const onPath = path.join(base, "onpath.cmd");
|
|
fs.writeFileSync(onPath, "@rem stand-in\r\n");
|
|
// npm's global bin: the prefix itself on Windows, <prefix>/bin elsewhere.
|
|
const npmBin = process.platform === "win32" ? path.join(base, "npm-prefix") : path.join(base, "npm-prefix", "bin");
|
|
fs.mkdirSync(npmBin, { recursive: true });
|
|
const inNpm = path.join(npmBin, "agenttwo.cmd");
|
|
fs.writeFileSync(inNpm, "@rem stand-in\r\n");
|
|
|
|
const shipped = {
|
|
schema: 1,
|
|
agents: [
|
|
{
|
|
id: "testagent",
|
|
name: "Test Agent",
|
|
kind: "builtin",
|
|
command: "testagent.cmd",
|
|
prompt: "/plan2code",
|
|
args: ["{prompt}"],
|
|
bypassArgs: ["--yes"],
|
|
modelArgs: ["--model", "{model}"],
|
|
installUrl: "https://example.com/get",
|
|
install: {
|
|
win: [{ label: "PowerShell", run: "irm x | iex", note: "n" }],
|
|
mac: [{ label: "Terminal", run: "curl x" }],
|
|
linux: [],
|
|
},
|
|
installDirs: { win: [outside], mac: [outside], linux: [outside] },
|
|
},
|
|
{ id: "gone", name: "Gone Agent", kind: "builtin", command: "gone-agent-xyz.cmd" },
|
|
{ id: "templ", name: "Templ", kind: "template", command: "templ", prompt: "Use plan2code", args: ["{prompt}"], note: "a starter" },
|
|
],
|
|
};
|
|
const user = {
|
|
schema: 1,
|
|
agents: [
|
|
{ id: "myagent", name: "My Agent", command: onPath },
|
|
{ id: "agenttwo", name: "Agent Two", command: "agenttwo.cmd" },
|
|
],
|
|
};
|
|
const shippedFile = path.join(MODELS_DIR, "bin", "agents.json");
|
|
const userFile = path.join(MODELS_DIR, "agents.json");
|
|
fs.mkdirSync(path.dirname(shippedFile), { recursive: true });
|
|
fs.writeFileSync(shippedFile, JSON.stringify(shipped));
|
|
fs.writeFileSync(userFile, JSON.stringify(user));
|
|
return { outside, onPath, inNpm, shipped, shippedFile, userFile };
|
|
}
|
|
|
|
const AGENT_ENV = (base) => ({ PLAN2CODE_NO_SAVED_PATH: "1", npm_config_prefix: path.join(base, "npm-prefix"), ...NO_APP });
|
|
|
|
test("GET /agents reports found, outside and missing for the custom and shipped lists", async () => {
|
|
const base = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-agents-"));
|
|
const res = cli(["open", "--workflow", "setup", "--no-open"], { env: AGENT_ENV(base) });
|
|
try {
|
|
const f = agentFixtures(base);
|
|
const { base: url, cookie } = sessionUrl(res.json.url);
|
|
const got = await (await fetch(`${url}/agents`, { headers: { cookie, connection: "close" } })).json();
|
|
|
|
const mine = got.agents.find((a) => a.id === "myagent");
|
|
assert.deepEqual(
|
|
{ state: mine.state, path: mine.path, where: mine.where, folder: mine.folder },
|
|
{ state: "found", path: f.onPath, where: "path", folder: path.dirname(f.onPath) }
|
|
);
|
|
const two = got.agents.find((a) => a.id === "agenttwo");
|
|
assert.deepEqual({ state: two.state, path: two.path, where: two.where }, { state: "outside", path: f.inNpm, where: "npm" });
|
|
|
|
const testagent = got.builtins.find((b) => b.id === "testagent");
|
|
assert.deepEqual({ state: testagent.state, where: testagent.where }, { state: "outside", where: "install-dir" });
|
|
assert.equal(testagent.name, "Test Agent");
|
|
assert.equal(testagent.command, "testagent.cmd");
|
|
assert.equal(testagent.prompt, "/plan2code");
|
|
assert.deepEqual(testagent.args, ["{prompt}"]);
|
|
assert.deepEqual(testagent.bypassArgs, ["--yes"]);
|
|
assert.deepEqual(testagent.modelArgs, ["--model", "{model}"]);
|
|
assert.equal(testagent.installUrl, "https://example.com/get");
|
|
const OS_KEY = process.platform === "win32" ? "win" : process.platform === "darwin" ? "mac" : "linux";
|
|
assert.deepEqual(testagent.install, f.shipped.agents[0].install[OS_KEY], "only this OS's install steps");
|
|
|
|
const gone = got.builtins.find((b) => b.id === "gone");
|
|
assert.deepEqual(
|
|
{ state: gone.state, path: gone.path, where: gone.where, folder: gone.folder },
|
|
{ state: "missing", path: null, where: null, folder: null }
|
|
);
|
|
// Templates come back as the form fields only: no `kind`, no found state.
|
|
assert.deepEqual(got.templates, [{ id: "templ", name: "Templ", command: "templ", prompt: "Use plan2code", args: ["{prompt}"], note: "a starter" }]);
|
|
assert.deepEqual(got.warnings, []);
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
fs.rmSync(path.join(MODELS_DIR, "agents.json"), { force: true });
|
|
fs.rmSync(path.join(MODELS_DIR, "bin", "agents.json"), { force: true });
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("POST /agents/use-path writes findAgent's hit into agents.json, and only that", async () => {
|
|
const base = fs.mkdtempSync(path.join(os.tmpdir(), "p2c-agents-"));
|
|
const res = cli(["open", "--workflow", "setup", "--no-open"], { env: AGENT_ENV(base) });
|
|
try {
|
|
const f = agentFixtures(base);
|
|
const { base: url, cookie } = sessionUrl(res.json.url);
|
|
const usePath = (body) =>
|
|
fetch(`${url}/agents/use-path`, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", cookie, origin: url, connection: "close" },
|
|
body: JSON.stringify(body),
|
|
});
|
|
const readUser = () => JSON.parse(fs.readFileSync(f.userFile, "utf8"));
|
|
|
|
const missing = await usePath({ id: "gone" });
|
|
assert.equal(missing.status, 409, "not on PATH and nowhere else either");
|
|
assert.deepEqual(await missing.json(), { error: "not-found" });
|
|
const unknown = await usePath({ id: "nope" });
|
|
assert.equal(unknown.status, 404, "no such agent at all");
|
|
assert.deepEqual(await unknown.json(), { error: "not-found" });
|
|
|
|
// Already on PATH: a 200 and no write.
|
|
const before = fs.readFileSync(f.userFile, "utf8");
|
|
const found = await usePath({ id: "myagent" });
|
|
assert.equal(found.status, 200);
|
|
assert.deepEqual(await found.json(), { ok: true, id: "myagent", command: f.onPath });
|
|
assert.equal(fs.readFileSync(f.userFile, "utf8"), before);
|
|
|
|
// Off PATH ("outside"): the command becomes where it was found. A path in
|
|
// the body is never taken.
|
|
const outside = await usePath({ id: "agenttwo", command: "should-not-be-taken", path: "should-not-be-taken" });
|
|
assert.equal(outside.status, 200);
|
|
const wanted = f.inNpm;
|
|
assert.deepEqual(await outside.json(), { ok: true, id: "agenttwo", command: wanted });
|
|
assert.equal(readUser().agents.find((a) => a.id === "agenttwo").command, wanted);
|
|
|
|
// A built-in is materialized as a new custom entry under a generated id;
|
|
// the file's other entries stand.
|
|
const builtin = await usePath({ id: "testagent" });
|
|
assert.equal(builtin.status, 200);
|
|
const saved = await builtin.json();
|
|
assert.equal(saved.id, "test-agent", "makeId kebab-cases the name");
|
|
const created = readUser().agents.find((a) => a.id === "test-agent");
|
|
assert.equal(created.command, path.join(f.outside, "testagent.cmd"));
|
|
assert.equal(created.name, "Test Agent");
|
|
assert.equal(created.prompt, "/plan2code");
|
|
assert.equal(readUser().schema, 1);
|
|
assert.deepEqual(readUser().agents.map((a) => a.id), ["myagent", "agenttwo", "test-agent"]);
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
fs.rmSync(path.join(MODELS_DIR, "agents.json"), { force: true });
|
|
fs.rmSync(path.join(MODELS_DIR, "bin", "agents.json"), { force: true });
|
|
fs.rmSync(base, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
// The setup tab's move: another Plan2Code process POSTs the session's sign-in
|
|
// link here, the page's stream gets a `move` event and state.setup.moved is
|
|
// set. Only a setup session answers, only for the token `open` printed, and
|
|
// only a loopback console /s/ link is a legal destination.
|
|
test("POST /handover takes only the setup token and a console sign-in link, and moves the page", async () => {
|
|
const res = cli(["open", "--workflow", "setup", "--no-open"], { env: NO_APP });
|
|
const m = res.json.url.match(/^(http:\/\/127\.0\.0\.1:(\d+))\/s\/([^/]+)\//);
|
|
const cookie = cookieFor(m[1], m[3]);
|
|
const port = Number(m[2]);
|
|
const token = res.json.setup.token;
|
|
const handover = (body, headers = {}) =>
|
|
new Promise((resolve, reject) => {
|
|
const req = http.request(
|
|
{
|
|
host: "127.0.0.1",
|
|
port,
|
|
path: "/handover",
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", "x-plan2code-token": token, connection: "close", ...headers },
|
|
},
|
|
(r) => {
|
|
const chunks = [];
|
|
r.on("data", (c) => chunks.push(c));
|
|
r.on("end", () => resolve({ status: r.statusCode, body: Buffer.concat(chunks).toString("utf8") }));
|
|
}
|
|
);
|
|
req.on("error", reject);
|
|
req.end(JSON.stringify(body));
|
|
});
|
|
const other = cli(["open", "--workflow", "plan", "--no-open"], { env: NO_APP });
|
|
try {
|
|
// No cookie at all: the hand-over has its own token, which is the point.
|
|
for (const headers of [{ "x-plan2code-token": "wrong-token" }, { "x-plan2code-token": "" }]) {
|
|
const no = await handover({ url: "http://127.0.0.1:9/s/abc/" }, headers);
|
|
assert.equal(no.status, 403, JSON.stringify(headers));
|
|
assert.deepEqual(JSON.parse(no.body), { error: "forbidden" });
|
|
}
|
|
for (const url of [
|
|
"https://127.0.0.1:9/s/abc/",
|
|
"http://example.com/s/abc/",
|
|
"http://127.0.0.1/s/abc/",
|
|
"http://127.0.0.1:9/x/abc/",
|
|
"http://127.0.0.1:9/s/a b/",
|
|
"javascript:alert(1)",
|
|
"",
|
|
42,
|
|
null,
|
|
]) {
|
|
const no = await handover({ url });
|
|
assert.equal(no.status, 400, JSON.stringify(url));
|
|
assert.deepEqual(JSON.parse(no.body), { error: "bad-url" });
|
|
}
|
|
|
|
// The stream sees the move the POST causes.
|
|
const events = new Promise((resolve, reject) => {
|
|
const req = http.request({ host: "127.0.0.1", port, path: "/events", headers: { cookie } }, (r) => {
|
|
let buf = "";
|
|
r.setEncoding("utf8");
|
|
r.on("data", (c) => (buf += c));
|
|
setTimeout(() => {
|
|
req.destroy();
|
|
resolve(buf);
|
|
}, 1500);
|
|
});
|
|
req.on("error", reject);
|
|
req.end();
|
|
});
|
|
await sleep(150); // the GET must land before the POST
|
|
const target = "http://localhost:9/s/NewAgent_1-2/";
|
|
const ok = await handover({ url: target });
|
|
assert.equal(ok.status, 204);
|
|
const stream = await events;
|
|
assert.ok(stream.includes(`event: move\ndata: ${JSON.stringify({ url: target })}`), stream);
|
|
const setup = readState(res.json.session).setup;
|
|
assert.equal(setup.moved.url, target);
|
|
assert.ok(setup.moved.at);
|
|
|
|
// A session that is not the setup page never answers, whatever the header.
|
|
const otherPort = Number(other.json.url.match(/^http:\/\/127\.0\.0\.1:(\d+)\//)[1]);
|
|
const notSetup = await new Promise((resolve, reject) => {
|
|
const req = http.request(
|
|
{
|
|
host: "127.0.0.1",
|
|
port: otherPort,
|
|
path: "/handover",
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", "x-plan2code-token": token },
|
|
},
|
|
(r) => {
|
|
const chunks = [];
|
|
r.on("data", (c) => chunks.push(c));
|
|
r.on("end", () => resolve({ status: r.statusCode, body: Buffer.concat(chunks).toString("utf8") }));
|
|
}
|
|
);
|
|
req.on("error", reject);
|
|
req.end(JSON.stringify({ url: "http://127.0.0.1:9/s/abc/" }));
|
|
});
|
|
assert.equal(notSetup.status, 404);
|
|
assert.deepEqual(JSON.parse(notSetup.body), { error: "not-found" });
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
cli(["stop", "--session", other.json.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// The other half of the hand-over: an agent opened under PLAN2CODE_SETUP_* posts
|
|
// its link to the setup console's /handover instead of opening a browser, and a
|
|
// refused post falls back to the browser with a note saying so.
|
|
test("an agent opened with the setup hand-over posts its link, and a refused post says so", async () => {
|
|
const setup = cli(["open", "--workflow", "setup", "--no-open"], { env: NO_APP });
|
|
const token = readState(setup.json.session).setup.token;
|
|
let agent;
|
|
try {
|
|
// setup.url is the setup session's own link; /handover resolves off it, so
|
|
// the running server answers. No --no-open: that flag is what skips this.
|
|
agent = cli(["open", "--workflow", "plan"], {
|
|
env: { ...NO_APP, PLAN2CODE_SETUP_ANNOUNCE: setup.json.setup.url, PLAN2CODE_SETUP_TOKEN: token },
|
|
});
|
|
assert.equal(agent.json.handover, true);
|
|
const moved = readState(setup.json.session).setup.moved;
|
|
assert.equal(moved.url, agent.json.url, "the setup session learned where its tab went");
|
|
|
|
const bad = cli(["open", "--workflow", "plan"], {
|
|
env: { ...NO_APP, PLAN2CODE_SETUP_ANNOUNCE: setup.json.setup.url, PLAN2CODE_SETUP_TOKEN: "wrong-token" },
|
|
});
|
|
try {
|
|
assert.equal("handover" in bad.json, false);
|
|
assert.match(bad.json.note, /Could not move the setup tab/);
|
|
} finally {
|
|
cli(["stop", "--session", bad.json.sid, "--force"]);
|
|
}
|
|
} finally {
|
|
if (agent) cli(["stop", "--session", agent.json.sid, "--force"]);
|
|
cli(["stop", "--session", setup.json.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// The idle deadline is the only thing that stops an orphan server (server.mjs's
|
|
// comment says why it must not be optimized away); a setup session honors it too.
|
|
test("a setup session still stops on --idle-ms", async () => {
|
|
const res = cli(["open", "--workflow", "setup", "--idle-ms", "300", "--no-open"], { env: NO_APP });
|
|
try {
|
|
const events = path.join(res.json.session, "events.ndjson");
|
|
// The deadline is checked on a 20s tick, so the exit lands within a tick of the cap.
|
|
const gone = await until(() => fs.existsSync(events) && fs.readFileSync(events, "utf8").includes('"reason":"idle"'), 40000);
|
|
assert.ok(gone, "the server never recorded its idle exit");
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
}
|
|
});
|
|
|
|
// NFR-2: the launcher scrubs the app-window variables before spawning the setup
|
|
// console (test-launcher.mjs has the spawn half), so nothing can leak the page
|
|
// into an app window. Even with an announce URL left in the environment a
|
|
// console without the full signal never calls it; with the signal it does.
|
|
test("a setup console without the app signal never calls a leftover announce URL", async () => {
|
|
const calls = [];
|
|
const stub = http.createServer((req, res) => {
|
|
req.resume();
|
|
req.on("end", () => {
|
|
calls.push(`${req.method} ${req.url}`);
|
|
res.writeHead(req.url === "/session" ? 404 : 204).end();
|
|
});
|
|
});
|
|
await new Promise((r) => stub.listen(0, "127.0.0.1", r));
|
|
const announce = `http://127.0.0.1:${stub.address().port}`;
|
|
try {
|
|
const res = cli(["open", "--workflow", "setup", "--no-open"], { env: { ...NO_APP, PLAN2CODE_APP_ANNOUNCE: announce } });
|
|
try {
|
|
assert.equal(res.json.inApp, undefined);
|
|
assert.equal(res.json.announced, undefined);
|
|
assert.deepEqual(calls, [], "a stray announce URL alone is not the signal");
|
|
} finally {
|
|
cli(["stop", "--session", res.json.sid, "--force"]);
|
|
}
|
|
|
|
// With the full signal the same open announces, as the in-app tests cover.
|
|
// Spawned asynchronously: the announce endpoint lives in this process, so a
|
|
// blocking spawn would deadlock (the same reason test-in-app uses openAsync).
|
|
const inApp = await new Promise((resolve) => {
|
|
const child = spawn(
|
|
process.execPath,
|
|
[path.join(ROOT, "src", "web-console", "console.mjs"), "open", "--workflow", "setup", "--no-open"],
|
|
{
|
|
cwd: ROOT,
|
|
env: { ...ENV, ...NO_APP, PLAN2CODE_IN_APP: "1", PLAN2CODE_APP_ANNOUNCE: announce, PLAN2CODE_APP_TOKEN: "tok" },
|
|
windowsHide: true,
|
|
}
|
|
);
|
|
let out = "";
|
|
child.stdout.on("data", (c) => (out += c));
|
|
child.on("close", (status) => resolve({ status, json: JSON.parse(out.trim().split("\n").filter(Boolean).pop()) }));
|
|
});
|
|
try {
|
|
assert.equal(inApp.json.announced, true);
|
|
assert.ok(calls.some((c) => c.startsWith("POST /page")), JSON.stringify(calls));
|
|
} finally {
|
|
cli(["stop", "--session", inApp.json.sid, "--force"]);
|
|
}
|
|
} finally {
|
|
stub.close();
|
|
}
|
|
});
|