superpowers-manager 0.6.0 → 0.7.1

package/dist/harnesses/codex/presentation.js

@@ -58,33 +58,12 @@ function fields(f) {
         { key: "update_control", label: "update control", value: f.updateControl },
     ];
 }
-const NO_FACTS = {
-    harness: "codex",
-    requestedRef: "",
-    resolvedRef: "",
-    desiredCommit: "",
-    generatedCommit: "",
-    installedCommit: "",
-    identityState: "",
-    status: "",
-    selectionOrigin: "",
-    selectionMode: "",
-    upstreamSourceOrigin: "",
-    effectiveSource: "",
-    savedMode: "",
-    savedSource: "",
-    savedRequestedRef: "",
-    savedResolvedRef: "",
-    savedCommit: "",
-    updateControl: "",
-};
-export const PROBE_PORCELAIN_KEYS = fields(NO_FACTS).map((field) => field.key);
-export function formatPorcelain(f) {
+function formatPorcelain(f) {
     return fields(f)
         .map((field) => `${field.key}=${field.value}\n`)
         .join("");
 }
-export function formatHuman(f) {
+function formatHuman(f) {
     let text = fields(f)
         .map((field) => {
         const shown = field.value.length === 0 && field.absent !== undefined

package/dist/harnesses/codex/publication.js

@@ -298,9 +298,6 @@ async function nativeUnchangedAfterAttempt(prior, priorActiveDigest, current) {
     return (await activeDigest(current)) === priorActiveDigest;
 }
 async function rollbackPublication(pending, publication, previous, priorNative, priorActiveDigest, activationAttempted, ctx, dependencies) {
-    if (pending.settled) {
-        return fail("already-settled", "Codex installation transaction has already been settled", []);
-    }
     const messages = [];
     try {
         const currentNative = await observeNative(ctx, dependencies, messages);
@@ -358,9 +355,6 @@ async function verifyActivated(pending, dependencies, ctx, messages) {
     }
 }
 async function finalizePublication(pending, publication, dependencies, ctx) {
-    if (pending.settled) {
-        return fail("already-settled", "Codex installation transaction has already been settled", []);
-    }
     const messages = [];
     let verified = false;
     let backupRemoved = false;

package/dist/harnesses/codex/recovery.js

@@ -114,7 +114,7 @@ function validateEvidenceShape(record) {
         throw new Error("incomplete old recovery evidence");
     }
 }
-async function decodeRecord(bytes, paths) {
+function decodeRecord(bytes, paths) {
     const parsed = object(parseStrictJson(bytes, PROFILE));
     if (parsed === null)
         throw new Error("recovery journal is not an object");
@@ -182,7 +182,7 @@ async function readOwnedRecord(paths) {
     }
     const path = recordPath(paths);
     await assertNoFollowType(path, ["regular-file"]);
-    return await decodeRecord(await readFile(path), paths);
+    return decodeRecord(await readFile(path), paths);
 }
 export async function readCodexRecovery(paths) {
     try {
@@ -247,11 +247,12 @@ export async function beginCodexRecovery(paths, input) {
             oldDigest: input.oldDigest,
             oldIdentity: input.oldIdentity,
         };
-        await decodeRecord(recordBytes(record), paths);
+        const bytes = recordBytes(record);
+        decodeRecord(bytes, paths);
         const path = recordPath(paths);
         const handle = await open(path, "wx", 0o600);
         try {
-            await handle.writeFile(recordBytes(record));
+            await handle.writeFile(bytes);
             await handle.sync();
         }
         finally {
@@ -311,7 +312,6 @@ async function requirePending(pending) {
         !(await readFile(path)).equals(recordBytes(pending.record))) {
         throw new Error("Codex recovery journal changed");
     }
-    await decodeRecord(recordBytes(pending.record), pending.paths);
 }
 export async function finishCodexRecovery(pending) {
     try {

package/dist/harnesses/codex/stored-state.js

@@ -244,6 +244,6 @@ export async function readCodexStoredState(env, cwd) {
         managerPluginEnabled: manager?.enabled === true,
         legacyPluginPresent: legacy?.installed === true,
         legacyPluginEnabled: legacy?.enabled === true,
-        installedListingJson: JSON.stringify({ installed }),
+        installedPlugins: installed,
     };
 }

package/dist/harnesses/opencode/config.js

@@ -0,0 +1,256 @@
+import { Buffer } from "node:buffer";
+import { constants } from "node:fs";
+import { chmod, open } from "node:fs/promises";
+import { isDeepStrictEqual } from "node:util";
+import { applyEdits, createScanner, findNodeAtLocation, getNodeValue, parseTree, } from "jsonc-parser";
+import * as jsoncParserRuntime from "jsonc-parser";
+import { atomicWriteFile } from "../../atomic.js";
+import { SafetyError } from "../../safety-error.js";
+import { isErrno } from "../../safe-path.js";
+const MAX_CONFIG_BYTES = 1024 * 1024;
+const MAX_CONFIG_DEPTH = 256;
+const UTF8_DECODER = new TextDecoder("utf-8", {
+    fatal: true,
+    ignoreBOM: true,
+});
+const SYNTAX_KIND = jsoncParserRuntime.SyntaxKind;
+async function readBoundedConfigBytes(handle) {
+    const budget = Buffer.allocUnsafe(MAX_CONFIG_BYTES + 1);
+    let length = 0;
+    while (length < budget.length) {
+        const { bytesRead } = await handle.read(budget, length, budget.length - length, null);
+        if (bytesRead === 0)
+            break;
+        length += bytesRead;
+    }
+    if (length > MAX_CONFIG_BYTES) {
+        throw new Error("configuration grew past the byte limit");
+    }
+    return Buffer.from(budget.subarray(0, length));
+}
+function invalidConfig(path, cause) {
+    return new SafetyError("opencode-config", `invalid OpenCode configuration: ${path}`, cause === undefined ? {} : { cause });
+}
+function cannotRead(path, cause) {
+    return new SafetyError("opencode-config", `cannot read OpenCode configuration: ${path}`, cause === undefined ? {} : { cause });
+}
+function cannotRemove(path, cause) {
+    return new SafetyError("opencode-config", `cannot remove owned OpenCode registration: ${path}`, cause === undefined ? {} : { cause });
+}
+function propertyParts(property) {
+    const [key, value] = property.children ?? [];
+    if (property.type !== "property" ||
+        key?.type !== "string" ||
+        typeof key.value !== "string" ||
+        value === undefined) {
+        throw new Error("malformed property tree");
+    }
+    return [key, value];
+}
+function validateTree(node, depth) {
+    if (node.type !== "object" && node.type !== "array")
+        return;
+    if (depth > MAX_CONFIG_DEPTH)
+        throw new Error("configuration is too deep");
+    if (node.type === "object") {
+        const names = new Set();
+        for (const property of node.children ?? []) {
+            const [key, value] = propertyParts(property);
+            if (names.has(key.value))
+                throw new Error("duplicate key");
+            names.add(key.value);
+            validateTree(value, depth + 1);
+        }
+        return;
+    }
+    for (const child of node.children ?? [])
+        validateTree(child, depth + 1);
+}
+function configEntries(root) {
+    const plugin = findNodeAtLocation(root, ["plugin"]);
+    if (plugin === undefined)
+        return [];
+    if (plugin.type !== "array")
+        throw new Error("plugin must be an array");
+    return (plugin.children ?? []).map((entry, index) => {
+        if (entry.type === "string" && typeof entry.value === "string") {
+            return { index, spec: entry.value, options: null };
+        }
+        const tuple = entry.children ?? [];
+        if (entry.type !== "array" ||
+            tuple.length !== 2 ||
+            tuple[0]?.type !== "string" ||
+            typeof tuple[0].value !== "string" ||
+            tuple[1]?.type !== "object") {
+            throw new Error("unsupported plugin entry");
+        }
+        return {
+            index,
+            spec: tuple[0].value,
+            options: structuredClone(getNodeValue(tuple[1])),
+        };
+    });
+}
+export function parseOpenCodeConfig(text, path) {
+    try {
+        if (Buffer.byteLength(text, "utf8") > MAX_CONFIG_BYTES) {
+            throw new Error("configuration is too large");
+        }
+        const errors = [];
+        const root = parseTree(text, errors, { allowTrailingComma: true });
+        if (root === undefined || errors.length !== 0 || root.type !== "object") {
+            throw new Error("configuration must be one valid object");
+        }
+        validateTree(root, 1);
+        return { path, text, root, entries: configEntries(root) };
+    }
+    catch (cause) {
+        if (cause instanceof SafetyError)
+            throw cause;
+        throw invalidConfig(path, cause);
+    }
+}
+function sameEntries(left, right) {
+    return (left.length === right.length &&
+        left.every((entry, index) => entry.spec === right[index]?.spec &&
+            isDeepStrictEqual(entry.options, right[index]?.options)));
+}
+export function removeOpenCodeEntry(document, index) {
+    try {
+        const array = findNodeAtLocation(document.root, ["plugin"]);
+        const elements = array?.children ?? [];
+        const element = elements[index];
+        if (array?.type !== "array" ||
+            !Number.isInteger(index) ||
+            index < 0 ||
+            !element) {
+            throw new Error("invalid removal index");
+        }
+        const previous = elements[index - 1];
+        const next = elements[index + 1];
+        const gapStart = next || !previous
+            ? element.offset + element.length
+            : previous.offset + previous.length;
+        const gapEnd = next
+            ? next.offset
+            : previous
+                ? element.offset
+                : array.offset + array.length - 1;
+        const scanner = createScanner(document.text, true);
+        scanner.setPosition(gapStart);
+        let commaOffset;
+        while (scanner.getPosition() < gapEnd) {
+            const token = scanner.scan();
+            if (token === SYNTAX_KIND.EOF || scanner.getTokenOffset() >= gapEnd)
+                break;
+            if (token !== SYNTAX_KIND.CommaToken || commaOffset !== undefined) {
+                throw new Error("unexpected separator");
+            }
+            commaOffset = scanner.getTokenOffset();
+        }
+        if ((previous || next) && commaOffset === undefined) {
+            throw new Error("missing separator");
+        }
+        const edits = [
+            { offset: element.offset, length: element.length, content: "" },
+        ];
+        if (commaOffset !== undefined) {
+            edits.push({ offset: commaOffset, length: 1, content: "" });
+        }
+        const output = applyEdits(document.text, edits);
+        const after = parseOpenCodeConfig(output, document.path);
+        const expected = document.entries.filter((entry) => entry.index !== index);
+        if (!sameEntries(after.entries, expected)) {
+            throw new Error("removal changed surviving registrations");
+        }
+        return output;
+    }
+    catch (cause) {
+        throw cannotRemove(document.path, cause);
+    }
+}
+async function readConfigBytes(path) {
+    let handle;
+    try {
+        handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const details = await handle.stat();
+        if (!details.isFile() || details.size > MAX_CONFIG_BYTES) {
+            throw new Error("configuration is not a bounded regular file");
+        }
+        const bytes = await readBoundedConfigBytes(handle);
+        return {
+            bytes,
+            identity: {
+                dev: details.dev,
+                ino: details.ino,
+                mode: details.mode,
+            },
+        };
+    }
+    catch (cause) {
+        if (isErrno(cause, "ENOENT"))
+            return null;
+        throw cannotRead(path, cause);
+    }
+    finally {
+        await handle?.close().catch(() => { });
+    }
+}
+function decodeConfig(bytes, path) {
+    try {
+        return UTF8_DECODER.decode(bytes);
+    }
+    catch (cause) {
+        throw cannotRead(path, cause);
+    }
+}
+export async function readOpenCodeConfig(path) {
+    const observed = await readConfigBytes(path);
+    if (observed === null)
+        return null;
+    const text = decodeConfig(observed.bytes, path);
+    try {
+        return {
+            document: parseOpenCodeConfig(text, path),
+            bytes: observed.bytes,
+            identity: observed.identity,
+        };
+    }
+    catch (cause) {
+        throw cannotRead(path, cause);
+    }
+}
+function sameObservedState(left, right) {
+    return (left.dev === right.dev && left.ino === right.ino && left.mode === right.mode);
+}
+export async function removeObservedOpenCodeEntry(observation, index) {
+    const path = observation.document.path;
+    try {
+        const originalText = decodeConfig(observation.bytes, path);
+        const original = parseOpenCodeConfig(originalText, path);
+        const output = removeOpenCodeEntry(original, index);
+        const outputBytes = Buffer.from(output, "utf8");
+        const expected = original.entries.filter((entry) => entry.index !== index);
+        await atomicWriteFile(path, outputBytes, {
+            validate: async (temporary) => {
+                await chmod(temporary, observation.identity.mode & 0o7777);
+                const current = await readConfigBytes(path);
+                if (current === null ||
+                    !sameObservedState(current.identity, observation.identity) ||
+                    !current.bytes.equals(observation.bytes)) {
+                    throw new Error("OpenCode configuration changed concurrently");
+                }
+            },
+        });
+        const after = await readOpenCodeConfig(path);
+        if (after === null ||
+            !after.bytes.equals(outputBytes) ||
+            after.identity.mode !== observation.identity.mode ||
+            !sameEntries(after.document.entries, expected)) {
+            throw new Error("published OpenCode configuration could not be verified");
+        }
+    }
+    catch (cause) {
+        throw cannotRemove(path, cause);
+    }
+}