superpowers-manager 0.8.0 → 0.9.0

package/dist/harnesses/opencode/install.js

@@ -1,6 +1,6 @@
 import { createHash, randomBytes } from "node:crypto";
-import { cp, lstat, mkdir, open, readFile, readdir, rm, rmdir, unlink, } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { cp, mkdir, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
 import { findNodeAtLocation } from "jsonc-parser";
 import { failureResult, successResult, } from "../../adapter-result.js";
 import { digestArtifactTree } from "../../artifact-tree.js";
@@ -14,6 +14,7 @@ import { readOpenCodePackageAssessment, readOpenCodeReceipt, } from "./package.j
 import { assertOpenCodePreparationSeparate, openCodePaths, } from "./paths.js";
 import { inspectOpenCodeControl, inspectOpenCodeOwnership, } from "./state.js";
 import { displayPath } from "../../validator.js";
+import { createJournal, createSnapshotJournal, hasRecovery, identity, journalPath, publicationPaths, requireNoRecovery, } from "../../snapshot-journal.js";
 const DEFAULTS = {
     run: runOpenCode,
     beginPublication: beginDirectoryPublication,
@@ -35,20 +36,6 @@ function accepted(result) {
         throw new Error("OpenCode operation did not succeed");
     return result.outcome.result;
 }
-function sameIdentity(left, right) {
-    return left.dev === right.dev && left.ino === right.ino;
-}
-async function identity(path) {
-    await assertNoFollowType(path, ["directory"]);
-    return await lstat(path);
-}
-async function requireIdentity(path, expected) {
-    if (!sameIdentity(await identity(path), expected))
-        throw new Error("OpenCode directory changed");
-}
-function journalPath(pending) {
-    return join(pending.paths.recoveryRoot, "transaction.json");
-}
 function journalBytes(journal) {
     const bytes = Buffer.from(`${JSON.stringify(journal)}\n`);
     if (bytes.length > MAX_JOURNAL_BYTES)
@@ -57,31 +44,14 @@ function journalBytes(journal) {
 }
 async function validatePaths(paths) {
     await assertOpenCodePreparationSeparate(paths);
-    await assertNoFollowType(paths.configRoot, ["directory", "missing"]);
-    await assertNoFollowType(paths.managerRoot, ["directory", "missing"]);
-    await assertNoFollowType(paths.installedRoot, ["directory", "missing"]);
     return await canonicalizeProspectivePath(paths.installedRoot);
 }
-async function requireNoRecovery(paths) {
-    await assertNoFollowType(paths.recoveryRoot, ["missing"]);
-}
-async function hasRecovery(paths) {
-    try {
-        return (await classifyPathNoFollow(paths.recoveryRoot)) !== "missing";
-    }
-    catch {
-        return true;
-    }
-}
-async function syncDirectoryStrict(path) {
-    const directory = await open(path, "r");
-    try {
-        await directory.sync();
-    }
-    finally {
-        await directory.close();
-    }
-}
+const { requireIdentity, requireJournal, phase, retireJournal } = createSnapshotJournal({
+    label: "OpenCode",
+    validatePaths,
+    serialize: journalBytes,
+    readCap: MAX_JOURNAL_BYTES,
+});
 function artifactSame(left, right) {
     return left === null
         ? right === null
@@ -200,39 +170,6 @@ async function requireActivationEligibility(ctx) {
         control.mutationEligibility.kind !== "allowed")
         throw new Error("OpenCode ownership or control blocked");
 }
-async function requireJournal(pending) {
-    if ((await validatePaths(pending.paths)) !== pending.canonicalRoot ||
-        pending.journal.installedRoot !== pending.canonicalRoot ||
-        !/^[a-f0-9]{32}$/u.test(pending.journal.token))
-        throw new Error("OpenCode recovery root changed");
-    await requireIdentity(pending.paths.recoveryRoot, pending.recoveryIdentity);
-    const path = journalPath(pending);
-    await assertNoFollowType(path, ["regular-file"]);
-    const observed = await lstat(path);
-    if (!sameIdentity(observed, pending.journalIdentity) ||
-        observed.size > MAX_JOURNAL_BYTES ||
-        !(await readFile(path)).equals(journalBytes(pending.journal)))
-        throw new Error("OpenCode recovery journal changed");
-    if (pending.backup !==
-        join(dirname(pending.canonicalRoot), `.${basename(pending.canonicalRoot)}.bak.${pending.journal.token}`) ||
-        pending.stage !==
-            join(dirname(pending.canonicalRoot), `.${basename(pending.canonicalRoot)}.stage.${pending.journal.token}`))
-        throw new Error("OpenCode recovery paths changed");
-}
-async function phase(pending, next, changes = {}) {
-    await requireJournal(pending);
-    const journal = { ...pending.journal, ...changes, phase: next };
-    const bytes = journalBytes(journal);
-    await atomicWriteFile(journalPath(pending), bytes, {
-        validate: async (temporary) => {
-            if (!(await readFile(temporary)).equals(bytes))
-                throw new Error("OpenCode journal write changed");
-        },
-    });
-    await syncDirectoryStrict(pending.paths.recoveryRoot);
-    pending.journal = journal;
-    pending.journalIdentity = await lstat(journalPath(pending));
-}
 async function beginJournal(paths, oldArtifact, newArtifact, priorRegistration, ctx) {
     const canonicalRoot = await validatePaths(paths);
     await requireNoRecovery(paths);
@@ -253,36 +190,18 @@ async function beginJournal(paths, oldArtifact, newArtifact, priorRegistration,
     await mkdir(paths.managerRoot, { recursive: true });
     await mkdir(paths.recoveryRoot, { mode: 0o700 });
     const recoveryIdentity = await identity(paths.recoveryRoot);
-    const path = join(paths.recoveryRoot, "transaction.json");
-    const handle = await open(path, "wx", 0o600);
-    try {
-        await handle.writeFile(bytes);
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-    await syncDirectoryStrict(paths.recoveryRoot);
+    const journalIdentity = await createJournal(paths.recoveryRoot, bytes);
     return {
         paths,
         canonicalRoot,
         recoveryIdentity,
-        backup: join(dirname(canonicalRoot), `.${basename(canonicalRoot)}.bak.${token}`),
-        stage: join(dirname(canonicalRoot), `.${basename(canonicalRoot)}.stage.${token}`),
+        ...publicationPaths(canonicalRoot, token),
         ctx,
         journal,
-        journalIdentity: await lstat(path),
+        journalIdentity,
         settled: false,
     };
 }
-async function retireJournal(pending) {
-    await requireJournal(pending);
-    if ((await readdir(pending.paths.recoveryRoot)).some((name) => name !== "transaction.json"))
-        throw new Error("unknown OpenCode recovery material");
-    await unlink(journalPath(pending));
-    await requireIdentity(pending.paths.recoveryRoot, pending.recoveryIdentity);
-    await rmdir(pending.paths.recoveryRoot);
-}
 async function recoveryGuidance(pending) {
     try {
         const kind = await classifyPathNoFollow(pending.paths.recoveryRoot);

package/dist/harnesses/opencode/native.js

@@ -1,57 +1,36 @@
-import { tmpdir } from "node:os";
-import { dirname, isAbsolute, resolve, sep } from "node:path";
+import { dirname, resolve } from "node:path";
 import { mkdir } from "node:fs/promises";
-import { failureResult, } from "../../adapter-result.js";
-import { nativeCommandResult, } from "../../harness-command-result.js";
+import {} from "../../adapter-result.js";
+import { runIsolatedNative, } from "../../harness-command-result.js";
 import { BOUNDED_EXECUTABLE, runValidator as runBoundedCommand, } from "../../validator.js";
-import { withWorkspace } from "../../workspace.js";
 const OPEN_CODE_EXECUTABLE = {
     ...BOUNDED_EXECUTABLE,
     inheritEnvironment: false,
 };
-function selectedExecutable(env, invocationCwd) {
-    const configured = env.SUPERPOWERS_OPENCODE || "opencode";
-    return configured.includes(sep) && !isAbsolute(configured)
-        ? resolve(invocationCwd, configured)
-        : configured;
-}
 export async function runOpenCode(args, paths, ctx, execute = runBoundedCommand) {
-    const operation = "opencode-command";
-    const env = ctx.env ?? {};
-    const executable = selectedExecutable(env, process.cwd());
-    let entered = false;
-    try {
-        return await withWorkspace(env.TMPDIR ?? tmpdir(), "superpowers-manager.opencode.", async (workspace) => {
-            entered = true;
-            const home = resolve(workspace, "home");
-            const data = resolve(workspace, "data");
-            const cache = resolve(workspace, "cache");
-            const state = resolve(workspace, "state");
-            const temporary = resolve(workspace, "tmp");
-            const managed = resolve(workspace, "managed");
-            await Promise.all([home, data, cache, state, temporary, managed].map((path) => mkdir(path)));
-            const result = await execute([executable, ...args], OPEN_CODE_EXECUTABLE, {
-                PATH: env.PATH,
-                HOME: home,
-                XDG_CONFIG_HOME: dirname(paths.configRoot),
-                XDG_DATA_HOME: data,
-                XDG_CACHE_HOME: cache,
-                XDG_STATE_HOME: state,
-                TMPDIR: temporary,
-                OPENCODE_DISABLE_AUTOUPDATE: "1",
-                OPENCODE_DISABLE_MODELS_FETCH: "1",
-                OPENCODE_DISABLE_PROJECT_CONFIG: "1",
-                OPENCODE_PURE: "1",
-                OPENCODE_TEST_MANAGED_CONFIG_DIR: managed,
-                GIT_CONFIG_GLOBAL: "/dev/null",
-                GIT_CONFIG_NOSYSTEM: "1",
-            }, temporary, workspace);
-            return nativeCommandResult("OpenCode", result);
-        });
-    }
-    catch {
-        return failureResult(operation, "workspace-failed", entered
-            ? "cannot complete OpenCode command in its isolated workspace"
-            : "cannot create an isolated OpenCode command workspace", [], []);
-    }
+    return await runIsolatedNative("OpenCode", (ctx.env ?? {}).SUPERPOWERS_OPENCODE || "opencode", ctx, async (executable, workspace, env) => {
+        const home = resolve(workspace, "home");
+        const data = resolve(workspace, "data");
+        const cache = resolve(workspace, "cache");
+        const state = resolve(workspace, "state");
+        const temporary = resolve(workspace, "tmp");
+        const managed = resolve(workspace, "managed");
+        await Promise.all([home, data, cache, state, temporary, managed].map((path) => mkdir(path)));
+        return await execute([executable, ...args], OPEN_CODE_EXECUTABLE, {
+            PATH: env.PATH,
+            HOME: home,
+            XDG_CONFIG_HOME: dirname(paths.configRoot),
+            XDG_DATA_HOME: data,
+            XDG_CACHE_HOME: cache,
+            XDG_STATE_HOME: state,
+            TMPDIR: temporary,
+            OPENCODE_DISABLE_AUTOUPDATE: "1",
+            OPENCODE_DISABLE_MODELS_FETCH: "1",
+            OPENCODE_DISABLE_PROJECT_CONFIG: "1",
+            OPENCODE_PURE: "1",
+            OPENCODE_TEST_MANAGED_CONFIG_DIR: managed,
+            GIT_CONFIG_GLOBAL: "/dev/null",
+            GIT_CONFIG_NOSYSTEM: "1",
+        }, temporary, workspace);
+    });
 }

package/dist/harnesses/opencode/package.js

@@ -1,10 +1,9 @@
 import { join } from "node:path";
-import { ARTIFACT_DIGEST_RE, ARTIFACT_RECEIPT, digestArtifactTree, readArtifactObject, validateNativeSkill, } from "../../artifact-tree.js";
-import { COMMIT_RE, SEMVER_RE } from "../../domain/refs.js";
+import { readArtifactObject, validateNativeSkill, } from "../../artifact-tree.js";
+import { SEMVER_RE } from "../../domain/refs.js";
 import { assertNoFollowType } from "../../safe-path.js";
 import { validateSource } from "../../selection.js";
-import { SafetyError } from "../../safety-error.js";
-import { isOfficialSnapshotSource, requireNoSnapshotDependencies, requireSnapshotBootstrap, snapshotReceiptBinding, } from "../../snapshot-package.js";
+import { createSnapshotReceipts, isOfficialSnapshotSource, requireNoSnapshotDependencies, requireSnapshotBootstrap, } from "../../snapshot-package.js";
 const BOOTSTRAP = ".opencode/plugins/superpowers.js";
 const ENTRYPOINT = "index.js";
 // Exact-byte allowlist, matched as a unit: a bootstrap and the V2 entrypoint
@@ -32,19 +31,6 @@ const QUALIFIED_PROFILES = [
         },
     },
 ];
-function isReceiptCompatibility(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const compatibility = value;
-    if (typeof compatibility.reason !== "string")
-        return false;
-    if (compatibility.kind === "supported" ||
-        compatibility.kind === "experimental")
-        return typeof compatibility.generation === "string";
-    return ((compatibility.kind === "unknown" ||
-        compatibility.kind === "unsupported") &&
-        compatibility.generation === undefined);
-}
 export async function assessOpenCodeCompatibility(root, selection) {
     try {
         validateSource(selection.effectiveSource);
@@ -84,41 +70,11 @@ export async function assessOpenCodeCompatibility(root, selection) {
         };
     }
 }
-export async function readOpenCodeReceipt(root) {
-    const path = join(root, ARTIFACT_RECEIPT);
-    try {
-        const value = await readArtifactObject(root, path);
-        if (value.schema !== 1 ||
-            value.manager !== "superpowers-manager" ||
-            value.harness !== "opencode" ||
-            typeof value.source !== "string" ||
-            typeof value.commit !== "string" ||
-            !COMMIT_RE.test(value.commit) ||
-            typeof value.digest !== "string" ||
-            !ARTIFACT_DIGEST_RE.test(value.digest) ||
-            typeof value.binding !== "string" ||
-            !ARTIFACT_DIGEST_RE.test(value.binding))
-            throw new Error("receipt fields");
-        validateSource(value.source);
-        if (snapshotReceiptBinding(value) !==
-            value.binding)
-            throw new Error("receipt binding");
-        if (!isReceiptCompatibility(value.compatibility))
-            throw new Error("receipt compatibility");
-        return value;
-    }
-    catch (cause) {
-        throw new SafetyError("opencode-package", `invalid OpenCode artifact receipt: ${path}`, { cause });
-    }
-}
-export async function readOpenCodePackageAssessment(root) {
-    const receipt = await readOpenCodeReceipt(root);
-    if ((await digestArtifactTree(root)) !== receipt.digest)
-        throw new SafetyError("opencode-package", `OpenCode artifact digest mismatch: ${root}`);
-    return {
-        receipt,
-        compatibility: await assessOpenCodeCompatibility(root, {
-            effectiveSource: receipt.source,
-        }),
-    };
-}
+const receipts = createSnapshotReceipts({
+    harness: "opencode",
+    label: "OpenCode",
+    strictGeneration: true,
+    assessCompatibility: assessOpenCodeCompatibility,
+});
+export const readOpenCodeReceipt = receipts.readReceipt;
+export const readOpenCodePackageAssessment = receipts.readAssessment;

package/dist/harnesses/opencode/prepare.js

@@ -2,12 +2,6 @@ import { failureResult, successResult, } from "../../adapter-result.js";
 import { createSnapshotPreparation } from "../../snapshot-prepare.js";
 import { assertOpenCodePreparationSeparate, openCodePaths } from "./paths.js";
 import { assessOpenCodeCompatibility, readOpenCodePackageAssessment, } from "./package.js";
-export function openCodePreparationLocation(ctx) {
-    return {
-        destinationRoot: openCodePaths(ctx.env ?? {}, process.cwd()).preparedRoot,
-        stagingLeaf: "superpowers",
-    };
-}
 export async function validateOpenCodePreparationBeforeFetch(ctx) {
     try {
         const paths = openCodePaths(ctx.env ?? {}, process.cwd());
@@ -21,10 +15,11 @@ export async function validateOpenCodePreparationBeforeFetch(ctx) {
 const preparation = createSnapshotPreparation({
     harness: "opencode",
     label: "OpenCode",
-    preparationLocation: openCodePreparationLocation,
+    paths: openCodePaths,
     assessCompatibility: assessOpenCodeCompatibility,
     readAssessment: readOpenCodePackageAssessment,
 });
+export const openCodePreparationLocation = preparation.preparationLocation;
 export const prepareOpenCodeCandidate = preparation.prepareCandidate;
 export const inspectOpenCodePrepared = preparation.inspectPrepared;
 export const readOpenCodePrepared = preparation.readPrepared;

package/dist/harnesses/opencode/presentation.js

@@ -1,5 +1,5 @@
 import { displaySource } from "../../selection.js";
-import { createSnapshotPresentation } from "../../snapshot-presentation.js";
+import { createSnapshotPresentation, probeOutput, } from "../../snapshot-presentation.js";
 import { displayPath } from "../../validator.js";
 const renderProbe = (facts) => {
     const fields = [
@@ -19,11 +19,6 @@ const renderProbe = (facts) => {
         ["compatibility_reason", facts.compatibility.reason],
         ["status", facts.status],
     ].map(([key, value]) => [key, displayPath(value)]);
-    return {
-        human: fields
-            .map(([key, value]) => `${key.replaceAll("_", " ")}: ${value || "not present"}\n`)
-            .join(""),
-        porcelain: fields.map(([key, value]) => `${key}=${value}\n`).join(""),
-    };
+    return probeOutput(fields);
 };
 export const openCodePresentation = createSnapshotPresentation("OpenCode", renderProbe, (input) => input.receiptDigest === null && input.registration === null);