@lpm-registry/cli 0.59.0 → 0.59.1

package/README.md

@@ -8,7 +8,9 @@ npm install -g @lpm-registry/cli
 
 This package is the npm gateway for the native LPM CLI. It installs a small
 JavaScript launcher plus the matching platform package, such as
-`@lpm-registry/cli-darwin-arm64` or `@lpm-registry/cli-linux-x64`.
+`@lpm-registry/cli-darwin-arm64` or `@lpm-registry/cli-linux-x64`. A tiny
+`postinstall` verifier checks the native binary and wires the global command to
+it where the platform allows that.
 
 The JavaScript launcher does not implement package-manager behavior. All CLI
 commands run in the native Rust binary.
@@ -36,5 +38,8 @@ with optional dependencies enabled:
 npm install -g @lpm-registry/cli
 ```
 
+If install scripts were disabled, reinstall without `--ignore-scripts` so npm
+can validate the native binary during installation.
+
 Other install methods are documented at
 [github.com/lpm-dev/rust-client](https://github.com/lpm-dev/rust-client).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lpm-registry/cli",
-  "version": "0.59.0",
+  "version": "0.59.1",
   "description": "LPM CLI native binary installer for npm",
   "repository": {
     "type": "git",
@@ -22,20 +22,22 @@
   },
   "files": [
     "bin",
+    "scripts",
     "README.md"
   ],
   "optionalDependencies": {
-    "@lpm-registry/cli-darwin-arm64": "0.59.0",
-    "@lpm-registry/cli-darwin-x64": "0.59.0",
-    "@lpm-registry/cli-linux-arm64": "0.59.0",
-    "@lpm-registry/cli-linux-x64": "0.59.0",
-    "@lpm-registry/cli-win32-x64": "0.59.0"
+    "@lpm-registry/cli-darwin-arm64": "0.59.1",
+    "@lpm-registry/cli-darwin-x64": "0.59.1",
+    "@lpm-registry/cli-linux-arm64": "0.59.1",
+    "@lpm-registry/cli-linux-x64": "0.59.1",
+    "@lpm-registry/cli-win32-x64": "0.59.1"
   },
   "type": "module",
   "engines": {
     "node": ">=18.0.0"
   },
   "scripts": {
+    "postinstall": "node scripts/install-binary.js",
     "test": "node --test tests/*.test.mjs",
     "pack:check": "npm pack --dry-run --json"
   }

package/scripts/install-binary.js

@@ -0,0 +1,240 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  LpmWrapperError,
+  PLATFORMS,
+  platformKey,
+  resolveNativeBinary,
+} from "../bin/native.js";
+
+const require = createRequire(import.meta.url);
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const defaultWrapperRoot = path.resolve(scriptDir, "..");
+const defaultValidateTimeoutMs = 30_000;
+const commands = ["lpm", "lpx"];
+
+export function installNativeBinaries(options = {}) {
+  const wrapperRoot = options.wrapperRoot ?? defaultWrapperRoot;
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? os.arch();
+  const env = options.env ?? process.env;
+  const requireFn = options.requireFn ?? require;
+  const fsModule = options.fsModule ?? fs;
+  const spawnSyncFn = options.spawnSyncFn ?? spawnSync;
+  const logFn = options.logFn ?? console.log;
+  const validateTimeoutMs =
+    options.validateTimeoutMs ?? defaultValidateTimeoutMs;
+
+  const key = platformKey(platform, arch);
+  const spec = PLATFORMS[key];
+  if (!spec) {
+    logFn(
+      `[lpm] No pre-built native npm package for ${key}; the JS wrapper will report this at runtime.`,
+    );
+    return { status: "unsupported", platform: key, optimized: [] };
+  }
+
+  const expectedVersion = readWrapperVersion(wrapperRoot, fsModule);
+  const lpmBinary = resolveNativeBinary({
+    command: "lpm",
+    platform,
+    arch,
+    env,
+    requireFn,
+  });
+
+  validateNativeBinary(lpmBinary.path, {
+    expectedVersion,
+    env,
+    spawnSyncFn,
+    validateTimeoutMs,
+  });
+
+  const optimized = [];
+  for (const command of commands) {
+    const native =
+      command === "lpm"
+        ? lpmBinary
+        : resolveNativeBinary({
+            command,
+            platform,
+            arch,
+            env,
+            requireFn,
+          });
+    const target = optimizedTargetPath(wrapperRoot, platform, command);
+    const action = stageOptimizedBinary({
+      source: native.path,
+      target,
+      platform,
+      fsModule,
+    });
+    optimized.push({
+      command,
+      source: native.path,
+      target,
+      action,
+    });
+  }
+
+  logFn(`[lpm] Installed native binary from ${spec.pkg}`);
+  return { status: "installed", platform: key, package: spec.pkg, optimized };
+}
+
+export function validateNativeBinary(
+  binaryPath,
+  {
+    expectedVersion = "",
+    env = process.env,
+    spawnSyncFn = spawnSync,
+    validateTimeoutMs = defaultValidateTimeoutMs,
+  } = {},
+) {
+  let result;
+  try {
+    result = spawnSyncFn(binaryPath, ["--version"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+      env,
+      timeout: validateTimeoutMs,
+    });
+  } catch (error) {
+    throw new Error(
+      `Native binary at ${binaryPath} could not be started: ${error.message}`,
+      { cause: error },
+    );
+  }
+
+  if (result.error) {
+    const timeout =
+      result.error.code === "ETIMEDOUT"
+        ? ` within ${Math.ceil(validateTimeoutMs / 1000)}s`
+        : "";
+    throw new Error(
+      `Native binary at ${binaryPath} did not report its version${timeout}: ${result.error.message}`,
+      { cause: result.error },
+    );
+  }
+
+  if (result.signal) {
+    throw new Error(
+      `Native binary at ${binaryPath} was interrupted by ${result.signal} while reporting its version.`,
+    );
+  }
+
+  if (result.status !== 0) {
+    const stderr = String(result.stderr ?? "").trim();
+    throw new Error(
+      `Native binary at ${binaryPath} exited with status ${result.status} while reporting its version.${stderr ? ` ${stderr}` : ""}`,
+    );
+  }
+
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  if (expectedVersion && !output.includes(expectedVersion)) {
+    throw new Error(
+      `Native binary at ${binaryPath} reported version ${JSON.stringify(output || "<empty>")} instead of ${expectedVersion}.`,
+    );
+  }
+
+  return output;
+}
+
+export function stageOptimizedBinary({ source, target, platform, fsModule = fs }) {
+  fsModule.mkdirSync(path.dirname(target), { recursive: true });
+  if (platform === "win32") {
+    atomicCopy(source, target, fsModule);
+    return "copy";
+  }
+
+  try {
+    atomicLink(source, target, fsModule);
+    return "link";
+  } catch {
+    atomicCopy(source, target, fsModule);
+    return "copy";
+  }
+}
+
+function optimizedTargetPath(wrapperRoot, platform, command) {
+  const filename = platform === "win32" ? `${command}.exe` : `${command}.js`;
+  return path.join(wrapperRoot, "bin", filename);
+}
+
+function readWrapperVersion(wrapperRoot, fsModule) {
+  try {
+    const manifest = JSON.parse(
+      fsModule.readFileSync(path.join(wrapperRoot, "package.json"), "utf8"),
+    );
+    return typeof manifest.version === "string" ? manifest.version : "";
+  } catch {
+    return "";
+  }
+}
+
+function atomicLink(source, target, fsModule) {
+  replaceWithTemp(target, fsModule, temp => {
+    fsModule.linkSync(source, temp);
+    fsModule.chmodSync(temp, 0o755);
+  });
+}
+
+function atomicCopy(source, target, fsModule) {
+  replaceWithTemp(target, fsModule, temp => {
+    fsModule.copyFileSync(source, temp);
+    fsModule.chmodSync(temp, 0o755);
+  });
+}
+
+function replaceWithTemp(target, fsModule, writeTemp) {
+  const temp = `${target}.${process.pid}.${Date.now()}.tmp`;
+  let replaced = false;
+
+  try {
+    unlinkIfExists(temp, fsModule);
+    writeTemp(temp);
+    fsModule.renameSync(temp, target);
+    replaced = true;
+  } finally {
+    if (!replaced) {
+      unlinkIfExists(temp, fsModule);
+    }
+  }
+}
+
+function unlinkIfExists(filePath, fsModule) {
+  try {
+    fsModule.unlinkSync(filePath);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+
+function printInstallError(error) {
+  if (error instanceof LpmWrapperError) {
+    console.error(`[lpm] ${error.message}`);
+    for (const hint of error.hints) {
+      console.error(`[lpm] ${hint}`);
+    }
+  } else {
+    console.error(`[lpm] Failed to install native binary: ${error.message}`);
+  }
+
+  console.error(
+    "[lpm] Reinstall with optional dependencies and install scripts enabled: npm install -g @lpm-registry/cli",
+  );
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  try {
+    installNativeBinaries();
+  } catch (error) {
+    printInstallError(error);
+    process.exit(1);
+  }
+}