skalpel 3.0.20 → 3.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skalpel",
-  "version": "3.0.20",
+  "version": "3.0.21",
   "description": "Skalpel — local proxy and TUI for coding agents (skalpel + skalpeld bundle).",
   "license": "Apache-2.0",
   "homepage": "https://skalpel.ai",
@@ -29,6 +29,7 @@
   },
   "scripts": {
     "postinstall": "node postinstall/index.js",
+    "preuninstall": "node postinstall/uninstall.js",
     "test": "echo 'no top-level tests; run make test or npm run test:rc-edit' && exit 0",
     "test:rc-edit": "node postinstall/lib/rc-edit.test.js"
   },
@@ -53,10 +54,10 @@
     "x64"
   ],
   "optionalDependencies": {
-    "@skalpelai/skalpel-darwin-arm64": "3.0.20",
-    "@skalpelai/skalpel-darwin-x64": "3.0.20",
-    "@skalpelai/skalpel-linux-arm64": "3.0.20",
-    "@skalpelai/skalpel-linux-x64": "3.0.20",
-    "@skalpelai/skalpel-win32-x64": "3.0.20"
+    "@skalpelai/skalpel-darwin-arm64": "3.0.21",
+    "@skalpelai/skalpel-darwin-x64": "3.0.21",
+    "@skalpelai/skalpel-linux-arm64": "3.0.21",
+    "@skalpelai/skalpel-linux-x64": "3.0.21",
+    "@skalpelai/skalpel-win32-x64": "3.0.21"
   }
 }

package/postinstall/lib/rc-edit.js

@@ -55,42 +55,86 @@ function shellEscapePsSQ(v) {
 // the line accurately reflects whether anything will happen on the
 // next request.
 //
+// Fail-open: if `skalpel status` exits non-zero (daemon down /
+// compressor off / config corrupt), we run claude with the proxy env
+// vars unset so requests reach Anthropic directly. Without this, a
+// crashed daemon would leave ANTHROPIC_BASE_URL pointing at a closed
+// port and every claude invocation would hang on connection refused.
+//
 // Self-disabling knobs:
 //   - SKALPEL_NO_AGENT_WRAP=1   → operator opt-out (env var, anywhere).
 //   - existing `claude` alias   → we don't override aliases.
 //   - `skalpel` not on PATH     → wrapper installs nothing.
 const agentWrapPosix = `
-# Pre-launch status hint for coding agents launched in this shell.
-# Status comes from \`skalpel status\` (checks daemon + engine config).
+# Pre-launch status hint + fail-open for coding agents in this shell.
+# Status comes from \`skalpel status\` (checks daemon + engine config);
+# non-zero exit ⇒ unset proxy env vars so claude reaches Anthropic
+# directly instead of hanging on a closed proxy port.
 # Set SKALPEL_NO_AGENT_WRAP=1 to disable.
 if [ -z "\${SKALPEL_NO_AGENT_WRAP:-}" ] && ! alias claude >/dev/null 2>&1 && command -v skalpel >/dev/null 2>&1; then
-  claude() { skalpel status >&2; command claude "$@"; }
+  claude() {
+    if skalpel status >&2; then
+      command claude "$@"
+    else
+      ANTHROPIC_API_URL= ANTHROPIC_BASE_URL= OPENAI_BASE_URL= OPENAI_API_BASE= SKALPEL_PROXY_URL= command claude "$@"
+    fi
+  }
 fi`;
 
 // agentWrapFish is the fish-shell port of agentWrapPosix.
 const agentWrapFish = `
-# Pre-launch status hint for coding agents launched in this shell.
-# Status comes from \`skalpel status\` (checks daemon + engine config).
+# Pre-launch status hint + fail-open for coding agents in this shell.
+# Status comes from \`skalpel status\` (checks daemon + engine config);
+# non-zero exit ⇒ unset proxy env vars so claude reaches Anthropic
+# directly instead of hanging on a closed proxy port.
 # Set SKALPEL_NO_AGENT_WRAP=1 to disable.
 if not set -q SKALPEL_NO_AGENT_WRAP; and not functions -q claude; and command -q skalpel
     function claude
-        skalpel status 1>&2
-        command claude $argv
+        if skalpel status 1>&2
+            command claude $argv
+        else
+            env -u ANTHROPIC_API_URL -u ANTHROPIC_BASE_URL -u OPENAI_BASE_URL -u OPENAI_API_BASE -u SKALPEL_PROXY_URL command claude $argv
+        end
     end
 end`;
 
 // agentWrapPosh is the PowerShell port. Same delegation: ask the
 // `skalpel` binary for the status, write it to stderr, then forward.
+// On non-zero exit, scrub the proxy env vars from the child's
+// environment for the one invocation (Remove-Item Env:… inside a
+// scoped script block), so claude reaches Anthropic directly.
 const agentWrapPosh = `
-# Pre-launch status hint for coding agents launched in this shell.
-# Status comes from \`skalpel status\` (checks daemon + engine config).
+# Pre-launch status hint + fail-open for coding agents in this shell.
+# Status comes from \`skalpel status\` (checks daemon + engine config);
+# non-zero exit ⇒ unset proxy env vars for the one claude invocation.
 # Set $env:SKALPEL_NO_AGENT_WRAP=1 to disable.
 $_skalpelOrigClaude = Get-Command claude.exe -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
 $_skalpelStatusBin = Get-Command skalpel -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
 if (-not $env:SKALPEL_NO_AGENT_WRAP -and $_skalpelOrigClaude -and $_skalpelStatusBin) {
     function global:claude {
         & $script:_skalpelStatusBin.Source status 1>&2
-        & $script:_skalpelOrigClaude.Source @args
+        if ($LASTEXITCODE -eq 0) {
+            & $script:_skalpelOrigClaude.Source @args
+        } else {
+            $_savedAnthropicApi = $env:ANTHROPIC_API_URL
+            $_savedAnthropicBase = $env:ANTHROPIC_BASE_URL
+            $_savedOpenAiBase = $env:OPENAI_BASE_URL
+            $_savedOpenAiApiBase = $env:OPENAI_API_BASE
+            $_savedSkalpelProxy = $env:SKALPEL_PROXY_URL
+            $env:ANTHROPIC_API_URL = ''
+            $env:ANTHROPIC_BASE_URL = ''
+            $env:OPENAI_BASE_URL = ''
+            $env:OPENAI_API_BASE = ''
+            $env:SKALPEL_PROXY_URL = ''
+            try { & $script:_skalpelOrigClaude.Source @args }
+            finally {
+                $env:ANTHROPIC_API_URL = $_savedAnthropicApi
+                $env:ANTHROPIC_BASE_URL = $_savedAnthropicBase
+                $env:OPENAI_BASE_URL = $_savedOpenAiBase
+                $env:OPENAI_API_BASE = $_savedOpenAiApiBase
+                $env:SKALPEL_PROXY_URL = $_savedSkalpelProxy
+            }
+        }
     }
 }`;
 
@@ -98,31 +142,53 @@ function bodyFor(shell, env) {
   const note =
     'This block is managed by skalpel install. Do not edit by hand;\n' +
     're-run `skalpel install` or `npx skalpel` to update.';
+  // The env exports themselves are gated on `skalpel` being on PATH.
+  // Why: npm v7+ silently drops the `preuninstall` lifecycle script,
+  // so `npm uninstall -g skalpel` removes the binary but leaves this
+  // managed block in place — without the gate, every NEW shell would
+  // re-export ANTHROPIC_BASE_URL pointing at a closed proxy port and
+  // every `claude` invocation would hang. The gate makes uninstall-
+  // by-any-mechanism (npm, brew, manual rm) auto-restore plain
+  // claude on next shell sourcing. The block itself becomes inert
+  // (cosmetic comment) but does no harm. `skalpel uninstall` is
+  // still the canonical full-cleanup entry point.
   switch (shell) {
     case 'fish':
       return [
         '# Managed by skalpel install; safe to delete.',
+        '# Gated on `skalpel` being on PATH so an uninstalled binary',
+        '# leaves no broken proxy env vars behind.',
+        'if command -q skalpel',
         ...Object.entries(env).map(
-          ([k, v]) => `set -gx ${k} "${shellEscapePosixDQ(v)}"`
+          ([k, v]) => `    set -gx ${k} "${shellEscapePosixDQ(v)}"`
         ),
-        agentWrapFish,
+        agentWrapFish.replace(/^/gm, '    ').replace(/^    $/gm, ''),
+        'end',
       ].join('\n');
     case 'powershell':
     case 'powershell-legacy':
       return [
         ...note.split('\n').map((l) => `# ${l}`),
+        '# Gated on `skalpel` being on PATH so an uninstalled binary',
+        '# leaves no broken proxy env vars behind.',
+        'if (Get-Command skalpel -CommandType Application -ErrorAction SilentlyContinue) {',
         ...Object.entries(env).map(
-          ([k, v]) => `$env:${k} = '${shellEscapePsSQ(v)}'`
+          ([k, v]) => `    $env:${k} = '${shellEscapePsSQ(v)}'`
         ),
-        agentWrapPosh,
+        agentWrapPosh.replace(/^/gm, '    ').replace(/^    $/gm, ''),
+        '}',
       ].join('\n');
     default:
       return [
         ...note.split('\n').map((l) => `# ${l}`),
+        '# Gated on `skalpel` being on PATH so an uninstalled binary',
+        '# leaves no broken proxy env vars behind.',
+        'if command -v skalpel >/dev/null 2>&1; then',
         ...Object.entries(env).map(
-          ([k, v]) => `export ${k}="${shellEscapePosixDQ(v)}"`
+          ([k, v]) => `  export ${k}="${shellEscapePosixDQ(v)}"`
         ),
-        agentWrapPosix,
+        agentWrapPosix.replace(/^/gm, '  ').replace(/^  $/gm, ''),
+        'fi',
       ].join('\n');
   }
 }

package/postinstall/uninstall.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// npm `preuninstall` hook — runs before `npm uninstall -g skalpel`
+// removes the package files. Without this, the managed rc-file block
+// (export ANTHROPIC_BASE_URL=http://127.0.0.1:7878 …) stays behind in
+// every shell config and leaves the user's claude CLI pointing at a
+// dead proxy port.
+//
+// Strategy: locate the platform-specific `skalpel` binary (which still
+// exists on disk at preuninstall time) and shell out to:
+//
+//   skalpel uninstall --keep-package --keep-data
+//
+// `--keep-package` skips any package-removal logic on the Go side
+// (npm is already doing that). `--keep-data` preserves auth.json /
+// config.toml so a follow-up `npm install -g skalpel` picks the user
+// back up where they left off; an explicit `skalpel uninstall` is
+// still the canonical "wipe everything" entry point.
+//
+// Best effort: any failure (missing platform package, exec error,
+// non-zero exit) prints a hint and exits 0 so the npm uninstall
+// itself is never blocked. The user can always re-run
+// `skalpel uninstall` if the binary is reachable.
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const PLATFORM_PACKAGES = {
+  'darwin-arm64': '@skalpelai/skalpel-darwin-arm64',
+  'darwin-x64': '@skalpelai/skalpel-darwin-x64',
+  'linux-arm64': '@skalpelai/skalpel-linux-arm64',
+  'linux-x64': '@skalpelai/skalpel-linux-x64',
+  'win32-x64': '@skalpelai/skalpel-win32-x64',
+};
+
+function findBinary() {
+  const exe = process.platform === 'win32' ? 'skalpel.exe' : 'skalpel';
+
+  // Local-dev override (mirrors npm-bin/skalpel.js): when set, look
+  // there first so a `npm link`-ed dev install can still uninstall.
+  const overrideDir = process.env.SKALPEL_BIN_DIR;
+  if (overrideDir) {
+    const c = path.join(overrideDir, exe);
+    if (fs.existsSync(c)) return c;
+  }
+
+  const key = `${process.platform}-${process.arch}`;
+  const pkg = PLATFORM_PACKAGES[key];
+  if (!pkg) return null;
+  let pkgRoot;
+  try {
+    pkgRoot = path.dirname(require.resolve(`${pkg}/package.json`));
+  } catch (_err) {
+    return null;
+  }
+  const c = path.join(pkgRoot, 'bin', exe);
+  return fs.existsSync(c) ? c : null;
+}
+
+(function main() {
+  // Allow operators to skip this hook entirely (e.g. CI tearing down
+  // a transient install on a shared box where rc edits don't matter).
+  if (process.env.SKALPEL_NO_PREUNINSTALL) {
+    return;
+  }
+  const bin = findBinary();
+  if (!bin) {
+    process.stderr.write(
+      '[skalpel] preuninstall: could not locate platform binary; ' +
+        'shell-rc env vars NOT removed. Run `skalpel uninstall` manually if the binary is still on PATH.\n'
+    );
+    return;
+  }
+  const args = ['uninstall', '--keep-package', '--keep-data'];
+  const r = spawnSync(bin, args, { stdio: 'inherit' });
+  if (r.error) {
+    process.stderr.write(
+      `[skalpel] preuninstall: failed to exec ${bin}: ${r.error.message}\n`
+    );
+    return;
+  }
+  if (typeof r.status === 'number' && r.status !== 0) {
+    process.stderr.write(
+      `[skalpel] preuninstall: \`${bin} ${args.join(' ')}\` exited ${r.status}; ` +
+        'rc/service cleanup may be incomplete.\n'
+    );
+  }
+})();