superpowers-manager 0.5.1 → 0.5.2

package/dist/harnesses/codex/paths.js

@@ -0,0 +1,97 @@
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { assertNoFollowType, canonicalizeProspectivePath, } from "../../safe-path.js";
+import { SafetyError } from "../../safety-error.js";
+export function codexHome(env, cwd) {
+    const configured = env.CODEX_HOME;
+    if (configured !== undefined && configured.length > 0) {
+        return resolve(cwd, configured);
+    }
+    const home = env.HOME;
+    if (home === undefined || home.length === 0) {
+        throw new SafetyError("codex-paths", "cannot determine Codex state root without HOME");
+    }
+    return join(resolve(cwd, home), ".codex");
+}
+export function codexPaths(env, cwd) {
+    const root = codexHome(env, cwd);
+    const managerRoot = join(root, "superpowers-manager");
+    const marketplaceRoot = join(managerRoot, "marketplace");
+    return {
+        codexHome: root,
+        managerRoot,
+        preparedRoot: join(managerRoot, "prepared"),
+        marketplaceRoot,
+        publishedPluginRoot: join(marketplaceRoot, "plugins", "superpowers"),
+        recoveryRoot: join(managerRoot, "recovery"),
+    };
+}
+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);
+}
+function separationError() {
+    return new SafetyError("codex-paths", "preparation overlaps Codex published or recovery storage", { details: { kind: "overlap" } });
+}
+async function inspectRoot(path, root) {
+    try {
+        await assertNoFollowType(path, ["directory", "missing"]);
+        return await canonicalizeProspectivePath(path);
+    }
+    catch (cause) {
+        throw new SafetyError("codex-paths", `cannot inspect ${root} root: ${path}`, { cause, details: { kind: "inspection", root, path } });
+    }
+}
+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 };
+}
+export async function assertCodexPreparationSeparate(preparedRoot, paths) {
+    const recovery = await inspectRoot(paths.recoveryRoot, "recovery");
+    const marketplace = await inspectRoot(paths.marketplaceRoot, "marketplace");
+    let prepared;
+    try {
+        prepared = await inspectRoot(preparedRoot, "preparation");
+    }
+    catch (cause) {
+        const failure = codexPathFailureDetails(cause);
+        if (failure?.kind !== "inspection" || failure.root !== "preparation") {
+            throw cause;
+        }
+        try {
+            const canonical = await canonicalizeProspectivePath(preparedRoot);
+            if (overlaps(canonical, marketplace) || overlaps(canonical, recovery)) {
+                throw separationError();
+            }
+        }
+        catch (resolutionCause) {
+            if (codexPathFailureDetails(resolutionCause)?.kind === "overlap") {
+                throw resolutionCause;
+            }
+        }
+        throw cause;
+    }
+    if (overlaps(prepared, marketplace) || overlaps(prepared, recovery)) {
+        throw separationError();
+    }
+}

package/dist/harnesses/codex/prepare.js

@@ -9,6 +9,8 @@ import { readGeneratedCommitLenient, readStrictProvenanceField, writeProvenance,
 import { classifyPathNoFollow } from "../../safe-path.js";
 import { SafetyError } from "../../safety-error.js";
 import { manifestVersionForRef } from "../../upstream-version.js";
+import { assertCodexPreparationSeparate, codexPathFailureDetails, codexPaths, } from "./paths.js";
+import { readCodexRecovery } from "./recovery.js";
 // Order is inherited from the original prepare command; the first miss wins.
 const REQUIRED_UPSTREAM = [
     { path: "skills", label: "skills/" },
@@ -75,7 +77,7 @@ async function copyPathIfPresent(source, destination) {
     await owned(`cannot clear candidate path: ${destination}`, () => rm(destination, { recursive: true, force: true }));
     await owned(`cannot copy upstream path into candidate: ${source}`, () => cp(source, destination, { recursive: true, verbatimSymlinks: true }));
 }
-export function resolveFromCwd(value, cwd) {
+function resolveFromCwd(value, cwd) {
     return isAbsolute(value) ? value : resolve(cwd, value);
 }
 function manifestTemplate(ctx) {
@@ -86,11 +88,41 @@ function manifestTemplate(ctx) {
 export function codexPreparationLocation(ctx) {
     const env = ctx.env ?? {};
     return {
-        destinationRoot: resolveFromCwd(env.SUPERPOWERS_PLUGIN_ROOT || join(ctx.root, "plugins", "superpowers"), process.cwd()),
+        destinationRoot: env.SUPERPOWERS_PLUGIN_ROOT !== undefined &&
+            env.SUPERPOWERS_PLUGIN_ROOT.length > 0
+            ? resolveFromCwd(env.SUPERPOWERS_PLUGIN_ROOT, process.cwd())
+            : codexPaths(env, process.cwd()).preparedRoot,
         stagingLeaf: "superpowers",
     };
 }
 export async function validateCodexPreparationBeforeFetch(ctx) {
+    const paths = codexPaths(ctx.env ?? {}, process.cwd());
+    const preparedRoot = codexPreparationLocation(ctx).destinationRoot;
+    try {
+        await assertCodexPreparationSeparate(preparedRoot, paths);
+    }
+    catch (cause) {
+        const failure = codexPathFailureDetails(cause);
+        if (failure?.kind === "inspection") {
+            if (failure.root === "recovery") {
+                return failureResult("prepare", "recovery-required", `cannot inspect Codex recovery state at ${paths.recoveryRoot}`, [], []);
+            }
+            return failureResult("prepare", "prepare-failed", failure.root === "marketplace"
+                ? `cannot inspect Codex marketplace storage at ${paths.marketplaceRoot}`
+                : `cannot inspect Codex preparation root at ${preparedRoot}`, [], []);
+        }
+        return failureResult("prepare", failure?.kind === "overlap" ? "preparation-overlap" : "prepare-failed", failure?.kind === "overlap"
+            ? `Codex preparation overlaps Codex published or recovery storage: ${preparedRoot}`
+            : `cannot validate Codex preparation storage separation at ${preparedRoot}`, [], []);
+    }
+    try {
+        if ((await readCodexRecovery(paths)) !== null) {
+            return failureResult("prepare", "recovery-required", `Codex recovery is required before preparation; preserve material at ${paths.recoveryRoot}`, [], []);
+        }
+    }
+    catch {
+        return failureResult("prepare", "recovery-required", `cannot inspect Codex recovery state at ${paths.recoveryRoot}`, [], []);
+    }
     const template = manifestTemplate(ctx);
     if (!(await regularFileExists(template))) {
         return failureResult("prepare", "missing-template", `missing fallback manifest template: ${template}`, [], []);

package/dist/harnesses/codex/presentation.js

@@ -2,7 +2,7 @@ import { normalizeCodexInstall, normalizeCodexInstalled } from "./harness.js";
 import { displaySource } from "../../selection.js";
 // One ordered table drives both formats, preserving the public human and
 // porcelain field order exposed through the harness presentation.
-export function fields(f) {
+function fields(f) {
     return [
         { key: "harness", label: "harness", value: f.harness },
         { key: "requested_ref", label: "requested ref", value: f.requestedRef },
@@ -251,17 +251,18 @@ export const codexPresentation = {
         if (inspection.outcome.result.kind === "current") {
             return { stdout: [...stdout, "manager updated"], stderr: [] };
         }
+        const missing = inspection.outcome.result.kind === "absent" || observed.length === 0;
         if (receipt.status !== 0 || !receipt.outcome.ok) {
             return {
                 stdout,
                 stderr: [
-                    inspection.outcome.result.kind === "absent"
+                    missing
                         ? "error: installed manager fingerprint is not detectable after install."
                         : "error: installed manager fingerprint does not match the prepared plugin after install.",
                 ],
             };
         }
-        const output = inspection.outcome.result.kind === "absent"
+        const output = missing
             ? receipt.outcome.result.missingVerificationOutput
             : receipt.outcome.result.mismatchVerificationOutput;
         return { stdout, stderr: output.stderr };