skalpel 3.1.5 → 3.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skalpel",
-  "version": "3.1.5",
+  "version": "3.1.7",
   "description": "Skalpel — local proxy and TUI for coding agents (skalpel + skalpeld bundle).",
   "license": "Apache-2.0",
   "homepage": "https://skalpel.ai",
@@ -28,11 +28,13 @@
     "skalpeld": "npm-bin/skalpeld.js"
   },
   "scripts": {
+    "preinstall": "node postinstall/preinstall.js",
     "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",
-    "test:postinstall": "node --test postinstall/index.test.js"
+    "test:postinstall": "node --test postinstall/index.test.js",
+    "test:preinstall": "node --test postinstall/preinstall.test.js"
   },
   "files": [
     "npm-bin/",
@@ -55,10 +57,10 @@
     "x64"
   ],
   "optionalDependencies": {
-    "@skalpelai/skalpel-darwin-arm64": "3.1.5",
-    "@skalpelai/skalpel-darwin-x64": "3.1.5",
-    "@skalpelai/skalpel-linux-arm64": "3.1.5",
-    "@skalpelai/skalpel-linux-x64": "3.1.5",
-    "@skalpelai/skalpel-win32-x64": "3.1.5"
+    "@skalpelai/skalpel-darwin-arm64": "3.1.7",
+    "@skalpelai/skalpel-darwin-x64": "3.1.7",
+    "@skalpelai/skalpel-linux-arm64": "3.1.7",
+    "@skalpelai/skalpel-linux-x64": "3.1.7",
+    "@skalpelai/skalpel-win32-x64": "3.1.7"
   }
 }

package/postinstall/lib/env-inject.js

@@ -45,8 +45,15 @@ function run({ dryRun, port }) {
   for (const rc of rcs) {
     const exists = fs.existsSync(rc.path);
     if (!exists) {
-      log.info(`env-inject: ${rc.shell} rc absent (${rc.path}) — skip`);
-      continue;
+      // BUG-0035: on Windows most users have no PowerShell $PROFILE yet,
+      // but the `claude` wrapper still must be installed — applyBlock
+      // creates the file (and parent dir). On POSIX, skip absent rc files
+      // (the present.length===0 fallback below bootstraps ~/.profile).
+      if (process.platform !== 'win32') {
+        log.info(`env-inject: ${rc.shell} rc absent (${rc.path}) — skip`);
+        continue;
+      }
+      log.info(`env-inject: ${rc.shell} rc absent (${rc.path}) — creating (Windows)`);
     }
     present.push(rc);
     if (dryRun) {

package/postinstall/lib/integrations.js

@@ -47,11 +47,11 @@ end`,
     powershell: `
 # Pre-launch status hint + fail-open for Claude Code.
 # Set $env:SKALPEL_NO_AGENT_WRAP=1 to disable.
-$_skalpelOrigClaude = Get-Command claude.exe -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
+$_skalpelOrigClaude = Get-Command claude -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:_skalpelStatusBin.Source status | Out-Host
         if ($LASTEXITCODE -eq 0) {
             & $script:_skalpelStatusBin.Source claude-exec @args
         } else {
@@ -134,11 +134,11 @@ end`,
     powershell: `
 # Codex CLI/App integration. Config overrides are native Codex -c knobs.
 # Set $env:SKALPEL_NO_AGENT_WRAP=1 to disable.
-$_skalpelOrigCodex = Get-Command codex.exe -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
+$_skalpelOrigCodex = Get-Command codex -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 $_skalpelOrigCodex -and $_skalpelStatusBin) {
     function global:codex {
-        & $script:_skalpelStatusBin.Source status 1>&2
+        & $script:_skalpelStatusBin.Source status | Out-Host
         if ($LASTEXITCODE -eq 0) {
             $_skalpelCodexHome = if ($env:CODEX_HOME) { $env:CODEX_HOME } else { Join-Path $HOME '.codex' }
             $_skalpelCodexAuthMode = ''

package/postinstall/lib/rc-edit.test.js

@@ -198,6 +198,26 @@ function run() {
     assert.ok(!block.includes('network.proxy_url'), 'Codex wrapper should not generic-proxy metadata routes');
   });
 
+  test('TestRcEdit_PowerShell_Wrapper_Valid_Syntax', () => {
+    // BUG-0036 regression: the PowerShell wrappers must not use `1>&2`
+    // (a PowerShell parse error → the whole profile block fails to load
+    // → the claude/codex functions are never defined → bare `claude`
+    // bypasses skalpel on Windows). And the original-binary lookup must
+    // target `claude`/`codex` (npm installs claude.cmd/.ps1 on Windows),
+    // not `claude.exe`/`codex.exe` (which don't exist → null → wrapper
+    // never engages).
+    const env = rc.envBlockValues(7878);
+    const block = rc.buildBlock('powershell', env);
+    assert.ok(!block.includes('1>&2'), 'PowerShell wrapper uses unsupported 1>&2 redirect');
+    assert.ok(!block.includes('claude.exe'), 'PowerShell wrapper looks up claude.exe (absent on npm Windows)');
+    assert.ok(!block.includes('codex.exe'), 'PowerShell wrapper looks up codex.exe (absent on npm Windows)');
+    assert.ok(
+      block.includes('Get-Command claude -CommandType Application'),
+      'PowerShell wrapper should resolve claude via Get-Command claude'
+    );
+    assert.ok(block.includes('| Out-Host'), 'PowerShell wrapper should route status output via | Out-Host');
+  });
+
   process.stdout.write(`\n  pass=${pass} fail=${fail}\n`);
   return fail === 0 ? 0 : 1;
 }

package/postinstall/preinstall.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// Preinstall hook — runs BEFORE npm extracts/overwrites the package's
+// files in node_modules. The job of this script is narrow and
+// Windows-specific: stop the running skalpeld daemon (and the
+// Scheduled Task that auto-restarts it) so npm can atomically rename
+// the new skalpeld.exe over the old one without tripping EBUSY /
+// EPERM / "The process cannot access the file because it is being
+// used by another process".
+//
+// On Linux and macOS this is a no-op: those kernels permit replacing
+// the file backing a running executable (the running process keeps
+// its old inode until it exits), and the existing service supervisor
+// (systemd / launchd) will pick up the new binary on the next restart.
+//
+// Failure mode contract: this script ALWAYS exits 0. Returning a
+// non-zero status from preinstall aborts the install with a confusing
+// "ELIFECYCLE" error; the right thing to do when we cannot find or
+// stop the daemon is to log and let the (real) install proceed,
+// because the EBUSY is downstream from us anyway. A fresh install
+// (no prior daemon running) is the common case and we must not break
+// it.
+//
+// History:
+//   - BUG-0037 (2026-05-22): added this script after npm upgrade of
+//     skalpel 3.1.4→3.1.6 on Windows failed with EBUSY because the
+//     v3.1.4 daemon (started by the scheduled task on the previous
+//     reboot) held skalpeld.exe open.
+
+'use strict';
+
+if (process.platform !== 'win32') {
+  // Other platforms are unaffected. Exit silently — preinstall scripts
+  // run on every install regardless of platform and noise is not
+  // helpful here.
+  process.exit(0);
+}
+
+const { spawnSync } = require('child_process');
+
+const TASK_NAME = 'Skalpel\\skalpel-daemon';
+const SHUTDOWN_TIMEOUT_MS = 8000;
+const POST_STOP_SETTLE_MS = 750;
+
+function step(msg) {
+  process.stdout.write(`skalpel preinstall: ${msg}\n`);
+}
+
+function tryRun(label, cmd, args, opts = {}) {
+  const r = spawnSync(cmd, args, { stdio: 'pipe', timeout: 15000, ...opts });
+  if (r.error) {
+    step(`  ${label}: ${r.error.code || 'error'} (skipped)`);
+    return false;
+  }
+  if (typeof r.status === 'number' && r.status === 0) {
+    step(`  ${label}: ok`);
+    return true;
+  }
+  // Non-zero is expected when the daemon/task isn't present (fresh
+  // install) or already stopped. Don't surface stderr to avoid scary
+  // output during a normal first install.
+  step(`  ${label}: skipped (status=${r.status ?? '?'})`);
+  return false;
+}
+
+function sleepSync(ms) {
+  // Atomics.wait blocks the event loop without spawning a child
+  // process. Reliable on Node ≥ 18.
+  const sab = new SharedArrayBuffer(4);
+  Atomics.wait(new Int32Array(sab), 0, 0, Math.max(0, ms | 0));
+}
+
+step('win32 detected — stopping running daemon before binary replace');
+
+// Step 1: End the Scheduled Task. This prevents the
+// RestartOnFailure=Count=9999 loop in Task.xml from racing with the
+// upcoming taskkill, which would otherwise re-spawn skalpeld.exe
+// while npm is mid-rename. schtasks /End is idempotent — exits
+// non-zero when the task doesn't exist, which we ignore.
+tryRun('schtasks /End', 'schtasks.exe', ['/End', '/TN', TASK_NAME]);
+
+// Step 2: Best-effort graceful shutdown via the OLD skalpel CLI (still
+// on disk at this point — preinstall runs BEFORE npm overwrites
+// anything). `skalpel daemon stop` talks to the daemon over IPC,
+// triggers a clean drain (drains proxy + IPC subscribers + flushes
+// stats cache), and waits for the lock file to disappear. Times out
+// at SHUTDOWN_TIMEOUT_MS; we don't pass --force because the next step
+// will taskkill anything still hanging on. The CLI may resolve via
+// PATH (`skalpel.cmd` shim) — use shell:true so cmd.exe walks PATHEXT.
+tryRun(
+  'skalpel daemon stop (graceful)',
+  `skalpel daemon stop --wait ${Math.floor(SHUTDOWN_TIMEOUT_MS / 1000)}s`,
+  [],
+  { shell: true, timeout: SHUTDOWN_TIMEOUT_MS + 2000 }
+);
+
+// Step 3: Belt-and-braces — taskkill any skalpeld.exe still running
+// (e.g. when the OLD CLI wasn't on PATH, or the graceful stop hit a
+// daemon variant from before the IPC drain was reliable). /F because
+// the previous step already gave it a chance to drain; the lock file
+// + stats cache flush are owned by the running process and we accept
+// the cost of skipping them when graceful failed.
+tryRun('taskkill /F skalpeld.exe', 'taskkill.exe', ['/F', '/IM', 'skalpeld.exe', '/T']);
+
+// Step 4: brief settle — even after TerminateProcess returns, the OS
+// can take a few hundred ms to release the open handles on
+// skalpeld.exe (handle table cleanup is async w.r.t. process exit).
+// Without this, npm's rename can still EBUSY race the OS.
+sleepSync(POST_STOP_SETTLE_MS);
+
+step('done — proceeding with install');
+process.exit(0);

package/postinstall/preinstall.test.js

@@ -0,0 +1,47 @@
+// preinstall.test.js — sanity checks for postinstall/preinstall.js.
+//
+// The preinstall script is Windows-specific and shells out to
+// schtasks.exe / taskkill.exe / skalpel.cmd. We can't fully drive
+// those from a Linux test runner, but we CAN verify:
+//   1. The script is syntactically valid JS (the test file `require`s
+//      it indirectly via a `node --check`-style import in a child).
+//   2. On non-Windows, it exits 0 immediately without attempting any
+//      shell-out (the operative branch for CI Linux runners).
+//   3. The exit code under any condition is 0 (preinstall must never
+//      block a real install).
+
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert');
+const { spawnSync } = require('node:child_process');
+const path = require('node:path');
+
+const SCRIPT = path.join(__dirname, 'preinstall.js');
+
+test('preinstall: syntactically valid (node --check)', () => {
+  const r = spawnSync(process.execPath, ['--check', SCRIPT], { encoding: 'utf8' });
+  assert.strictEqual(r.status, 0, `node --check failed: ${r.stderr}`);
+});
+
+test('preinstall: on non-win32 exits 0 immediately with no shell-out', { skip: process.platform === 'win32' }, () => {
+  const r = spawnSync(process.execPath, [SCRIPT], {
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  assert.strictEqual(r.status, 0, `non-win32 preinstall expected status 0, got ${r.status} stderr=${r.stderr}`);
+  // No "win32 detected" log line on non-Windows hosts.
+  assert.ok(
+    !/win32 detected/.test(r.stdout || ''),
+    'non-win32 host should not log win32-detected branch'
+  );
+});
+
+test('preinstall: always exits 0 even on simulated win32 (preserves install when shells missing)', { skip: process.platform === 'win32' }, () => {
+  // On Linux we can't truly exercise the win32 branch (schtasks.exe
+  // isn't present), but we can verify the contract that the script
+  // never throws unhandled. Without spoofing process.platform that's
+  // limited to the non-win32 path tested above; the contract is
+  // covered there. This placeholder documents the contract.
+  assert.ok(true);
+});