lockpicks 0.8.0-go.10 → 0.8.0-go.11

package/README.md

@@ -5,7 +5,7 @@ Read your Lockpick results from the terminal, and give coding agents the same ac
 ## Sign in
 
 ```bash
-npx lockpicks login --host https://<your-lockpick>
+npx --allow-scripts=lockpicks lockpicks@latest login --host https://<your-lockpick>
 ```
 
 The browser opens a device page. Confirm the code, pick a workspace and approve. To let the key start Pulse scans, tick **Start Pulse scans on sites I own or may test** under **Also allow**; that box is your statement that you own the workspace's sites or may test them, and each Pulse started with the key is recorded under your name. Without it the key only reads. **Add and switch sites** lets the key add sites (`lockpick sites add`) and switch your free site. **Prepare Deep scans I approve** lets the key prepare Deep scans (`lockpick deep`); each still needs a verified ownership proof and your approval of that exact scan in Lockpick. `lockpick login --pulse --sites --deep` marks what the terminal asks for, but the browser never ticks anything for you and the key gets exactly what you tick. `lockpick whoami` shows what the key can do. The terminal receives a key bound to that workspace, stored in your OS keychain (or `~/.config/lockpick/config.json`, mode 0600, when no keychain is available). Each use extends the key; an idle key expires after the workspace's lifetime (30 days by default). Revoke it with `lockpick logout` or in the web app under **Workspace settings → CLI & agent access**.
@@ -13,10 +13,12 @@ The browser opens a device page. Confirm the code, pick a workspace and approve.
 After an `npx` login, the CLI offers to install itself so you can type `lockpick` (or `lockpicks`) instead of `npx lockpicks`. To do it yourself:
 
 ```bash
-npm install -g lockpicks
+npm install -g --allow-scripts=lockpicks lockpicks
 ```
 
-With it installed, `lockpick mcp config` points agents at `lockpick mcp`; without it, at `npx -y lockpicks mcp`.
+`--allow-scripts=lockpicks` lets npm 12 run the install script that makes `lockpick` the native binary; npm 10 and 11 accept it (npm 11 prints a warning you can ignore). With npx it goes before the package name, and the package is `lockpicks@latest`: with a bare name npx runs whatever `lockpicks` is installed globally, however old. In a project, npm 12 refuses the flag: allow the script in `package.json` with `"allowScripts": { "lockpicks": true }` instead.
+
+With it installed (the same version you run), `lockpick mcp config` points agents at `lockpick mcp`; otherwise, an older global install included, at `npx -y --allow-scripts=lockpicks lockpicks@latest mcp`.
 
 Use HTTPS for a remote Lockpick host; a host without a scheme (`lockpick.app`) means HTTPS, and a local one (`studio-mac:3000`) means HTTP. HTTP is accepted for local network and Tailscale development hosts. The CLI never follows redirects during API calls, so a saved key stays on its selected host: when a host only moves to its canonical address (`lockpick.app` to `www.lockpick.app`), `login`, which sends no key, signs in there and saves that address, and every other command names the address to use. `--host` takes precedence over `LOCKPICK_HOST`, which takes precedence over the last login. Each host has its own saved profile; `lockpick logout --host <url>` revokes and removes only that host's key. When the OS keychain is unavailable, the CLI writes the config through a private temporary file and replaces the old file only after the new one is complete. If the config is damaged, repair it before logging in again; the CLI will not silently discard saved profiles.
 
@@ -81,7 +83,7 @@ A new link checks every lockfile in the repository (at most 20, the most-used la
 
 `lockpick share create <runId>` publishes a completed Pulse result at a public link (a key allowed to start Pulses). Lockpick shows the link only to the call that makes it: run it again and it says the result is already shared, with no link; `--replace` makes a new link and the old one stops working, and `lockpick share revoke` stops sharing. `lockpick export <runId> --out <file>` writes the scan's PDF to exactly that file, creating it so that an existing file is never replaced unless you pass `--force`.
 
-`--fail-on critical|high|medium|low` on `pulse`, `recheck`, `watch`, `deep start` and `findings` exits `8` when open findings are that severe or worse, for CI. `lockpick ci init <site>` writes a GitHub Actions workflow that runs `npx -y lockpicks@<this version> pulse <site> --fail-on high` with the key from the `LOCKPICK_KEY` repository secret; it runs on published releases and by hand only, because each run uses a Pulse.
+`--fail-on critical|high|medium|low` on `pulse`, `recheck`, `watch`, `deep start` and `findings` exits `8` when open findings are that severe or worse, for CI. `lockpick ci init <site>` writes a GitHub Actions workflow that runs `npx -y --allow-scripts=lockpicks lockpicks@<this version> pulse <site> --fail-on high` with the key from the `LOCKPICK_KEY` repository secret; it runs on published releases and by hand only, because each run uses a Pulse.
 
 Text from scanned sites and saved briefs can carry terminal escape sequences. The CLI neutralizes every control character in API responses before printing them (an escape shows as `␛`), and keeps only its own colours on the way out, so a scanned page cannot clear your screen, write your clipboard or hide a link. Ids are checked before they go into a URL, and the key is never printed, even when a server error repeats it.
 

package/THIRD-PARTY-NOTICES.txt

@@ -1,4 +1,4 @@
-The lockpicks package contains only Lockpick's own launcher (bin/lockpick.cjs)
-and no third-party code. The Lockpick CLI binary it runs comes in the matching
+The lockpicks package contains only Lockpick's own launcher (bin/lockpick.exe)
+and install script (install.cjs), and no third-party code. The Lockpick CLI binary it runs comes in the matching
 @lockpicks/cli-<os>-<cpu> package, whose THIRD-PARTY-NOTICES.txt lists Go and every
 module linked into that binary.

package/bin/{lockpick.cjs → lockpick.exe}

@@ -1,14 +1,18 @@
 #!/usr/bin/env node
-// The `lockpicks` npm shim for the Go build of the Lockpick CLI: it finds the
-// platform package npm installed (`@lockpicks/cli-<os>-<cpu>`, an optional
-// dependency) and runs its binary.
-// It has no install scripts. LOCKPICK_LAUNCH tells the binary how it was
-// launched, decided from this script's path exactly as the TypeScript CLI's
-// launchKind decides it from its own.
+// The `lockpicks` npm launcher for the Go build of the Lockpick CLI, shipped
+// as bin/lockpick.exe: it finds the platform package npm installed
+// (`@lockpicks/cli-<os>-<cpu>`, an optional dependency) and runs its binary.
+// The preinstall script (install.cjs) replaces this file with that binary
+// wherever the package manager allows, so this is the fallback: install
+// scripts skipped (`--ignore-scripts`, pnpm, bun without trust), yarn 2 and
+// later, or yarn 1 and bun on Windows. LOCKPICK_LAUNCH tells the binary how
+// it was launched, decided from this script's path exactly as the TypeScript
+// CLI's launchKind decides it from its own (and as the binary decides it
+// from its own path when it is the command).
 'use strict';
 
 const { spawn } = require('node:child_process');
-const { realpathSync } = require('node:fs');
+const { readFileSync, realpathSync } = require('node:fs');
 const { delimiter, join, sep } = require('node:path');
 
 const PACKAGE_DIR = `${sep}lockpicks${sep}`;
@@ -21,7 +25,29 @@ function real(path) {
   }
 }
 
-function launchKind(script, pathEnv) {
+// The version of the lockpicks install that holds file, or null.
+function installedVersion(file) {
+  const at = file.lastIndexOf(PACKAGE_DIR);
+  if (at < 0) return null;
+  try {
+    const manifest = JSON.parse(
+      readFileSync(
+        join(file.slice(0, at + PACKAGE_DIR.length), 'package.json'),
+        'utf8'
+      )
+    );
+    return manifest.name === 'lockpicks' && typeof manifest.version === 'string'
+      ? manifest.version
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+// `path` when a `lockpick` on PATH is this file or another install of this
+// package at this version (an older or newer global must not take over an
+// npx run's MCP entry); then `npx`, `package` or `checkout`.
+function launchKind(script, pathEnv, version) {
   const self = real(script) ?? script;
   const parts = self.split(sep);
   const installed = parts.includes('node_modules');
@@ -32,7 +58,7 @@ function launchKind(script, pathEnv) {
         : null;
     return (
       found !== null &&
-      (found === self || (installed && found.includes(PACKAGE_DIR)))
+      (found === self || (installed && installedVersion(found) === version))
     );
   });
   if (onPath) return 'path';
@@ -45,9 +71,10 @@ function launchKind(script, pathEnv) {
 // file into its environment before any JavaScript runs: a `NODE_OPTIONS` in
 // it has already run its preloads by now, and its other variables would
 // reach the binary. That is Node's behaviour, met by every Node launcher, and
-// nothing here can undo it; the CLI's flag for a repository's env file is
-// `--dotenv` so no one is told to pass it. Refuse the old name rather than
-// hand the binary an environment the file chose.
+// nothing here can undo it (the binary as the command, above, never meets
+// it); the CLI's flag for a repository's env file is `--dotenv` so no one is
+// told to pass it. Refuse the old name rather than hand the binary an
+// environment the file chose.
 const args = process.argv.slice(2);
 const end = args.indexOf('--');
 const nodeEnvFile = (end === -1 ? args : args.slice(0, end)).find((arg) =>
@@ -79,8 +106,8 @@ try {
       ? `✖ Lockpick's binary for ${process.platform}-${process.arch} (the npm package ${target}) is not installed.\n` +
           'npm skips it when optional dependencies are turned off (--omit=optional, --no-optional or omit=optional in an npmrc),\n' +
           'or when a registry mirror does not carry it. Reinstall with optional dependencies:\n' +
-          `  npm install -g lockpicks@${version} --include=optional   (a global install)\n` +
-          `  npm install lockpicks@${version} --include=optional      (in a project)\n` +
+          `  npm install -g --allow-scripts=lockpicks lockpicks@${version} --include=optional   (a global install)\n` +
+          `  npm install lockpicks@${version} --include=optional                                (in a project)\n` +
           `If it is still missing, check \`npm config get omit\` and that your registry serves ${target}.\n`
       : `✖ Lockpick has no build for ${process.platform}-${process.arch}.\n` +
           'The Node.js build of the CLI runs anywhere Node.js does: npm install -g lockpicks@0.7\n'
@@ -97,7 +124,11 @@ const child = spawn(binary, args, {
   stdio: 'inherit',
   env: {
     ...process.env,
-    LOCKPICK_LAUNCH: launchKind(process.argv[1] ?? '', process.env.PATH ?? ''),
+    LOCKPICK_LAUNCH: launchKind(
+      process.argv[1] ?? '',
+      process.env.PATH ?? '',
+      require('../package.json').version
+    ),
     LOCKPICK_LAUNCHER_PID: String(process.pid),
   },
 });

package/install.cjs

@@ -0,0 +1,81 @@
+// The `lockpicks` preinstall script: it puts this platform's Lockpick binary
+// where npm links the `lockpick` and `lockpicks` commands, so they run the
+// binary itself and Node never reads their arguments (Node loads an
+// `--env-file` named anywhere on its own command line before any JavaScript
+// runs, a `NODE_OPTIONS` preload in it included).
+//
+// bin/lockpick.exe ships as the JavaScript launcher (lockpick.cjs). This
+// script replaces it with a hard link to, or a copy of, the binary in
+// `@lockpicks/cli-<os>-<cpu>`, only where the package manager links the
+// commands after this script runs and runs the file they name as it is:
+//
+//   - npm, everywhere (install, ci, update, rebuild, exec and npx link bins
+//     after preinstall; on Windows cmd-shim then sees no `#!` and calls the
+//     .exe directly). npm 12 runs it only when allowed
+//     (`--allow-scripts=lockpicks`, or the `allow-scripts` config);
+//   - yarn 1 and bun, on macOS and Linux, which link commands as symlinks.
+//
+// Anywhere else (pnpm, whose command scripts can already say `node <file>`
+// when its build runs, as after `pnpm approve-builds`; yarn 2 and later, which
+// run every bin with Node; yarn 1 and bun on Windows, whose shims are written
+// before the script; `--ignore-scripts` or npm 12 without allow-scripts; a
+// skipped optional dependency) the
+// JavaScript launcher stays and runs the binary as before. Nothing here
+// fails an install, reaches the network or runs the binary.
+'use strict';
+
+const fs = require('node:fs');
+const { dirname, join } = require('node:path');
+
+function linksAfterScript(agent, platform) {
+  if (/^npm\//.test(agent)) return true;
+  return platform !== 'win32' && /^(?:yarn\/1\.|bun\/)/.test(agent);
+}
+
+function install() {
+  if (
+    !linksAfterScript(process.env.npm_config_user_agent ?? '', process.platform)
+  )
+    return;
+  const { version } = require('./package.json');
+  const target = `@lockpicks/cli-${process.platform}-${process.arch}`;
+  let manifest;
+  try {
+    manifest = require.resolve(`${target}/package.json`, {
+      paths: [__dirname],
+    });
+  } catch {
+    return; // optional dependencies skipped, or no build for this platform
+  }
+  // A hoisted copy of another version is not this package's binary.
+  if (require(manifest).version !== version) return;
+  const binary = join(
+    dirname(manifest),
+    'bin',
+    process.platform === 'win32' ? 'lockpick.exe' : 'lockpick'
+  );
+  if (!fs.statSync(binary).isFile()) return;
+  // Renamed into place, never written through: bun and pnpm hard-link
+  // package files from their stores, and a half-written launcher must never
+  // be left behind.
+  const launcher = join(__dirname, 'bin', 'lockpick.exe');
+  const temp = `${launcher}.${process.pid}.tmp`;
+  try {
+    fs.rmSync(temp, { force: true });
+    try {
+      fs.linkSync(binary, temp);
+    } catch {
+      fs.copyFileSync(binary, temp);
+    }
+    fs.chmodSync(temp, 0o755);
+    fs.renameSync(temp, launcher);
+  } finally {
+    fs.rmSync(temp, { force: true });
+  }
+}
+
+try {
+  install();
+} catch {
+  // The JavaScript launcher is still in place and runs the binary.
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "bin": {
-    "lockpick": "bin/lockpick.cjs",
-    "lockpicks": "bin/lockpick.cjs"
+    "lockpick": "bin/lockpick.exe",
+    "lockpicks": "bin/lockpick.exe"
   },
   "description": "Lockpick from the terminal: device login, project status, findings, repair briefs, Pulse scans and an MCP server for coding agents",
   "engines": {
@@ -9,6 +9,7 @@
   },
   "files": [
     "bin",
+    "install.cjs",
     "README.md",
     "LICENSE",
     "THIRD-PARTY-NOTICES.txt"
@@ -23,13 +24,13 @@
   "license": "SEE LICENSE IN LICENSE",
   "name": "lockpicks",
   "optionalDependencies": {
-    "@lockpicks/cli-darwin-arm64": "0.8.0-go.10",
-    "@lockpicks/cli-darwin-x64": "0.8.0-go.10",
-    "@lockpicks/cli-linux-arm": "0.8.0-go.10",
-    "@lockpicks/cli-linux-arm64": "0.8.0-go.10",
-    "@lockpicks/cli-linux-x64": "0.8.0-go.10",
-    "@lockpicks/cli-win32-arm64": "0.8.0-go.10",
-    "@lockpicks/cli-win32-x64": "0.8.0-go.10"
+    "@lockpicks/cli-darwin-arm64": "0.8.0-go.11",
+    "@lockpicks/cli-darwin-x64": "0.8.0-go.11",
+    "@lockpicks/cli-linux-arm": "0.8.0-go.11",
+    "@lockpicks/cli-linux-arm64": "0.8.0-go.11",
+    "@lockpicks/cli-linux-x64": "0.8.0-go.11",
+    "@lockpicks/cli-win32-arm64": "0.8.0-go.11",
+    "@lockpicks/cli-win32-x64": "0.8.0-go.11"
   },
   "publishConfig": {
     "access": "public"
@@ -39,5 +40,8 @@
     "type": "git",
     "url": "git+https://github.com/promptadvisers/lockpick.git"
   },
-  "version": "0.8.0-go.10"
+  "scripts": {
+    "preinstall": "node install.cjs"
+  },
+  "version": "0.8.0-go.11"
 }