@qpfai/pf-gate-cli 2.0.1-win32-arm64 → 2.0.1

package/README.md

@@ -1,14 +1,64 @@
-# @qpfai/pf-gate-cli (win32-arm64)
+# @qpfai/pf-gate-cli
 
-Platform runtime payload for PF Gate CLI.
+Global CLI launcher for PF Gate with Codex-style platform runtime packages.
 
-The bundled launcher at `vendor/<target-triple>/pf-gate/` runs PF Gate through Python.
+## Install
 
-Default install source:
-- bundled wheel: `vendor/<target-triple>/python/persons_field-1.0.0-py3-none-any.whl`
+```bash
+npm i -g @qpfai/pf-gate-cli
+```
 
-Runtime behavior:
-- Uses `PF_GATE_PYTHON` when set, else probes `python3` then `python` (Windows also tries `py -3`).
-- Installs from bundled wheel by default.
-- Optional override: set `PF_GATE_PIP_SPEC` to force a different install source.
-- Starts `persons_field.terminal.launcher` with forwarded arguments.
+## Use
+
+Open the PF Gate terminal UX:
+
+```bash
+pf gate
+```
+
+Run direct CLI commands:
+
+```bash
+pf --version
+pf gate --selftest
+```
+
+The launcher resolves a platform package at install time and executes a bundled runtime binary at run time.
+
+## Maintainer release flow
+
+Set the release version for all npm package manifests:
+
+```bash
+node npm/tools/set-version.mjs 2.0.1
+```
+
+Validate release topology without publishing:
+
+```bash
+node npm/tools/publish-all.mjs --dry-run
+```
+
+The dry run warns on placeholder runtime payloads by default.
+To fail dry run on placeholders, use:
+
+```bash
+node npm/tools/publish-all.mjs --dry-run --strict-placeholder-check
+```
+
+Publish all platform variants, then the meta package:
+
+```bash
+node npm/tools/publish-all.mjs --registry=https://registry.npmjs.org/
+```
+
+With npm 2FA:
+
+```bash
+node npm/tools/publish-all.mjs --registry=https://registry.npmjs.org/ --otp=<code>
+```
+
+Each platform package must contain:
+
+- `vendor/<target-triple>/pf-gate/<binary>`
+- optional helper tools in `vendor/<target-triple>/path/`

package/bin/pf.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+import { runCli } from "../lib/main.mjs";
+
+runCli(process.argv.slice(2)).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`PF Gate launcher error: ${message}`);
+  process.exit(1);
+});
+

package/lib/main.mjs

@@ -0,0 +1,229 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const require = createRequire(import.meta.url);
+
+const PLATFORM_PACKAGE_BY_TARGET = Object.freeze({
+  "x86_64-unknown-linux-musl": "@qpfai/pf-gate-cli-linux-x64",
+  "aarch64-unknown-linux-musl": "@qpfai/pf-gate-cli-linux-arm64",
+  "x86_64-apple-darwin": "@qpfai/pf-gate-cli-darwin-x64",
+  "aarch64-apple-darwin": "@qpfai/pf-gate-cli-darwin-arm64",
+  "x86_64-pc-windows-msvc": "@qpfai/pf-gate-cli-win32-x64",
+  "aarch64-pc-windows-msvc": "@qpfai/pf-gate-cli-win32-arm64",
+});
+
+function commandForPackageManager(packageManager) {
+  if (packageManager === "bun") {
+    return "bun install -g @qpfai/pf-gate-cli";
+  }
+  return "npm install -g @qpfai/pf-gate-cli";
+}
+
+function firstExisting(paths, existsSyncFn) {
+  for (const candidate of paths) {
+    if (existsSyncFn(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+export function resolveTargetTriple(platform = process.platform, arch = process.arch) {
+  switch (platform) {
+    case "linux":
+    case "android":
+      if (arch === "x64") {
+        return "x86_64-unknown-linux-musl";
+      }
+      if (arch === "arm64") {
+        return "aarch64-unknown-linux-musl";
+      }
+      return null;
+    case "darwin":
+      if (arch === "x64") {
+        return "x86_64-apple-darwin";
+      }
+      if (arch === "arm64") {
+        return "aarch64-apple-darwin";
+      }
+      return null;
+    case "win32":
+      if (arch === "x64") {
+        return "x86_64-pc-windows-msvc";
+      }
+      if (arch === "arm64") {
+        return "aarch64-pc-windows-msvc";
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+
+export function packageAliasForTarget(targetTriple) {
+  return PLATFORM_PACKAGE_BY_TARGET[targetTriple] || null;
+}
+
+export function binaryNameCandidates(platform = process.platform) {
+  if (platform === "win32") {
+    return ["pf-gate.exe", "pf-gate.cmd", "pf-gate.bat"];
+  }
+  return ["pf-gate"];
+}
+
+export function prependPath(existingPath, newDirs, platform = process.platform) {
+  const separator = platform === "win32" ? ";" : ":";
+  const current = String(existingPath || "")
+    .split(separator)
+    .filter(Boolean);
+  return [...newDirs, ...current].join(separator);
+}
+
+export function detectPackageManager(env = process.env, dirnameHint = __dirname) {
+  const userAgent = String(env.npm_config_user_agent || "");
+  if (/\bbun\//.test(userAgent)) {
+    return "bun";
+  }
+  const execPath = String(env.npm_execpath || "");
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
+  if (
+    dirnameHint.includes(".bun/install/global") ||
+    dirnameHint.includes(".bun\\install\\global")
+  ) {
+    return "bun";
+  }
+  if (userAgent) {
+    return "npm";
+  }
+  return null;
+}
+
+export function shouldUseShellForBinary(binaryPath, platform = process.platform) {
+  if (platform !== "win32") {
+    return false;
+  }
+  return /\.(cmd|bat)$/i.test(binaryPath);
+}
+
+export function resolveRuntimeBinary(options = {}) {
+  const platform = options.platform || process.platform;
+  const arch = options.arch || process.arch;
+  const packageRoot = options.packageRoot || PACKAGE_ROOT;
+  const existsSyncFn = options.existsSync || existsSync;
+  const requireResolve = options.requireResolve || ((specifier) => require.resolve(specifier));
+
+  const targetTriple = resolveTargetTriple(platform, arch);
+  if (!targetTriple) {
+    throw new Error(`Unsupported platform: ${platform} (${arch})`);
+  }
+
+  const packageAlias = packageAliasForTarget(targetTriple);
+  if (!packageAlias) {
+    throw new Error(`Unsupported target triple: ${targetTriple}`);
+  }
+
+  const names = binaryNameCandidates(platform);
+  const localVendorRoot = path.join(packageRoot, "vendor");
+  const localBinaryCandidates = names.map((name) =>
+    path.join(localVendorRoot, targetTriple, "pf-gate", name),
+  );
+
+  let vendorRoot = null;
+  try {
+    const packageJsonPath = requireResolve(`${packageAlias}/package.json`);
+    vendorRoot = path.join(path.dirname(packageJsonPath), "vendor");
+  } catch {
+    const localBinary = firstExisting(localBinaryCandidates, existsSyncFn);
+    if (localBinary) {
+      vendorRoot = localVendorRoot;
+    }
+  }
+
+  if (!vendorRoot) {
+    const packageManager = detectPackageManager();
+    const reinstallCommand = commandForPackageManager(packageManager);
+    throw new Error(
+      `Missing optional dependency ${packageAlias}. Reinstall PF Gate CLI: ${reinstallCommand}`,
+    );
+  }
+
+  const binaryCandidates = names.map((name) => path.join(vendorRoot, targetTriple, "pf-gate", name));
+  const binaryPath = firstExisting(binaryCandidates, existsSyncFn);
+  if (!binaryPath) {
+    throw new Error(
+      `PF Gate binary missing for ${targetTriple}. Expected one of: ${binaryCandidates.join(", ")}`,
+    );
+  }
+
+  const pathDir = path.join(vendorRoot, targetTriple, "path");
+  const additionalPathDirs = existsSyncFn(pathDir) ? [pathDir] : [];
+  return {
+    targetTriple,
+    packageAlias,
+    vendorRoot,
+    binaryPath,
+    additionalPathDirs,
+  };
+}
+
+function forwardSignal(child, signal) {
+  if (child.killed) {
+    return;
+  }
+  try {
+    child.kill(signal);
+  } catch {
+    // Ignore child process signaling failures.
+  }
+}
+
+export async function runCli(args) {
+  const runtime = resolveRuntimeBinary();
+  const env = { ...process.env };
+  if (runtime.additionalPathDirs.length > 0) {
+    env.PATH = prependPath(env.PATH, runtime.additionalPathDirs);
+  }
+  const packageManager = detectPackageManager();
+  const managedByVar = packageManager === "bun" ? "PF_GATE_MANAGED_BY_BUN" : "PF_GATE_MANAGED_BY_NPM";
+  env[managedByVar] = "1";
+
+  const child = spawn(runtime.binaryPath, args, {
+    stdio: "inherit",
+    env,
+    shell: shouldUseShellForBinary(runtime.binaryPath),
+  });
+
+  child.on("error", (error) => {
+    console.error(error);
+    process.exit(1);
+  });
+
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(signal, () => forwardSignal(child, signal));
+  }
+
+  const childResult = await new Promise((resolve) => {
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        resolve({ type: "signal", signal });
+        return;
+      }
+      resolve({ type: "code", exitCode: code ?? 1 });
+    });
+  });
+
+  if (childResult.type === "signal") {
+    process.kill(process.pid, childResult.signal);
+    return;
+  }
+  process.exit(childResult.exitCode);
+}

package/package.json

@@ -1,22 +1,33 @@
 {
   "name": "@qpfai/pf-gate-cli",
-  "version": "2.0.1-win32-arm64",
-  "description": "PF Gate runtime payload for win32 arm64.",
+  "version": "2.0.1",
+  "description": "PF Gate platform launcher with optional native runtime packages.",
   "license": "Apache-2.0",
   "type": "module",
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "arm64"
-  ],
+  "bin": {
+    "pf": "bin/pf.mjs",
+    "pf-gate": "bin/pf.mjs"
+  },
   "files": [
+    "bin",
+    "lib",
     "vendor",
     "README.md"
   ],
+  "scripts": {
+    "test": "node --test tests/*.test.mjs"
+  },
   "engines": {
     "node": ">=18"
   },
+  "optionalDependencies": {
+    "@qpfai/pf-gate-cli-linux-x64": "npm:@qpfai/pf-gate-cli@2.0.1-linux-x64",
+    "@qpfai/pf-gate-cli-linux-arm64": "npm:@qpfai/pf-gate-cli@2.0.1-linux-arm64",
+    "@qpfai/pf-gate-cli-darwin-x64": "npm:@qpfai/pf-gate-cli@2.0.1-darwin-x64",
+    "@qpfai/pf-gate-cli-darwin-arm64": "npm:@qpfai/pf-gate-cli@2.0.1-darwin-arm64",
+    "@qpfai/pf-gate-cli-win32-x64": "npm:@qpfai/pf-gate-cli@2.0.1-win32-x64",
+    "@qpfai/pf-gate-cli-win32-arm64": "npm:@qpfai/pf-gate-cli@2.0.1-win32-arm64"
+  },
   "publishConfig": {
     "access": "public"
   }

package/vendor/aarch64-pc-windows-msvc/pf-gate/pf-gate.cmd

@@ -1,50 +0,0 @@
-@echo off
-setlocal
-
-set "SCRIPT_DIR=%~dp0"
-set "BUNDLED_WHEEL=%SCRIPT_DIR%..\python\persons_field-1.0.0-py3-none-any.whl"
-
-set "PYTHON_BIN=%PF_GATE_PYTHON%"
-if "%PYTHON_BIN%"=="" (
-  where python >nul 2>nul
-  if not errorlevel 1 (
-    set "PYTHON_BIN=python"
-  ) else (
-    where py >nul 2>nul
-    if not errorlevel 1 (
-      set "PYTHON_BIN=py -3"
-    ) else (
-      echo PF Gate runtime error: Python 3.13+ not found. Install Python or set PF_GATE_PYTHON. 1>&2
-      exit /b 1
-    )
-  )
-)
-
-set "PIP_TARGET=%PF_GATE_PIP_SPEC%"
-if "%PIP_TARGET%"=="" set "PIP_TARGET=%BUNDLED_WHEEL%"
-if "%PF_GATE_PIP_SPEC%"=="" (
-  if not exist "%BUNDLED_WHEEL%" (
-    echo PF Gate runtime error: missing bundled wheel at %BUNDLED_WHEEL% 1>&2
-    exit /b 1
-  )
-)
-
-call %PYTHON_BIN% -c "import persons_field.terminal.launcher" >nul 2>nul
-if errorlevel 1 (
-  echo PF Gate runtime: persons_field is missing; installing %PIP_TARGET%... 1>&2
-  call %PYTHON_BIN% -m pip --version >nul 2>nul
-  if errorlevel 1 (
-    call %PYTHON_BIN% -m ensurepip --upgrade >nul 2>nul
-  )
-  call %PYTHON_BIN% -m pip install --upgrade --disable-pip-version-check "%PIP_TARGET%"
-  if errorlevel 1 (
-    call %PYTHON_BIN% -m pip install --user --upgrade --disable-pip-version-check "%PIP_TARGET%"
-    if errorlevel 1 (
-      echo PF Gate runtime error: failed to install %PIP_TARGET%. Set PF_GATE_PYTHON and PF_GATE_PIP_SPEC, then retry. 1>&2
-      exit /b 1
-    )
-  )
-)
-
-call %PYTHON_BIN% -m persons_field.terminal.launcher %*
-exit /b %ERRORLEVEL%