@qpfai/pf-gate-cli 1.0.64 → 1.0.65-darwin-x64

package/README.md

@@ -1,81 +1,15 @@
-# @qpfai/pf-gate-cli
+# @qpfai/pf-gate-cli (darwin-x64)
 
-Global CLI launcher for PF Gate with Codex-style platform runtime packages.
+Platform runtime payload for PF Gate CLI.
 
-## Install
+The bundled launcher at `vendor/<target-triple>/pf-gate/` runs PF Gate through Python.
 
-```bash
-npm i -g @qpfai/pf-gate-cli
-```
+Default install source:
+- bundled wheel: `vendor/<target-triple>/python/persons_field-1.0.0-py3-none-any.whl`
 
-## Use
-
-Open the PF Gate terminal UX:
-
-```bash
-pf gate
-```
-
-`pf gate` checks npm for a newer `@qpfai/pf-gate-cli` release on startup and
-auto-installs updates before launching UX.
-To disable this behavior, set `PF_GATE_DISABLE_AUTO_UPDATE=1`.
-
-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.
-On first run, it bootstraps a per-user runtime environment under `~/.pf-gate/runtime/.venv`.
-
-## Maintainer release flow
-
-Set the release version for all npm package manifests:
-
-```bash
-node npm/tools/set-version.mjs 1.0.0
-```
-
-Validate release topology without publishing:
-
-```bash
-node npm/tools/publish-all.mjs --dry-run
-```
-
-`publish-all.mjs` rebuilds `persons_field-1.0.0-py3-none-any.whl` from current source
-and syncs it into every platform package before validation/publish.
-
-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/
-```
-
-Release tags used by default:
-- platform payload packages: `platform`
-- meta package: `latest`
-
-With npm passkey/WebAuthn 2FA:
-
-```bash
-cd "/Users/nicholashuunguyen/Documents/PF Gate/PF Gate V7"
-node npm/tools/publish-all.mjs --registry=https://registry.npmjs.org/
-npm view @qpfai/pf-gate-cli version --registry=https://registry.npmjs.org/
-```
-
-If npm prompts with `Authenticate your account at ... Press ENTER to open in the browser...`,
-press Enter and approve with your passkey in the browser.
-
-Each platform package must contain:
-
-- `vendor/<target-triple>/pf-gate/<binary>`
-- optional helper tools in `vendor/<target-triple>/path/`
+Runtime behavior:
+- Uses `PF_GATE_PYTHON` when set.
+- Otherwise creates/uses a per-user runtime venv at `~/.pf-gate/runtime/.venv` (or `PF_GATE_RUNTIME_HOME/.venv`).
+- 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.

package/package.json

@@ -1,33 +1,22 @@
 {
   "name": "@qpfai/pf-gate-cli",
-  "version": "1.0.64",
-  "description": "PF Gate platform launcher with optional native runtime packages.",
+  "version": "1.0.65-darwin-x64",
+  "description": "PF Gate runtime payload for darwin x64.",
   "license": "Apache-2.0",
   "type": "module",
-  "bin": {
-    "pf": "bin/pf.mjs",
-    "pf-gate": "bin/pf.mjs"
-  },
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "x64"
+  ],
   "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@1.0.64-linux-x64",
-    "@qpfai/pf-gate-cli-linux-arm64": "npm:@qpfai/pf-gate-cli@1.0.64-linux-arm64",
-    "@qpfai/pf-gate-cli-darwin-x64": "npm:@qpfai/pf-gate-cli@1.0.64-darwin-x64",
-    "@qpfai/pf-gate-cli-darwin-arm64": "npm:@qpfai/pf-gate-cli@1.0.64-darwin-arm64",
-    "@qpfai/pf-gate-cli-win32-x64": "npm:@qpfai/pf-gate-cli@1.0.64-win32-x64",
-    "@qpfai/pf-gate-cli-win32-arm64": "npm:@qpfai/pf-gate-cli@1.0.64-win32-arm64"
-  },
   "publishConfig": {
     "access": "public"
   }

package/vendor/x86_64-apple-darwin/pf-gate/pf-gate

@@ -0,0 +1,165 @@
+#!/usr/bin/env sh
+set -eu
+
+SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+BUNDLED_WHEEL="$SCRIPT_DIR/../python/persons_field-1.0.0-py3-none-any.whl"
+USER_HOME="${HOME:-}"
+RUNTIME_HOME="${PF_GATE_RUNTIME_HOME:-}"
+if [ -z "$RUNTIME_HOME" ] && [ -n "$USER_HOME" ]; then
+  RUNTIME_HOME="$USER_HOME/.pf-gate/runtime"
+fi
+WHEEL_STAMP_FILE=""
+if [ -n "$RUNTIME_HOME" ]; then
+  WHEEL_STAMP_FILE="$RUNTIME_HOME/.bundled-wheel.sha256"
+fi
+SYSTEM_PYTHON=""
+VENV_DIR=""
+IS_MANAGED_VENV=0
+
+resolve_system_python() {
+  if command -v python3 >/dev/null 2>&1; then
+    printf '%s' "python3"
+    return 0
+  fi
+  if command -v python >/dev/null 2>&1; then
+    printf '%s' "python"
+    return 0
+  fi
+  return 1
+}
+
+sha256_file() {
+  file_path="$1"
+  if command -v shasum >/dev/null 2>&1; then
+    shasum -a 256 "$file_path" | awk '{print $1}'
+    return 0
+  fi
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum "$file_path" | awk '{print $1}'
+    return 0
+  fi
+  if command -v openssl >/dev/null 2>&1; then
+    openssl dgst -sha256 "$file_path" | awk '{print $NF}'
+    return 0
+  fi
+  return 1
+}
+
+read_wheel_stamp() {
+  if [ -z "$WHEEL_STAMP_FILE" ] || [ ! -f "$WHEEL_STAMP_FILE" ]; then
+    return 0
+  fi
+  head -n 1 "$WHEEL_STAMP_FILE" 2>/dev/null || true
+}
+
+write_wheel_stamp() {
+  wheel_hash="$1"
+  if [ -z "$WHEEL_STAMP_FILE" ] || [ -z "$wheel_hash" ]; then
+    return 0
+  fi
+  mkdir -p "$(dirname "$WHEEL_STAMP_FILE")"
+  printf '%s\n' "$wheel_hash" >"$WHEEL_STAMP_FILE" || true
+}
+
+PYTHON_BIN="${PF_GATE_PYTHON:-}"
+if [ -z "$PYTHON_BIN" ]; then
+  SYSTEM_PYTHON="$(resolve_system_python || true)"
+  if [ -z "$SYSTEM_PYTHON" ]; then
+    echo "PF Gate runtime error: Python 3.13+ not found. Install Python or set PF_GATE_PYTHON." >&2
+    exit 1
+  fi
+
+  if [ -z "$USER_HOME" ] && [ -z "${PF_GATE_RUNTIME_HOME:-}" ]; then
+    echo "PF Gate runtime error: HOME is not set. Set PF_GATE_RUNTIME_HOME or PF_GATE_PYTHON." >&2
+    exit 1
+  fi
+
+  if [ -z "$RUNTIME_HOME" ]; then
+    RUNTIME_HOME="$USER_HOME/.pf-gate/runtime"
+  fi
+  VENV_DIR="$RUNTIME_HOME/.venv"
+  IS_MANAGED_VENV=1
+  PYTHON_BIN="$VENV_DIR/bin/python"
+
+  if [ ! -x "$PYTHON_BIN" ]; then
+    echo "PF Gate runtime: creating runtime environment at $VENV_DIR" >&2
+    mkdir -p "$RUNTIME_HOME"
+    if ! "$SYSTEM_PYTHON" -m venv "$VENV_DIR"; then
+      echo "PF Gate runtime error: failed to create runtime environment at $VENV_DIR" >&2
+      exit 1
+    fi
+  fi
+fi
+
+PIP_TARGET="${PF_GATE_PIP_SPEC:-$BUNDLED_WHEEL}"
+if [ -z "${PF_GATE_PIP_SPEC:-}" ] && [ ! -f "$BUNDLED_WHEEL" ]; then
+  echo "PF Gate runtime error: missing bundled wheel at $BUNDLED_WHEEL" >&2
+  exit 1
+fi
+
+BUNDLED_HASH=""
+if [ -z "${PF_GATE_PIP_SPEC:-}" ] && [ -f "$BUNDLED_WHEEL" ]; then
+  BUNDLED_HASH="$(sha256_file "$BUNDLED_WHEEL" 2>/dev/null || true)"
+fi
+
+NEEDS_INSTALL=0
+FORCE_REINSTALL=0
+INSTALL_REASON="persons_field is missing"
+if ! "$PYTHON_BIN" -c "import persons_field.terminal.launcher" >/dev/null 2>&1; then
+  NEEDS_INSTALL=1
+elif [ -z "${PF_GATE_PIP_SPEC:-}" ] && [ -n "$BUNDLED_HASH" ]; then
+  STORED_HASH="$(read_wheel_stamp)"
+  if [ "$STORED_HASH" != "$BUNDLED_HASH" ]; then
+    NEEDS_INSTALL=1
+    FORCE_REINSTALL=1
+    INSTALL_REASON="bundled runtime payload changed"
+  fi
+fi
+
+if [ "$NEEDS_INSTALL" -eq 1 ]; then
+  echo "PF Gate runtime: ${INSTALL_REASON}; installing ${PIP_TARGET}..." >&2
+  FORCE_PIP_REINSTALL="$FORCE_REINSTALL"
+  if [ "$FORCE_REINSTALL" -eq 1 ] && [ "$IS_MANAGED_VENV" -eq 1 ] && [ -n "$SYSTEM_PYTHON" ] && [ -n "$VENV_DIR" ]; then
+    echo "PF Gate runtime: refreshing runtime environment at $VENV_DIR" >&2
+    rm -rf "$VENV_DIR"
+    mkdir -p "$RUNTIME_HOME"
+    if ! "$SYSTEM_PYTHON" -m venv "$VENV_DIR"; then
+      echo "PF Gate runtime error: failed to refresh runtime environment at $VENV_DIR" >&2
+      exit 1
+    fi
+    PYTHON_BIN="$VENV_DIR/bin/python"
+    FORCE_PIP_REINSTALL=0
+  fi
+  if ! "$PYTHON_BIN" -m pip --version >/dev/null 2>&1; then
+    "$PYTHON_BIN" -m ensurepip --upgrade >/dev/null 2>&1 || true
+  fi
+  if [ "$FORCE_PIP_REINSTALL" -eq 1 ]; then
+    if ! "$PYTHON_BIN" -m pip install --upgrade --force-reinstall --disable-pip-version-check "$PIP_TARGET"; then
+      if [ "$IS_MANAGED_VENV" -eq 1 ]; then
+        echo "PF Gate runtime error: failed to install ${PIP_TARGET}. Set PF_GATE_PYTHON and PF_GATE_PIP_SPEC, then retry." >&2
+        exit 1
+      fi
+      if ! "$PYTHON_BIN" -m pip install --user --upgrade --force-reinstall --disable-pip-version-check "$PIP_TARGET"; then
+        echo "PF Gate runtime error: failed to install ${PIP_TARGET}. Set PF_GATE_PYTHON and PF_GATE_PIP_SPEC, then retry." >&2
+        exit 1
+      fi
+    fi
+  else
+    if ! "$PYTHON_BIN" -m pip install --upgrade --disable-pip-version-check "$PIP_TARGET"; then
+      if [ "$IS_MANAGED_VENV" -eq 1 ]; then
+        echo "PF Gate runtime error: failed to install ${PIP_TARGET}. Set PF_GATE_PYTHON and PF_GATE_PIP_SPEC, then retry." >&2
+        exit 1
+      fi
+      if ! "$PYTHON_BIN" -m pip install --user --upgrade --disable-pip-version-check "$PIP_TARGET"; then
+        echo "PF Gate runtime error: failed to install ${PIP_TARGET}. Set PF_GATE_PYTHON and PF_GATE_PIP_SPEC, then retry." >&2
+        exit 1
+      fi
+    fi
+  fi
+fi
+
+if [ -z "${PF_GATE_PIP_SPEC:-}" ] && [ -n "$BUNDLED_HASH" ]; then
+  write_wheel_stamp "$BUNDLED_HASH"
+fi
+
+exec "$PYTHON_BIN" -m persons_field.terminal.launcher "$@"

package/bin/pf.mjs

@@ -1,10 +0,0 @@
-#!/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

@@ -1,648 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import path from "node:path";
-import process from "node:process";
-import { createInterface } from "node:readline";
-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 NPM_REGISTRY = "https://registry.npmjs.org/";
-const CLI_PACKAGE_NAME = "@qpfai/pf-gate-cli";
-const CLI_PACKAGE_VERSION = (() => {
-  try {
-    const packageJson = require(path.join(PACKAGE_ROOT, "package.json"));
-    return String(packageJson?.version || "").trim();
-  } catch {
-    return "";
-  }
-})();
-
-export function resolveCliPackageVersion() {
-  return CLI_PACKAGE_VERSION;
-}
-
-function envFlagEnabled(value) {
-  return /^(1|true|yes|on)$/i.test(String(value || "").trim());
-}
-
-function parseVersion(rawVersion) {
-  const normalized = String(rawVersion || "")
-    .trim()
-    .replace(/^v/i, "");
-  const [coreRaw, prereleaseRaw = ""] = normalized.split("-", 2);
-  const core = coreRaw
-    .split(".")
-    .map((segment) => Number.parseInt(segment, 10))
-    .map((value) => (Number.isFinite(value) ? value : 0))
-    .slice(0, 3);
-  while (core.length < 3) {
-    core.push(0);
-  }
-  return {
-    core,
-    prerelease: prereleaseRaw.trim(),
-  };
-}
-
-export function compareCliVersions(left, right) {
-  const a = parseVersion(left);
-  const b = parseVersion(right);
-  for (let index = 0; index < 3; index += 1) {
-    if (a.core[index] > b.core[index]) {
-      return 1;
-    }
-    if (a.core[index] < b.core[index]) {
-      return -1;
-    }
-  }
-  if (!a.prerelease && !b.prerelease) {
-    return 0;
-  }
-  if (!a.prerelease) {
-    return 1;
-  }
-  if (!b.prerelease) {
-    return -1;
-  }
-  return a.prerelease.localeCompare(b.prerelease, undefined, {
-    numeric: true,
-    sensitivity: "base",
-  });
-}
-
-function normalizeVersionValue(raw) {
-  if (typeof raw === "string") {
-    return raw.trim();
-  }
-  if (Array.isArray(raw) && raw.length > 0 && typeof raw[0] === "string") {
-    return raw[0].trim();
-  }
-  return "";
-}
-
-function normalizeDistTagsValue(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return {};
-  }
-  const parsed = {};
-  for (const [key, value] of Object.entries(raw)) {
-    const tag = String(key || "").trim();
-    const version = String(value || "").trim();
-    if (!tag || !version) {
-      continue;
-    }
-    parsed[tag] = version;
-  }
-  return parsed;
-}
-
-export function resolveLatestPublishedVersion(options = {}) {
-  const packageManager = options.packageManager || "npm";
-  if (packageManager !== "npm") {
-    return "";
-  }
-  const env = options.env || process.env;
-  const runSync = options.runSync || spawnSync;
-  const timeoutMs = Number(options.timeoutMs || 5000);
-  const requestedTag = String(options.tag || "latest").trim() || "latest";
-  const packageSpecifier =
-    requestedTag === "latest" ? CLI_PACKAGE_NAME : `${CLI_PACKAGE_NAME}@${requestedTag}`;
-  const result = runSync(
-    "npm",
-    ["view", packageSpecifier, "version", "--json", "--registry", NPM_REGISTRY],
-    {
-      env,
-      encoding: "utf-8",
-      timeout: timeoutMs,
-    },
-  );
-  if (result.error || (result.status ?? 1) !== 0) {
-    return "";
-  }
-  const stdout = String(result.stdout || "").trim();
-  if (!stdout) {
-    return "";
-  }
-  try {
-    return normalizeVersionValue(JSON.parse(stdout));
-  } catch {
-    return normalizeVersionValue(stdout.replace(/^"+|"+$/g, ""));
-  }
-}
-
-export function resolvePublishedDistTags(options = {}) {
-  const packageManager = options.packageManager || "npm";
-  if (packageManager !== "npm") {
-    return {};
-  }
-  const env = options.env || process.env;
-  const runSync = options.runSync || spawnSync;
-  const timeoutMs = Number(options.timeoutMs || 5000);
-  const result = runSync(
-    "npm",
-    ["view", CLI_PACKAGE_NAME, "dist-tags", "--json", "--registry", NPM_REGISTRY],
-    {
-      env,
-      encoding: "utf-8",
-      timeout: timeoutMs,
-    },
-  );
-  if (result.error || (result.status ?? 1) !== 0) {
-    return {};
-  }
-  const stdout = String(result.stdout || "").trim();
-  if (!stdout) {
-    return {};
-  }
-  try {
-    return normalizeDistTagsValue(JSON.parse(stdout));
-  } catch {
-    return {};
-  }
-}
-
-export function resolveAutoUpdateTag(options = {}) {
-  const env = options.env || process.env;
-  const forcedTag = String(options.updateTag || env.PF_GATE_UPDATE_TAG || "").trim();
-  if (forcedTag) {
-    return forcedTag;
-  }
-
-  const distTags = normalizeDistTagsValue(options.distTags || {});
-  const currentVersion = String(options.currentVersion || "").trim();
-  if (!currentVersion || !distTags.latest) {
-    return "latest";
-  }
-
-  for (const [tag, version] of Object.entries(distTags)) {
-    if (version === currentVersion) {
-      return tag;
-    }
-  }
-
-  if (compareCliVersions(currentVersion, distTags.latest) <= 0) {
-    return "latest";
-  }
-
-  let selectedTag = "latest";
-  let selectedVersion = "";
-  for (const [tag, version] of Object.entries(distTags)) {
-    if (tag === "latest") {
-      continue;
-    }
-    if (compareCliVersions(version, currentVersion) <= 0) {
-      continue;
-    }
-    if (!selectedVersion || compareCliVersions(version, selectedVersion) < 0) {
-      selectedTag = tag;
-      selectedVersion = version;
-    }
-  }
-  return selectedTag;
-}
-
-export function maybeAutoUpdateCli(options = {}) {
-  const env = options.env || process.env;
-  const log =
-    typeof options.log === "function"
-      ? options.log
-      : (message) => process.stderr.write(String(message));
-  if (envFlagEnabled(env.PF_GATE_DISABLE_AUTO_UPDATE)) {
-    return { updated: false, latestVersion: "" };
-  }
-  if (envFlagEnabled(env.PF_GATE_AUTO_UPDATE_APPLIED)) {
-    return { updated: false, latestVersion: "" };
-  }
-
-  const packageManager = options.packageManager || detectPackageManager(env) || "npm";
-  if (packageManager !== "npm") {
-    return { updated: false, latestVersion: "" };
-  }
-
-  const currentVersion = String(options.currentVersion || CLI_PACKAGE_VERSION).trim();
-  if (!currentVersion) {
-    return { updated: false, latestVersion: "" };
-  }
-
-  const runSync = options.runSync || spawnSync;
-  const latestVersionOverride = String(options.latestVersionOverride || "").trim();
-  const latestVersion =
-    latestVersionOverride ||
-    resolveLatestPublishedVersion({
-      packageManager,
-      env,
-      runSync,
-      timeoutMs: options.timeoutMs,
-      tag: options.updateTag,
-    });
-  if (!latestVersion) {
-    return { updated: false, latestVersion: "" };
-  }
-  if (compareCliVersions(latestVersion, currentVersion) <= 0) {
-    return { updated: false, latestVersion };
-  }
-
-  if (typeof options.shouldInstall === "function") {
-    const shouldInstall = Boolean(
-      options.shouldInstall({
-        currentVersion,
-        latestVersion,
-        packageName: CLI_PACKAGE_NAME,
-      }),
-    );
-    if (!shouldInstall) {
-      return { updated: false, latestVersion };
-    }
-  }
-
-  const installTarget =
-    String(options.installTarget || "").trim() || CLI_PACKAGE_NAME;
-  log(`PF Gate launcher: updating ${CLI_PACKAGE_NAME} ${currentVersion} -> ${latestVersion}...\n`);
-  const installResult = runSync(
-    "npm",
-    ["install", "-g", installTarget, "--registry", NPM_REGISTRY],
-    {
-      env,
-      stdio: "inherit",
-    },
-  );
-  if (installResult.error || (installResult.status ?? 1) !== 0) {
-    log("PF Gate launcher warning: auto-update failed; continuing with installed version.\n");
-    return { updated: false, latestVersion };
-  }
-  return { updated: true, latestVersion };
-}
-
-export function resolveEffectiveCliVersion(options = {}) {
-  const env = options.env || process.env;
-  const currentVersion = String(options.currentVersion || CLI_PACKAGE_VERSION).trim();
-  const existingVersion = String(env.PF_GATE_CLI_VERSION || "").trim();
-  if (existingVersion) {
-    return existingVersion;
-  }
-
-  const updateResult = options.updateResult || {};
-  const updated = Boolean(updateResult.updated);
-  const latestVersion = String(updateResult.latestVersion || "").trim();
-  if (updated && latestVersion) {
-    return latestVersion;
-  }
-  return currentVersion;
-}
-
-export function promptOutputStream(primaryOut = process.stderr, secondaryOut = process.stdout) {
-  if (primaryOut?.isTTY) {
-    return primaryOut;
-  }
-  if (secondaryOut?.isTTY) {
-    return secondaryOut;
-  }
-  return primaryOut || secondaryOut;
-}
-
-export function isInteractivePrompt(
-  streamIn = process.stdin,
-  primaryOut = process.stderr,
-  secondaryOut = process.stdout,
-) {
-  const output = promptOutputStream(primaryOut, secondaryOut);
-  return Boolean(streamIn?.isTTY && output?.isTTY);
-}
-
-async function promptYesNo(
-  message,
-  { streamIn = process.stdin, streamOut = process.stderr, fallbackOut = process.stdout } = {},
-) {
-  const output = promptOutputStream(streamOut, fallbackOut);
-  if (!isInteractivePrompt(streamIn, output)) {
-    return false;
-  }
-  return await new Promise((resolve) => {
-    const rl = createInterface({
-      input: streamIn,
-      output,
-    });
-
-    const ask = () => {
-      rl.question(`${message} [Y/N]: `, (rawAnswer) => {
-        const answer = String(rawAnswer || "").trim().toLowerCase();
-        if (answer === "y" || answer === "yes") {
-          rl.close();
-          resolve(true);
-          return;
-        }
-        if (answer === "n" || answer === "no") {
-          rl.close();
-          resolve(false);
-          return;
-        }
-        output.write("Please enter Y or N.\n");
-        ask();
-      });
-    };
-
-    ask();
-  });
-}
-
-function shouldAutoUpdateForArgs(args) {
-  if (!Array.isArray(args) || args.length === 0) {
-    return true;
-  }
-  const command = String(args[0] || "")
-    .trim()
-    .toLowerCase();
-  return command === "gate" || command === "ux" || command === "shell";
-}
-
-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 env = { ...process.env };
-  const packageManager = detectPackageManager(env);
-  const effectivePackageManager = packageManager || "npm";
-  const shouldAutoUpdate = shouldAutoUpdateForArgs(args);
-  const currentVersion = String(CLI_PACKAGE_VERSION || "").trim();
-  let updateTag = "latest";
-
-  let approvedUpdate = true;
-  let latestVersionHint = "";
-  if (
-    shouldAutoUpdate &&
-    effectivePackageManager === "npm" &&
-    currentVersion &&
-    !envFlagEnabled(env.PF_GATE_DISABLE_AUTO_UPDATE) &&
-    !envFlagEnabled(env.PF_GATE_AUTO_UPDATE_APPLIED)
-  ) {
-    const distTags = resolvePublishedDistTags({
-      packageManager: effectivePackageManager,
-      env,
-      runSync: spawnSync,
-    });
-    updateTag = resolveAutoUpdateTag({
-      currentVersion,
-      distTags,
-      env,
-    });
-    latestVersionHint = resolveLatestPublishedVersion({
-      packageManager: effectivePackageManager,
-      env,
-      runSync: spawnSync,
-      tag: updateTag,
-    });
-    if (!latestVersionHint && updateTag !== "latest") {
-      updateTag = "latest";
-      latestVersionHint = resolveLatestPublishedVersion({
-        packageManager: effectivePackageManager,
-        env,
-        runSync: spawnSync,
-        tag: updateTag,
-      });
-    }
-    if (latestVersionHint && compareCliVersions(latestVersionHint, currentVersion) > 0) {
-      const tagHint = updateTag === "latest" ? "" : ` [channel: ${updateTag}]`;
-      approvedUpdate = await promptYesNo(
-        `PF Gate launcher: update available ${CLI_PACKAGE_NAME} ${currentVersion} -> ${latestVersionHint}${tagHint}. Update now?`,
-      );
-    }
-  }
-
-  const installTarget =
-    updateTag === "latest" ? CLI_PACKAGE_NAME : `${CLI_PACKAGE_NAME}@${updateTag}`;
-  const updateResult = shouldAutoUpdate
-    ? maybeAutoUpdateCli({
-        currentVersion: CLI_PACKAGE_VERSION,
-        packageManager: effectivePackageManager,
-        env,
-        latestVersionOverride: latestVersionHint,
-        updateTag,
-        installTarget,
-        shouldInstall: () => approvedUpdate,
-      })
-    : { updated: false, latestVersion: "" };
-
-  if (updateResult.updated) {
-    env.PF_GATE_AUTO_UPDATE_APPLIED = "1";
-  }
-  env.PF_GATE_CLI_VERSION = resolveEffectiveCliVersion({
-    env,
-    currentVersion: CLI_PACKAGE_VERSION,
-    updateResult,
-  });
-
-  const runtime = resolveRuntimeBinary();
-  if (runtime.additionalPathDirs.length > 0) {
-    env.PATH = prependPath(env.PATH, runtime.additionalPathDirs);
-  }
-  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);
-}