superpowers-manager 0.5.2 → 0.7.0

package/dist/harnesses/codex/paths.js

@@ -1,5 +1,5 @@
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-import { assertNoFollowType, canonicalizeProspectivePath, } from "../../safe-path.js";
+import { join, resolve } from "node:path";
+import { assertNoFollowType, canonicalizeProspectivePath, isContained, } from "../../safe-path.js";
 import { SafetyError } from "../../safety-error.js";
 export function codexHome(env, cwd) {
     const configured = env.CODEX_HOME;
@@ -26,15 +26,18 @@ export function codexPaths(env, cwd) {
     };
 }
 function overlaps(a, b) {
-    const inside = (root, leaf) => {
-        const suffix = relative(root, leaf);
-        return (suffix === "" ||
-            (!isAbsolute(suffix) && suffix !== ".." && !suffix.startsWith(`..${sep}`)));
-    };
-    return inside(a, b) || inside(b, a);
+    return isContained(a, b) || isContained(b, a);
+}
+class CodexPathError extends SafetyError {
+    constructor(message, details, cause) {
+        super("codex-paths", message, {
+            details,
+            ...(cause === undefined ? {} : { cause }),
+        });
+    }
 }
 function separationError() {
-    return new SafetyError("codex-paths", "preparation overlaps Codex published or recovery storage", { details: { kind: "overlap" } });
+    return new CodexPathError("preparation overlaps Codex published or recovery storage", { kind: "overlap" });
 }
 async function inspectRoot(path, root) {
     try {
@@ -42,29 +45,11 @@ async function inspectRoot(path, root) {
         return await canonicalizeProspectivePath(path);
     }
     catch (cause) {
-        throw new SafetyError("codex-paths", `cannot inspect ${root} root: ${path}`, { cause, details: { kind: "inspection", root, path } });
+        throw new CodexPathError(`cannot inspect ${root} root: ${path}`, { kind: "inspection", root, path }, cause);
     }
 }
 export function codexPathFailureDetails(cause) {
-    if (!(cause instanceof SafetyError) || cause.module !== "codex-paths") {
-        return null;
-    }
-    const details = cause.details;
-    if (details === null || typeof details !== "object" || !("kind" in details)) {
-        return null;
-    }
-    if (details.kind === "overlap")
-        return { kind: "overlap" };
-    if (details.kind !== "inspection" ||
-        !("root" in details) ||
-        !("path" in details) ||
-        (details.root !== "preparation" &&
-            details.root !== "marketplace" &&
-            details.root !== "recovery") ||
-        typeof details.path !== "string") {
-        return null;
-    }
-    return { kind: "inspection", root: details.root, path: details.path };
+    return cause instanceof CodexPathError ? (cause.details ?? null) : null;
 }
 export async function assertCodexPreparationSeparate(preparedRoot, paths) {
     const recovery = await inspectRoot(paths.recoveryRoot, "recovery");

package/dist/harnesses/codex/presentation.js

@@ -1,5 +1,5 @@
-import { normalizeCodexInstall, normalizeCodexInstalled } from "./harness.js";
 import { displaySource } from "../../selection.js";
+import { hasTerminalControl } from "../../adapter-result.js";
 // One ordered table drives both formats, preserving the public human and
 // porcelain field order exposed through the harness presentation.
 function fields(f) {
@@ -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
@@ -110,23 +89,15 @@ function verificationOutput(kind, hint) {
         stderr.push(`hint: ${hint}`);
     return { stdout: [], stderr };
 }
+function safeHint(value) {
+    return typeof value === "string" && !hasTerminalControl(value) ? value : "";
+}
 export function codexInstallReceipt(missingHint, mismatchHint) {
     return {
-        missingVerificationOutput: verificationOutput("missing", missingHint),
-        mismatchVerificationOutput: verificationOutput("mismatch", mismatchHint),
+        missingVerificationOutput: verificationOutput("missing", safeHint(missingHint)),
+        mismatchVerificationOutput: verificationOutput("mismatch", safeHint(mismatchHint)),
     };
 }
-// Compatibility export target for src/harnesses/codex/lifecycle.ts. Delegate to the production
-// normalizers and renderer so the retained verdict cannot drift from commands.
-export function verifyInstalledFingerprint(desiredCommit, installResult, inspectResult) {
-    const receipt = normalizeCodexInstall(installResult);
-    const inspection = normalizeCodexInstalled(inspectResult, desiredCommit);
-    const output = codexPresentation.renderInstallVerification(desiredCommit, receipt, inspection);
-    const ok = inspection.status === 0 &&
-        inspection.outcome.ok &&
-        inspection.outcome.result.kind === "current";
-    return { ok, stdout: output.stdout, stderr: output.stderr };
-}
 function probeFacts(facts) {
     const selection = facts.selection;
     const saved = selection.saved;

package/dist/harnesses/codex/publication.js

@@ -3,9 +3,8 @@ import { failureResult, successResult, } from "../../adapter-result.js";
 import { beginDirectoryPublication, } from "../../atomic.js";
 import { digestArtifactTree } from "../../artifact-tree.js";
 import { assertNoFollowType, classifyPathNoFollow } from "../../safe-path.js";
-import { codexInspect, codexInstallRefreshMode, codexRemove, codexReadNativeState, } from "./adapter.js";
+import { codexInspectControl, codexInspectOwnership, codexInstallRefreshMode, codexRemove, codexReadNativeState, } from "./adapter.js";
 import { readCodexAssessment } from "./compatibility.js";
-import { requireManagedUpdateControl, requireNoLegacyState, } from "./lifecycle.js";
 import { readCodexMarketplace, stageCodexMarketplace, } from "./marketplace.js";
 import { assertCodexPreparationSeparate, codexPathFailureDetails, codexPaths, } from "./paths.js";
 import { codexPreparationLocation } from "./prepare.js";
@@ -13,7 +12,8 @@ import { beginCodexRecovery, finishCodexRecovery, readCodexRecovery, verifyCodex
 import { hasFilesystemAccessFailure, pathsEqual } from "./state.js";
 const DEFAULTS = {
     readNative: codexReadNativeState,
-    inspectNative: codexInspect,
+    inspectOwnership: codexInspectOwnership,
+    inspectControl: codexInspectControl,
     beginPublication: beginDirectoryPublication,
 };
 const REMOVAL_DEFAULTS = {
@@ -26,16 +26,6 @@ function fail(code, message, messages) {
 function removalFailure(code, message, messages) {
     return failureResult("uninstall-codex", code, message, [], messages);
 }
-function objectResult(result) {
-    if (result.status !== 0 ||
-        !result.outcome.ok ||
-        result.outcome.result === null ||
-        typeof result.outcome.result !== "object" ||
-        Array.isArray(result.outcome.result)) {
-        throw new Error("Codex inspection failed");
-    }
-    return result.outcome.result;
-}
 function acceptedNative(result) {
     if (result.status !== 0 || !result.outcome.ok) {
         throw new Error("Codex native observation failed");
@@ -54,26 +44,18 @@ function acceptedNative(result) {
     return value;
 }
 function requireOwnership(result) {
-    const value = objectResult(result);
-    if (typeof value.identity_state !== "string" ||
-        requireNoLegacyState(value.identity_state).kind !== "ok" ||
-        !Array.isArray(value.conflicts) ||
-        value.conflicts.length !== 0) {
-        throw new Error("Codex ownership blocks publication");
+    if (result.status !== 0 || !result.outcome.ok) {
+        throw new Error("Codex inspection failed");
     }
-    const resources = value.resources;
-    if (typeof resources !== "object" ||
-        resources === null ||
-        Array.isArray(resources) ||
-        typeof resources.plugin !== "boolean" ||
-        typeof resources.marketplace !== "boolean") {
-        throw new Error("Codex ownership inspection is malformed");
+    if (result.outcome.result?.installEligibility?.kind !== "allowed") {
+        throw new Error("Codex ownership blocks publication");
     }
 }
 function requireControl(result) {
-    const value = objectResult(result);
-    if (typeof value.update_control !== "string" ||
-        !requireManagedUpdateControl(value.update_control).ok) {
+    if (result.status !== 0 || !result.outcome.ok) {
+        throw new Error("Codex inspection failed");
+    }
+    if (result.outcome.result?.mutationEligibility?.kind !== "allowed") {
         throw new Error("Codex update control blocks publication");
     }
 }
@@ -262,10 +244,10 @@ async function observeNative(ctx, dependencies, messages) {
     return acceptedNative(result);
 }
 async function requireEligibility(ctx, dependencies, messages) {
-    const ownership = await dependencies.inspectNative("ownership", ctx);
+    const ownership = await dependencies.inspectOwnership(ctx);
     messages.push(...ownership.outcome.messages);
     requireOwnership(ownership);
-    const control = await dependencies.inspectNative("update-control", ctx);
+    const control = await dependencies.inspectControl(ctx);
     messages.push(...control.outcome.messages);
     requireControl(control);
 }
@@ -316,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);
@@ -376,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);
+    }
+}