superpowers-manager 0.8.0 → 0.9.0

package/dist/workspace.js

@@ -3,17 +3,11 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { SafetyError } from "./safety-error.js";
 const MANAGED_SIGNALS = ["SIGHUP", "SIGINT", "SIGTERM"];
-// Each active workspace carries its caller's failure reporter. The signal
-// path still invokes it, for parity with the normal path, but a signal death
-// never builds a result outcome (see src/adapter-result.ts), so a report
-// that only lands in the adapter's buffered log would never become
-// observable — the signal path therefore also writes the hand-written
-// diagnostic straight to process.stderr, unconditionally; that raw write is
-// the only thing actually visible to a caller. Previously the signal path
-// called the module-private cleanup and swallowed the rejection in
-// Promise.allSettled, so a signal-time failure was silent entirely — this is
-// the state PR 11.4 removed from the normal path.
-const active = new Map();
+// Workspaces the signal path must remove. A signal death never builds a
+// result outcome (see src/adapter-result.ts), so the signal path writes its
+// hand-written diagnostic straight to process.stderr; that write is the only
+// report a caller can observe.
+const active = new Set();
 let exiting = false;
 const handlers = new Map();
 // One phrasing for one condition. The adapter re-emits this for a suppressed
@@ -40,29 +34,18 @@ function cleanupForSignal(signal) {
     if (exiting)
         return;
     exiting = true;
-    for (const [path, report] of active) {
+    for (const path of active) {
         try {
             rmSync(path, { recursive: true, force: true });
         }
         catch {
-            // The reporter is invoked for parity with the normal path, but nothing
-            // ever reads it back here — no outcome is built before the process
-            // dies — so the diagnostic is also written straight to stderr,
-            // unconditionally; that write is the only thing actually observable.
             // The diagnostic is hand-written and names the workspace; the caught
-            // cause is not interpolated.
-            //
-            // Reporting is guarded: if either call throws — plausibly EPIPE after
-            // SIGHUP, when the process on the other end of the pipe is already
-            // gone — the exception must not escape this loop, or the remaining
-            // workspaces' cleanup, deregistration, and the re-raise below never run.
+            // cause is not interpolated. Guarded: if the write throws — plausibly
+            // EPIPE after SIGHUP — the remaining workspaces' cleanup,
+            // deregistration, and the re-raise below must still run. Node documents
+            // pipe writes as asynchronous on some platforms (notably macOS); small
+            // buffers like this one are written inline.
             try {
-                if (report)
-                    report(path);
-                // Node documents pipe writes as asynchronous on some platforms
-                // (notably macOS); a saturated pipe could drop this write. Small
-                // buffers like this one are written inline, which is why the
-                // covering test observes it reliably.
                 process.stderr.write(`${workspaceRemovalFailure(path)}\n`);
             }
             catch {
@@ -96,7 +79,7 @@ function deregisterCoordinator() {
         process.off(signal, handler);
     handlers.clear();
 }
-export async function withWorkspace(parent, prefix, fn, options = {}) {
+async function runInWorkspace(parent, prefix, fn, options, reportCleanupFailure) {
     const remove = options.cleanup ?? cleanup;
     let workspace;
     try {
@@ -105,35 +88,46 @@ export async function withWorkspace(parent, prefix, fn, options = {}) {
     catch (cause) {
         throw new SafetyError("workspace", "cannot create workspace", { cause });
     }
-    active.set(workspace, options.onCleanupFailure);
+    active.add(workspace);
     registerCoordinator();
     try {
-        let result;
+        let value;
         let failed = false;
         let callbackError;
         try {
-            result = await fn(workspace);
+            value = await fn(workspace);
         }
         catch (error) {
             failed = true;
             callbackError = error;
         }
+        let cleanupWarning = null;
         try {
             await remove(workspace);
         }
         catch (cleanupError) {
             if (failed)
                 throw callbackError;
-            if (options.onCleanupFailure === undefined)
+            if (!reportCleanupFailure)
                 throw cleanupError;
-            options.onCleanupFailure(workspace);
+            cleanupWarning = workspaceRemovalFailure(workspace);
         }
         if (failed)
             throw callbackError;
-        return result;
+        return { value, cleanupWarning };
     }
     finally {
         active.delete(workspace);
         deregisterCoordinator();
     }
 }
+export async function withWorkspace(parent, prefix, fn, options = {}) {
+    return (await runInWorkspace(parent, prefix, fn, options, false)).value;
+}
+// Like withWorkspace, except a cleanup failure after a SUCCESSFUL callback is
+// returned as `cleanupWarning` instead of thrown, so the caller keeps the value
+// it already computed and reports the leak itself. A callback throw still
+// propagates, and a cleanup failure never masks it.
+export function withWorkspaceReporting(parent, prefix, fn, options = {}) {
+    return runInWorkspace(parent, prefix, fn, options, true);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "superpowers-manager",
-  "version": "0.8.0",
-  "description": "Install obra/superpowers directly from upstream for Codex, Pi, and OpenCode. Stay on a known-good release or commit, try a branch, and upgrade when you choose.",
+  "version": "0.9.0",
+  "description": "Install obra/superpowers directly from upstream for Codex, Pi, OpenCode, and Claude Code. Stay on a known-good release or commit, try a branch, and upgrade when you choose.",
   "keywords": [
     "superpowers",
     "obra-superpowers",
@@ -18,21 +18,22 @@
     "pi",
     "pi-coding-agent",
     "opencode",
+    "claude-code",
+    "claude-code-plugin",
     "version-pinning"
   ],
   "license": "MIT",
   "type": "module",
-  "packageManager": "pnpm@12.4.0",
+  "packageManager": "pnpm@12.4.2",
   "scripts": {
-    "lint": "oxlint src/ tests/bin/ tests/unit/ tests/baseline/ tests/lib/ tests/tools/ tests/container/ tests/run-node-suites.ts tests/assert-matcher-gate.ts",
-    "format": "prettier --write src/ tests/bin/ tests/unit/ tests/baseline/ tests/lib/ tests/tools/ tests/container/ tests/run-node-suites.ts tests/assert-matcher-gate.ts",
-    "format:check": "prettier --check src/ tests/bin/ tests/unit/ tests/baseline/ tests/lib/ tests/tools/ tests/container/ tests/run-node-suites.ts tests/assert-matcher-gate.ts",
-    "test": "node tests/run-node-suites.ts",
-    "test:unit": "node tests/run-node-suites.ts --group unit",
-    "test:integration": "node tests/run-node-suites.ts --group integration",
+    "lint": "oxlint src/ tests/",
+    "format": "prettier --write src/ tests/",
+    "format:check": "prettier --check src/ tests/",
+    "test": "sh tests/run.sh",
     "test:harness:codex": "sh tests/container.sh harness-codex",
     "test:harness:pi": "sh tests/container.sh harness-pi",
     "test:harness:opencode": "sh tests/container.sh harness-opencode",
+    "test:harness:claude-code": "sh tests/container.sh harness-claude-code",
     "test:acceptance": "sh tests/acceptance.sh",
     "check:static": "pnpm run format:check && pnpm run lint && pnpm run typecheck && pnpm run knip",
     "check": "pnpm run check:static && pnpm run test",

package/dist/python-json.js

@@ -1,4 +0,0 @@
-import { escapeNonAscii } from "./python-json-format.js";
-export function escapePythonJsonString(value) {
-    return escapeNonAscii(JSON.stringify(value).slice(1, -1));
-}

package/dist/upstream-workspace.js

@@ -1,8 +0,0 @@
-import { isAbsolute, join, resolve } from "node:path";
-export function upstreamCacheRoot(root, env, cwd) {
-    const configured = env.SUPERPOWERS_CACHE_DIR || join(root, ".cache", "upstream");
-    const cacheParent = isAbsolute(configured)
-        ? configured
-        : resolve(cwd, configured);
-    return join(cacheParent, "superpowers");
-}