repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
scripts/build/build.test.ts
Rawimport { spawnSync } from "node:child_process";
import { once } from "node:events";
import {
existsSync,
lstatSync,
mkdirSync,
mkdtempSync,
readdirSync,
readFileSync,
rmSync,
writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { basename, dirname, join } from "node:path";
import { pathToFileURL } from "node:url";
import { Worker } from "node:worker_threads";
import { DefaultResourceLoader } from "@earendil-works/pi-coding-agent";
import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
import { buildExtension, ROOT, rootVersion } from "./build.ts";
import { registrationConflicts } from "./conflicts.ts";
import { BUILD_MANIFEST, listFiles, publishPackage } from "./publish.ts";
import { readBuildSpec } from "./spec.ts";
import { forbiddenImports, verifyCollection, verifyPackage } from "./verify.ts";
function temp(prefix: string): string {
return mkdtempSync(join(tmpdir(), prefix));
}
it("installs declared externals using npm with a spaced working directory", async () => {
const root = temp("pi-ext-externals with spaces-");
try {
const dependency = join(root, "external");
const extension = join(root, "extensions", "demo");
mkdirSync(dependency);
mkdirSync(extension, { recursive: true });
writeFileSync(
join(root, "package.json"),
JSON.stringify({ version: "1.0.0" }),
);
writeFileSync(
join(dependency, "package.json"),
JSON.stringify({
name: "pi-ext-build-fixture",
version: "1.2.3",
type: "module",
main: "index.js",
}),
);
writeFileSync(
join(dependency, "index.js"),
"export const evidence = 'external';\n",
);
writeFileSync(
join(extension, "package.json"),
JSON.stringify({
name: "@bugabinga/pi-ext-demo",
type: "module",
main: "index.ts",
dependencies: {
"pi-ext-build-fixture": `file:${dependency.replaceAll("\\", "/")}`,
},
"pi-ext": {
externals: {
"pi-ext-build-fixture": "Local installer regression fixture",
},
},
}),
);
writeFileSync(
join(extension, "index.ts"),
"import { evidence } from 'pi-ext-build-fixture'; export default function () { return evidence; }\n",
);
const built = await buildExtension("demo", { root });
const manifest = JSON.parse(
readFileSync(
join(built.dir, "node_modules", "pi-ext-build-fixture", "package.json"),
"utf8",
),
);
expect(manifest.version).toBe("1.2.3");
expect(
lstatSync(
join(built.dir, "node_modules", "pi-ext-build-fixture"),
).isSymbolicLink(),
).toBe(false);
rmSync(dependency, { recursive: true, force: true });
const consumer = spawnSync(
process.execPath,
[
"--input-type=module",
"-e",
`const extension = await import(${JSON.stringify(pathToFileURL(join(built.dir, "index.ts")).href)}); console.log(extension.default());`,
],
{ encoding: "utf8", timeout: 10_000 },
);
expect(consumer.error).toBeUndefined();
expect(consumer.status, consumer.stderr).toBe(0);
expect(consumer.stdout.trim()).toBe("external");
expect(existsSync(join(root, "dist", ".staging"))).toBe(false);
} finally {
rmSync(root, { recursive: true, force: true });
}
}, 60_000);
it("revalidates stale registry metadata while baking the exact installed external version", async () => {
const root = temp("pi-ext-external-registry-");
const dependency = join(root, "dependency");
const extension = join(root, "extensions", "demo");
const name = "pi-ext-registry-fixture";
const phase = new SharedArrayBuffer(4);
let registry: Worker | undefined;
const npm = (args: string[], cwd: string) => {
const windows = process.platform === "win32";
return spawnSync(
windows ? `npm.cmd ${args.join(" ")}` : "npm",
windows ? [] : args,
{
cwd,
encoding: "utf8",
shell: windows,
timeout: 20_000,
},
);
};
try {
mkdirSync(dependency);
mkdirSync(extension, { recursive: true });
const installed = join(root, "node_modules", name);
mkdirSync(installed, { recursive: true });
const manifest = {
name,
version: "1.2.3",
type: "module",
main: "index.js",
};
writeFileSync(join(dependency, "package.json"), JSON.stringify(manifest));
writeFileSync(
join(dependency, "index.js"),
"export const evidence = 'pinned';\n",
);
writeFileSync(join(installed, "package.json"), JSON.stringify(manifest));
const packed = npm(["pack", "--ignore-scripts", "--json"], dependency);
expect(packed.status, packed.stderr).toBe(0);
const tarball = join(dependency, JSON.parse(packed.stdout)[0].filename);
// A worker keeps serving while the production installer uses spawnSync.
registry = new Worker(
`
const { createServer } = require('node:http');
const { readFileSync } = require('node:fs');
const { parentPort, workerData } = require('node:worker_threads');
const phase = new Int32Array(workerData.phase);
const server = createServer((req, res) => {
if (req.url.endsWith('.tgz')) { res.end(readFileSync(workerData.tarball)); return; }
const version = Atomics.load(phase, 0) ? '1.2.3' : '1.0.0';
const name = workerData.name;
const url = 'http://127.0.0.1:' + server.address().port;
res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'public, max-age=31536000' });
res.end(JSON.stringify({ name, 'dist-tags': { latest: version }, versions: {
[version]: { name, version, dist: { tarball: url + '/fixture.tgz' } }
} }));
});
server.listen(0, '127.0.0.1', () => parentPort.postMessage(server.address().port));
`,
{ eval: true, execArgv: [], workerData: { name, phase, tarball } },
);
const [port] = await once(registry, "message", {
signal: AbortSignal.timeout(5_000),
});
const url = `http://127.0.0.1:${port}`;
for (const key of ["npm_config_registry", "NPM_CONFIG_REGISTRY"])
vi.stubEnv(key, url);
for (const key of ["npm_config_cache", "NPM_CONFIG_CACHE"])
vi.stubEnv(key, join(root, "cache"));
const seeded = npm(["view", name, "version", "--prefer-online"], root);
expect(seeded.status, seeded.stderr).toBe(0);
expect(seeded.stdout.trim()).toBe("1.0.0");
Atomics.store(new Int32Array(phase), 0, 1);
writeFileSync(
join(root, "package.json"),
JSON.stringify({ version: "1.0.0" }),
);
writeFileSync(
join(extension, "package.json"),
JSON.stringify({
name: "@bugabinga/pi-ext-demo",
type: "module",
main: "index.ts",
dependencies: { [name]: "*" },
"pi-ext": {
externals: { [name]: "Registry freshness regression fixture" },
},
}),
);
writeFileSync(
join(extension, "index.ts"),
`import { evidence } from '${name}'; export default () => evidence;\n`,
);
const built = await buildExtension("demo", { root });
expect(
JSON.parse(readFileSync(join(built.dir, "package.json"), "utf8"))
.dependencies[name],
).toBe("1.2.3");
expect(
JSON.parse(
readFileSync(
join(built.dir, "node_modules", name, "package.json"),
"utf8",
),
).version,
).toBe("1.2.3");
} finally {
vi.unstubAllEnvs();
await registry?.terminate();
rmSync(root, { recursive: true, force: true });
}
}, 60_000);
describe("package import validation", () => {
it("allows nested package-private JavaScript chunks but rejects escapes and sources", () => {
const pkg = temp("pi-ext-imports-");
try {
mkdirSync(join(pkg, "src", "nested"), { recursive: true });
mkdirSync(join(pkg, "src", "node_modules", "dependency"), {
recursive: true,
});
writeFileSync(join(pkg, "src", "chunk.js"), "export {};\n");
writeFileSync(
join(pkg, "src", "nested", "entry.js"),
[
'import "../chunk.js";',
'import "./..";',
'import "./../../../escape.js";',
'import "./types.ts";',
'import "unshipped-external";',
].join("\n"),
);
writeFileSync(
join(pkg, "src", "node_modules", "dependency", "index.js"),
'import "../../escape.ts";\n',
);
const forbidden = forbiddenImports(pkg);
expect(forbidden).not.toContain("../chunk.js");
expect(forbidden).toEqual(
expect.arrayContaining([
"./..",
"./../../../escape.js",
"./types.ts",
"unshipped-external",
]),
);
expect(forbidden).toHaveLength(4);
} finally {
rmSync(pkg, { recursive: true, force: true });
}
});
});
describe("pipi package", () => {
let distRoot: string;
let pkg: string;
beforeAll(async () => {
distRoot = temp("pi-ext-dist-");
pkg = (await buildExtension("pipi", { distRoot })).dir;
}, 60_000);
afterAll(() => {
rmSync(distRoot, { recursive: true, force: true });
});
it("emits a complete self-contained package with declared skills", () => {
const files = listFiles(pkg);
expect(files).toContain("index.ts");
expect(files).toContain("package.json");
expect(files).toContain("skills/pipi-round-table/SKILL.md");
expect(files).toContain("skills/pipi-workflows/SKILL.md");
expect(files.some((f) => f.includes("/node_modules/"))).toBe(false);
expect(existsSync(join(distRoot, ".staging"))).toBe(false);
const manifest = JSON.parse(
readFileSync(join(pkg, "package.json"), "utf8"),
);
expect(manifest).toMatchObject({
name: "@bugabinga/pi-ext-pipi",
version: rootVersion(),
private: true,
type: "module",
main: "index.ts",
pi: { extensions: ["index.ts"] },
});
expect(manifest.scripts).toBeUndefined();
expect(manifest.dependencies).toBeUndefined();
expect(Object.keys(manifest.peerDependencies)).toEqual(
expect.arrayContaining(["@earendil-works/pi-coding-agent", "typebox"]),
);
});
it("imports only Node built-ins, Pi modules, and package-private chunks", () => {
expect(forbiddenImports(pkg)).toEqual([]);
});
it("loads relocated outside the checkout with its child tool", async () => {
const report = await verifyPackage(pkg);
expect(report.errors).toEqual([]);
expect(report.ok).toBe(true);
expect(report.extensions).toHaveLength(1);
const pipi = report.extensions[0]!;
expect(pipi.path).not.toContain(ROOT);
expect(pipi.tools).toContain("pipi");
expect(pipi.activeTools).toContain("pipi");
}, 120_000);
it("discovers declared skills from the package resource paths", async () => {
const root = temp("pi-ext-pipi-skills-");
try {
const manifest = JSON.parse(
readFileSync(join(pkg, "package.json"), "utf8"),
);
const loader = new DefaultResourceLoader({
cwd: root,
agentDir: join(root, "agent"),
noExtensions: true,
noSkills: true,
noPromptTemplates: true,
noThemes: true,
noContextFiles: true,
additionalSkillPaths: manifest.pi.skills.map((path: string) =>
join(pkg, path),
),
});
await loader.reload();
const skills = loader
.getSkills()
.skills.map((skill) => skill.filePath.replaceAll("\\", "/"));
expect(skills).toEqual(
expect.arrayContaining([
expect.stringMatching(/\/skills\/pipi-round-table\/SKILL\.md$/u),
expect.stringMatching(/\/skills\/pipi-workflows\/SKILL\.md$/u),
]),
);
for (const skill of skills) expect(skill).not.toContain(ROOT);
} finally {
rmSync(root, { recursive: true, force: true });
}
}, 30_000);
});
describe("memory worker package", () => {
it("runs its relocated Node worker and returns its JSON protocol response", async () => {
const root = temp("pi-ext-memory-worker-");
try {
const pkg = (await buildExtension("memory", { distRoot: root })).dir;
const result = spawnSync(
process.execPath,
[
"--no-warnings",
join(pkg, "sql-worker.js"),
JSON.stringify({
dbPath: join(root, "memory.sqlite"),
sql: "SELECT 1 AS answer",
params: [],
readonly: false,
}),
],
{ encoding: "utf8", timeout: 60_000 },
);
expect(result.error).toBeUndefined();
expect(result.status, result.stderr).toBe(0);
expect(JSON.parse(result.stdout)).toMatchObject({
ok: true,
columns: ["answer"],
rows: [[1]],
rowCount: 1,
});
} finally {
rmSync(root, { recursive: true, force: true });
}
}, 90_000);
});
describe("the-system package", () => {
let distRoot: string;
let pkg: string;
beforeAll(async () => {
distRoot = temp("pi-ext-dist-");
// Release variant: the shipped artifact, free of browser-E2E test entries.
pkg = (await buildExtension("the-system", { distRoot, release: true })).dir;
}, 120_000);
afterAll(() => {
rmSync(distRoot, { recursive: true, force: true });
});
it("bundles every third-party dependency and ships skills plus browser assets", () => {
const files = listFiles(pkg);
expect(files).toContain("skills/vertical-slices/SKILL.md");
expect(files).toContain("skills/the-system-mermaid/SKILL.md");
expect(files).toContain("browser/book.js");
expect(files).not.toContain("assets/mermaid.min.js");
expect(files).not.toContain("assets/minisearch.js");
// Math renders to MathML via Temml (bundled), so nothing ships external.
expect(files.some((f) => f.startsWith("node_modules/"))).toBe(false);
expect(forbiddenImports(pkg)).toEqual([]);
const manifest = JSON.parse(
readFileSync(join(pkg, "package.json"), "utf8"),
);
expect(manifest.dependencies).toBeUndefined();
const renderer = files.find((f) =>
/^system-renderer-[a-z0-9]+\.ts$/u.test(f),
);
expect(renderer).toBeDefined();
expect(readFileSync(join(pkg, renderer ?? ""), "utf8")).toContain(
"./browser/",
);
});
it("loads relocated with its skills served from the package", async () => {
const report = await verifyPackage(pkg);
expect(report.errors).toEqual([]);
expect(report.ok).toBe(true);
expect(report.extensions[0]?.commands).toContain("system");
expect(report.skills.map((path) => path.replaceAll("\\", "/"))).toEqual([
expect.stringMatching(/\/skills\/vertical-slices\/SKILL\.md$/u),
]);
expect(report.skills[0]).not.toContain(ROOT);
}, 120_000);
});
describe("release build parity", () => {
let devRoot: string;
let releaseRoot: string;
let dev: { dir: string; entries: string[] };
let release: { dir: string; entries: string[] };
beforeAll(async () => {
devRoot = temp("pi-ext-dev-");
releaseRoot = temp("pi-ext-rel-");
dev = await buildExtension("pipi", { distRoot: devRoot });
release = await buildExtension("pipi", {
distRoot: releaseRoot,
release: true,
});
}, 180_000);
afterAll(() => {
rmSync(devRoot, { recursive: true, force: true });
rmSync(releaseRoot, { recursive: true, force: true });
});
const isModule = (file: string) => /\.[cm]?[jt]s$/u.test(file);
const resourceFiles = (dir: string) =>
listFiles(dir).filter(
(file) =>
!file.endsWith(".map") &&
!isModule(file) &&
file !== "package.json" &&
file !== BUILD_MANIFEST,
);
it("emits identical entries, externals, manifest, and resources", () => {
// Entry chunk names are hash-free, so they are stable across variants.
expect([...release.entries].sort()).toEqual([...dev.entries].sort());
// Externals and manifest shape are authored once and copied verbatim.
expect(readFileSync(join(release.dir, "package.json"), "utf8")).toBe(
readFileSync(join(dev.dir, "package.json"), "utf8"),
);
// Resources ship byte-for-byte regardless of variant.
const resources = resourceFiles(dev.dir);
expect(resourceFiles(release.dir)).toEqual(resources);
expect(resources.length).toBeGreaterThan(0);
for (const file of resources)
expect(readFileSync(join(release.dir, file))).toEqual(
readFileSync(join(dev.dir, file)),
);
});
it("omits sourcemaps and minifies total shipped JavaScript", () => {
// Sourcemaps are omitted from the release artifact.
expect(listFiles(dev.dir).some((file) => file.endsWith(".map"))).toBe(true);
expect(listFiles(release.dir).some((file) => file.endsWith(".map"))).toBe(
false,
);
// PiPi is a representative multi-module package; release minification
// must reduce its total shipped JavaScript bytes.
const jsBytes = (dir: string) =>
listFiles(dir)
.filter(isModule)
.reduce((sum, file) => sum + readFileSync(join(dir, file)).length, 0);
expect(jsBytes(release.dir)).toBeLessThan(jsBytes(dev.dir));
});
});
describe("collection", () => {
it("reports identity, tool, command, flag, and skill conflicts", () => {
expect(
registrationConflicts(
[
{ path: "/a/index.js", tools: ["x"], commands: ["go"], flags: [] },
{ path: "/b/index.js", tools: ["x"], commands: [], flags: ["f"] },
{ path: "/c/index.js", tools: [], commands: ["go"], flags: ["f"] },
],
["@p/one", "@p/two", "@p/one"],
["/a/skills/s/SKILL.md", "/b/skills/s/SKILL.md"],
),
).toEqual([
"command go registered by /a/index.js, /c/index.js",
"flag f registered by /b/index.js, /c/index.js",
"package @p/one registered by @p/one, @p/one",
"skill s registered by /a/skills/s/SKILL.md, /b/skills/s/SKILL.md",
"tool x registered by /a/index.js, /b/index.js",
]);
expect(
registrationConflicts(
[{ path: "/a/index.js", tools: ["x"], commands: ["go"], flags: [] }],
["@p/one"],
["/a/skills/s/SKILL.md"],
),
).toEqual([]);
});
it("loads several generated packages together without conflicts", async () => {
const distRoot = temp("pi-ext-dist-");
try {
const dirs: string[] = [];
for (const name of ["pfui", "footer", "pipi", "nushell"])
dirs.push((await buildExtension(name, { distRoot })).dir);
const report = await verifyCollection(dirs);
expect(report.errors).toEqual([]);
expect(report.conflicts).toEqual([]);
expect(report.ok).toBe(true);
expect(report.extensions.map((e) => basename(dirname(e.path)))).toEqual([
"pfui",
"footer",
"pipi",
"nushell",
]);
} finally {
rmSync(distRoot, { recursive: true, force: true });
}
}, 180_000);
});
describe("publishPackage", () => {
function stage(root: string, files: Record<string, string>): string {
const staging = join(
root,
`staging-${Math.random().toString(36).slice(2)}`,
);
for (const [name, content] of Object.entries(files)) {
mkdirSync(join(staging, name, ".."), { recursive: true });
writeFileSync(join(staging, name), content);
}
return staging;
}
it("keeps previous chunks for one generation and switches entries last", () => {
const root = temp("pi-ext-publish-");
try {
const target = join(root, "dist", "demo");
publishPackage(
stage(root, {
"index.js": "import './chunk-a.js'",
"chunk-a.js": "a",
"prompts/one.md": "one",
"package.json": "{}",
}),
target,
["index.js"],
);
expect(listFiles(target)).toEqual([
BUILD_MANIFEST,
"chunk-a.js",
"index.js",
"package.json",
"prompts/one.md",
]);
publishPackage(
stage(root, {
"index.js": "import './chunk-b.js'",
"chunk-b.js": "b",
"package.json": "{}",
}),
target,
["index.js"],
);
expect(listFiles(target)).toEqual([
BUILD_MANIFEST,
"chunk-a.js",
"chunk-b.js",
"index.js",
"package.json",
"prompts/one.md",
]);
expect(readFileSync(join(target, "index.js"), "utf8")).toBe(
"import './chunk-b.js'",
);
publishPackage(
stage(root, {
"index.js": "import './chunk-c.js'",
"chunk-c.js": "c",
"package.json": "{}",
}),
target,
["index.js"],
);
expect(listFiles(target)).toEqual([
BUILD_MANIFEST,
"chunk-b.js",
"chunk-c.js",
"index.js",
"package.json",
]);
expect(readdirSync(root).filter((n) => n.startsWith("staging-"))).toEqual(
[],
);
} finally {
rmSync(root, { recursive: true, force: true });
}
});
});
describe("buildExtension", () => {
function fakeRepo(): { root: string; ext: string } {
const root = temp("pi-ext-repo-");
writeFileSync(
join(root, "package.json"),
JSON.stringify({ name: "fake", version: "9.9.9" }),
);
const ext = join(root, "extensions", "demo");
mkdirSync(ext, { recursive: true });
writeFileSync(
join(ext, "package.json"),
JSON.stringify({
name: "@bugabinga/pi-ext-demo",
description: "demo",
license: "MIT",
peerDependencies: { "@earendil-works/pi-coding-agent": "*" },
}),
);
writeFileSync(
join(ext, "index.ts"),
'import { join } from "node:path";\nexport default function demo() { return join("a", "b"); }\n',
);
return { root, ext };
}
it("emits Pi modules as TypeScript with host SDK imports preserved", async () => {
const { root, ext } = fakeRepo();
try {
writeFileSync(
join(ext, "index.ts"),
'export default () => import("./lazy.ts");\n',
);
writeFileSync(
join(ext, "lazy.ts"),
'export { VERSION } from "@earendil-works/pi-coding-agent";\n',
);
const built = await buildExtension("demo", { root });
expect(built.entries).toEqual(["index.ts"]);
expect(listFiles(built.dir)).toEqual(
expect.arrayContaining([
"index.ts",
expect.stringMatching(/^lazy-[a-z0-9]+\.ts$/u),
]),
);
expect(
JSON.parse(readFileSync(join(built.dir, "package.json"), "utf8")),
).toMatchObject({
main: "index.ts",
pi: { extensions: ["index.ts"] },
});
writeFileSync(
join(built.dir, "index.d.ts"),
'export * from "../source.ts";\n',
);
expect(forbiddenImports(built.dir)).toEqual([]);
writeFileSync(join(built.dir, "index.ts"), 'import "undeclared";\n');
expect(forbiddenImports(built.dir)).toEqual(["undeclared"]);
writeFileSync(join(built.dir, "index.ts"), 'import "./missing.ts";\n');
expect(forbiddenImports(built.dir)).toEqual(["./missing.ts"]);
} finally {
rmSync(root, { recursive: true, force: true });
}
});
it("leaves the previous package intact when a rebuild fails", async () => {
const { root, ext } = fakeRepo();
try {
const built = await buildExtension("demo", { root });
const before = listFiles(built.dir).map((f) => [
f,
readFileSync(join(built.dir, f), "utf8"),
]);
expect(
JSON.parse(readFileSync(join(built.dir, "package.json"), "utf8")),
).toMatchObject({ version: "9.9.9", pi: { extensions: ["index.ts"] } });
writeFileSync(join(ext, "index.ts"), 'import "./missing.ts";\n');
await expect(buildExtension("demo", { root })).rejects.toThrow();
const after = listFiles(built.dir).map((f) => [
f,
readFileSync(join(built.dir, f), "utf8"),
]);
expect(after).toEqual(before);
expect(existsSync(join(root, "dist", ".staging"))).toBe(false);
} finally {
rmSync(root, { recursive: true, force: true });
}
});
it("rejects undeclared or missing build declarations", () => {
const { root, ext } = fakeRepo();
try {
writeFileSync(
join(ext, "package.json"),
JSON.stringify({
name: "@bugabinga/pi-ext-demo",
"pi-ext": { resources: ["missing"] },
}),
);
expect(() => readBuildSpec(ext)).toThrow(/missing does not exist/u);
writeFileSync(
join(ext, "package.json"),
JSON.stringify({
name: "@bugabinga/pi-ext-demo",
"pi-ext": { externals: { left: "" } },
}),
);
expect(() => readBuildSpec(ext)).toThrow(/incompatibility reason/u);
writeFileSync(
join(ext, "package.json"),
JSON.stringify({
name: "@bugabinga/pi-ext-demo",
dependencies: { left: "^1" },
"pi-ext": { externals: { left: "native addon" } },
}),
);
expect(readBuildSpec(ext).externals).toEqual({ left: "native addon" });
writeFileSync(
join(ext, "package.json"),
JSON.stringify({
name: "@bugabinga/pi-ext-demo",
"pi-ext": { nodeEntries: ["missing-worker.ts"] },
}),
);
expect(() => readBuildSpec(ext)).toThrow(
/missing-worker.ts does not exist/u,
);
} finally {
rmSync(root, { recursive: true, force: true });
}
});
});