@penpair/core 0.2.0 → 0.3.0

package/dist/adapters.js

@@ -7,22 +7,60 @@ import { readProjectConfig } from "./instance/config.js";
 export const defineAdapter = (adapter) => adapter;
 /** The commands of the core itself; an adapter cannot take one of these names. */
 export const reservedCommands = [
-    "formats", "snapshot", "approve", "mcp", "spec", "inspect", "probe", "pages", "tree", "audit", "tokens", "export", "shots", "archive", "snippets", "run", "run-file", "kit", "recipes", "skills", "init", "setup", "connect",
-    "up", "down", "open", "status", "doctor", "backup", "restore", "baselines", "config", "runs", "onboard", "help",
+    "formats",
+    "snapshot",
+    "approve",
+    "mcp",
+    "spec",
+    "inspect",
+    "probe",
+    "pages",
+    "tree",
+    "audit",
+    "tokens",
+    "export",
+    "shots",
+    "archive",
+    "snippets",
+    "run",
+    "run-file",
+    "kit",
+    "recipes",
+    "skills",
+    "init",
+    "setup",
+    "connect",
+    "up",
+    "down",
+    "open",
+    "status",
+    "doctor",
+    "backup",
+    "restore",
+    "baselines",
+    "config",
+    "runs",
+    "onboard",
+    "help",
 ];
 /** Resolves an adapter the way the project would: a relative path from the project's folder, or a package installed in the project. */
 export const importFromProject = async (specifier, root) => {
     let file;
-    if (specifier.startsWith(".") || path.isAbsolute(specifier))
+    if (specifier.startsWith(".") || path.isAbsolute(specifier)) {
         file = await resolveProjectInput(root, specifier);
+    }
     else {
-        if (!/^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+(?:\/[a-z0-9._-]+)*$/i.test(specifier) || specifier.split("/").includes(".."))
+        if (!/^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+(?:\/[a-z0-9._-]+)*$/i.test(specifier) ||
+            specifier.split("/").includes("..")) {
             throw new Error("Adapter must name an installed package or a relative project module");
+        }
         try {
             file = createRequire(path.join(root, "package.json")).resolve(specifier);
         }
         catch {
-            const error = Object.assign(new Error(`${specifier} is not installed in this project`), { code: "ERR_MODULE_NOT_FOUND" });
+            const error = Object.assign(new Error(`${specifier} is not installed in this project`), {
+                code: "ERR_MODULE_NOT_FOUND",
+            });
             throw error;
         }
     }
@@ -50,18 +88,27 @@ export async function loadAdapters(root, specifiers, importer = importFromProjec
             continue;
         }
         for (const command of adapter.commands) {
-            if (reservedCommands.includes(command.name))
+            if (reservedCommands.includes(command.name)) {
                 problems.push(`adapter ${specifier}: the command "${command.name}" is one the core already has`);
-            else if (taken.has(command.name))
+            }
+            else if (taken.has(command.name)) {
                 problems.push(`adapter ${specifier}: the command "${command.name}" is already provided by ${taken.get(command.name)}`);
-            else
+            }
+            else {
                 taken.set(command.name, adapter.name);
+            }
         }
-        adapters.push({ ...adapter, commands: adapter.commands.filter((c) => taken.get(c.name) === adapter.name) });
+        adapters.push({
+            ...adapter,
+            commands: adapter.commands.filter((c) => taken.get(c.name) === adapter.name),
+        });
     }
-    return { adapters, problems };
+    return {
+        adapters,
+        problems,
+    };
 }
 /** The whole penpair.config.json as written (an adapter's own settings live in it). Empty when there is no file. */
 export async function readRawConfig(root) {
-    return await readProjectConfig(root) ?? {};
+    return (await readProjectConfig(root)) ?? {};
 }

package/dist/approvals.js

@@ -9,77 +9,184 @@ import { pngSize } from "./png.js";
 export const approvalFile = "design/approvals.json";
 export const artifactSha = (bytes) => createHash("sha256").update(bytes).digest("hex");
 export function approvalFingerprint(capture, sha256, intent) {
-    if (!capture || typeof capture.fileId !== "string" || !capture.fileId || typeof capture.pageId !== "string" || !capture.pageId || typeof capture.frameId !== "string" || !capture.frameId || !Number.isInteger(capture.revision) || !Number.isFinite(capture.scale) || capture.scale <= 0 || !/^[a-f0-9]{64}$/.test(sha256))
+    if (!capture ||
+        typeof capture.fileId !== "string" ||
+        !capture.fileId ||
+        typeof capture.pageId !== "string" ||
+        !capture.pageId ||
+        typeof capture.frameId !== "string" ||
+        !capture.frameId ||
+        !Number.isInteger(capture.revision) ||
+        !Number.isFinite(capture.scale) ||
+        capture.scale <= 0 ||
+        !/^[a-f0-9]{64}$/.test(sha256)) {
         throw new Error("Approval requires exact capture identity, revision, scale and SHA-256");
-    if (intent)
-        validateBaselineCase(intent, message => { throw new Error(message); });
-    return observationHash({ capture, sha256, case: intent ?? null });
+    }
+    if (intent) {
+        validateBaselineCase(intent, (message) => {
+            throw new Error(message);
+        });
+    }
+    return observationHash({
+        capture,
+        sha256,
+        case: intent ?? null,
+    });
 }
 export function validateApprovals(raw) {
     const v = raw;
-    if (!v || v.schemaVersion !== 1 || v.kind !== "design-approvals" || !Array.isArray(v.records) || v.records.length > 10000)
+    if (!v ||
+        v.schemaVersion !== 1 ||
+        v.kind !== "design-approvals" ||
+        !Array.isArray(v.records) ||
+        v.records.length > 10000) {
         throw new Error("Unsupported approval document");
+    }
     const ids = new Set();
     for (const r of v.records) {
-        if (!r || r.schemaVersion !== 1 || r.kind !== "owner-words" || typeof r.id !== "string" || !r.id || ids.has(r.id) || typeof r.note !== "string" || !r.note.trim() || r.note.length > 4000 || typeof r.by !== "string" || !r.by.trim() || r.by.length > 200 || !Number.isFinite(Date.parse(r.recordedAt)) || typeof r.image !== "string" || !r.image)
+        if (!r ||
+            r.schemaVersion !== 1 ||
+            r.kind !== "owner-words" ||
+            typeof r.id !== "string" ||
+            !r.id ||
+            ids.has(r.id) ||
+            typeof r.note !== "string" ||
+            !r.note.trim() ||
+            r.note.length > 4000 ||
+            typeof r.by !== "string" ||
+            !r.by.trim() ||
+            r.by.length > 200 ||
+            !Number.isFinite(Date.parse(r.recordedAt)) ||
+            typeof r.image !== "string" ||
+            !r.image) {
             throw new Error("Malformed owner approval record");
+        }
         ids.add(r.id);
         const { hash, ...body } = r;
-        if (hash !== observationHash(body) || r.fingerprint !== approvalFingerprint(r.capture, r.sha256, r.case))
+        if (hash !== observationHash(body) ||
+            r.fingerprint !== approvalFingerprint(r.capture, r.sha256, r.case)) {
             throw new Error("Approval evidence hash mismatch");
+        }
     }
     return v;
 }
 export async function readApprovals(root) {
     try {
         const file = await resolveProjectInput(root, approvalFile);
-        if ((await stat(file)).size > 16 * 1024 * 1024)
+        if ((await stat(file)).size > 16 * 1024 * 1024) {
             throw new Error("Approval file exceeds 16 MiB");
+        }
         return validateApprovals(JSON.parse(await readFile(file, "utf8")));
     }
     catch (error) {
-        if (error.code === "ENOENT")
-            return { schemaVersion: 1, kind: "design-approvals", records: [] };
+        if (error.code === "ENOENT") {
+            return {
+                schemaVersion: 1,
+                kind: "design-approvals",
+                records: [],
+            };
+        }
         throw error;
     }
 }
 /** Records supplied owner words; hashes detect accidental changes, not identity or consent. */
 export async function recordApproval(root, exported, words, intent, redact) {
-    exported = { ...exported, capture: structuredClone(exported.capture), png: Buffer.from(exported.png) };
+    exported = {
+        ...exported,
+        capture: structuredClone(exported.capture),
+        png: Buffer.from(exported.png),
+    };
     intent = intent ? structuredClone(intent) : undefined;
-    words = { ...words };
-    if (!exported.stable || !pngSize(exported.png))
+    words = {
+        ...words,
+    };
+    if (!exported.stable || !pngSize(exported.png)) {
         throw new Error("Approval requires a stable independently exported PNG");
-    if (typeof words.note !== "string" || !words.note.trim() || words.note.length > 4000 || typeof words.by !== "string" || !words.by.trim() || words.by.length > 200)
+    }
+    if (typeof words.note !== "string" ||
+        !words.note.trim() ||
+        words.note.length > 4000 ||
+        typeof words.by !== "string" ||
+        !words.by.trim() ||
+        words.by.length > 200) {
         throw new Error("Supply the owner's exact nonempty words and identity; an agent cannot invent approval");
-    const sha256 = artifactSha(exported.png), fingerprint = approvalFingerprint(exported.capture, sha256, intent);
-    if (intent && (!exported.capture.designSize || exported.capture.designSize.width !== intent.viewport.width || exported.capture.designSize.height !== intent.viewport.height || intent.activeThemeIds && observationHash([...(exported.capture.activeThemeIds ?? [])].sort()) !== observationHash([...intent.activeThemeIds].sort())))
+    }
+    const sha256 = artifactSha(exported.png);
+    const fingerprint = approvalFingerprint(exported.capture, sha256, intent);
+    if (intent &&
+        (!exported.capture.designSize ||
+            exported.capture.designSize.width !== intent.viewport.width ||
+            exported.capture.designSize.height !== intent.viewport.height ||
+            (intent.activeThemeIds &&
+                observationHash([
+                    ...(exported.capture.activeThemeIds ?? []),
+                ].sort()) !==
+                    observationHash([
+                        ...intent.activeThemeIds,
+                    ].sort())))) {
         throw new Error("Approval case assertions do not match observed capture");
-    const body = { schemaVersion: 1, id: randomUUID(), kind: "owner-words", recordedAt: new Date().toISOString(), by: words.by, note: words.note, capture: exported.capture, ...(intent ? { case: intent } : {}), sha256, image: `design/approvals/${sha256}.png`, fingerprint };
-    const record = { ...body, hash: observationHash(body) };
+    }
+    const body = {
+        schemaVersion: 1,
+        id: randomUUID(),
+        kind: "owner-words",
+        recordedAt: new Date().toISOString(),
+        by: words.by,
+        note: words.note,
+        capture: exported.capture,
+        ...(intent
+            ? {
+                case: intent,
+            }
+            : {}),
+        sha256,
+        image: `design/approvals/${sha256}.png`,
+        fingerprint,
+    };
+    const record = {
+        ...body,
+        hash: observationHash(body),
+    };
     const serialized = JSON.stringify(record);
-    if (redact && redact(serialized) !== serialized)
+    if (redact && redact(serialized) !== serialized) {
         throw new Error("Approval requires credential redaction; no record was written");
+    }
     const file = await resolveProjectOutput(root, approvalFile);
-    await mkdir(path.dirname(file), { recursive: true });
+    await mkdir(path.dirname(file), {
+        recursive: true,
+    });
     const lock = await open(file + ".lock", "wx", 0o600);
     try {
         const previous = await readApprovals(root);
-        if (previous.records.length >= 10000)
+        if (previous.records.length >= 10000) {
             throw new Error("Approval document record limit reached");
+        }
         const image = await resolveProjectOutput(root, record.image);
-        await mkdir(path.dirname(image), { recursive: true });
+        await mkdir(path.dirname(image), {
+            recursive: true,
+        });
         try {
             await atomicWriteFile(image, exported.png);
         }
         catch (error) {
-            if (error.code !== "EEXIST" || artifactSha(await readFile(image)) !== sha256)
+            if (error.code !== "EEXIST" ||
+                artifactSha(await readFile(image)) !== sha256) {
                 throw error;
+            }
         }
-        const next = JSON.stringify({ ...previous, records: [...previous.records, record] }, null, 2) + "\n";
-        if (Buffer.byteLength(next) > 16 * 1024 * 1024)
+        const next = JSON.stringify({
+            ...previous,
+            records: [
+                ...previous.records,
+                record,
+            ],
+        }, null, 2) + "\n";
+        if (Buffer.byteLength(next) > 16 * 1024 * 1024) {
             throw new Error("Approval document byte limit reached");
-        await atomicWriteFile(file, next, { replace: true });
+        }
+        await atomicWriteFile(file, next, {
+            replace: true,
+        });
         return record;
     }
     finally {
@@ -89,11 +196,18 @@ export async function recordApproval(root, exported, words, intent, redact) {
 }
 export async function matchingApproval(root, capture, sha256, intent) {
     const fingerprint = approvalFingerprint(capture, sha256, intent);
-    const record = [...(await readApprovals(root)).records].reverse().find(r => r.fingerprint === fingerprint);
-    if (!record)
+    const record = [
+        ...(await readApprovals(root)).records,
+    ]
+        .reverse()
+        .find((r) => r.fingerprint === fingerprint);
+    if (!record) {
         return undefined;
+    }
     const image = await resolveProjectInput(root, record.image);
-    if ((await stat(image)).size > 64 * 1024 * 1024 || artifactSha(await readFile(image)) !== sha256)
+    if ((await stat(image)).size > 64 * 1024 * 1024 ||
+        artifactSha(await readFile(image)) !== sha256) {
         throw new Error("Approved image bytes changed");
+    }
     return record;
 }

package/dist/atomic-output.js

@@ -16,13 +16,18 @@ export async function atomicWriteFile(destination, data, options = {}) {
     }
     await handle.close();
     try {
-        if (options.replace)
+        if (options.replace) {
             await rename(temporary, destination);
-        else
+        }
+        else {
             await link(temporary, destination);
+        }
     }
     finally {
-        await unlink(temporary).catch((error) => { if (error.code !== "ENOENT")
-            throw error; });
+        await unlink(temporary).catch((error) => {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        });
     }
 }