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

package/README.md

@@ -1,15 +1,81 @@
-# @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.
-- 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.
+## 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/`

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,648 @@
+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);
+}

package/package.json

@@ -1,22 +1,33 @@
 {
   "name": "@qpfai/pf-gate-cli",
-  "version": "1.0.65-win32-arm64",
-  "description": "PF Gate runtime payload for win32 arm64.",
+  "version": "1.0.65",
+  "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@1.0.65-linux-x64",
+    "@qpfai/pf-gate-cli-linux-arm64": "npm:@qpfai/pf-gate-cli@1.0.65-linux-arm64",
+    "@qpfai/pf-gate-cli-darwin-x64": "npm:@qpfai/pf-gate-cli@1.0.65-darwin-x64",
+    "@qpfai/pf-gate-cli-darwin-arm64": "npm:@qpfai/pf-gate-cli@1.0.65-darwin-arm64",
+    "@qpfai/pf-gate-cli-win32-x64": "npm:@qpfai/pf-gate-cli@1.0.65-win32-x64",
+    "@qpfai/pf-gate-cli-win32-arm64": "npm:@qpfai/pf-gate-cli@1.0.65-win32-arm64"
+  },
   "publishConfig": {
     "access": "public"
   }

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

@@ -1,145 +0,0 @@
-@echo off
-setlocal EnableExtensions EnableDelayedExpansion
-
-set "SCRIPT_DIR=%~dp0"
-set "BUNDLED_WHEEL=%SCRIPT_DIR%..\python\persons_field-1.0.0-py3-none-any.whl"
-set "RUNTIME_HOME=%PF_GATE_RUNTIME_HOME%"
-if "%RUNTIME_HOME%"=="" set "RUNTIME_HOME=%USERPROFILE%\.pf-gate\runtime"
-set "WHEEL_STAMP_FILE="
-if not "%RUNTIME_HOME%"=="" set "WHEEL_STAMP_FILE=%RUNTIME_HOME%\.bundled-wheel.sha256"
-set "SYSTEM_PYTHON="
-set "VENV_DIR="
-set "IS_MANAGED_VENV=0"
-
-set "PYTHON_BIN=%PF_GATE_PYTHON%"
-if "%PYTHON_BIN%"=="" (
-  where python >nul 2>nul
-  if not errorlevel 1 (
-    set "SYSTEM_PYTHON=python"
-  ) else (
-    where py >nul 2>nul
-    if not errorlevel 1 (
-      set "SYSTEM_PYTHON=py -3"
-    )
-  )
-
-  if "%SYSTEM_PYTHON%"=="" (
-    echo PF Gate runtime error: Python 3.13+ not found. Install Python or set PF_GATE_PYTHON. 1>&2
-    exit /b 1
-  )
-
-  set "VENV_DIR=%RUNTIME_HOME%\.venv"
-  set "IS_MANAGED_VENV=1"
-  set "PYTHON_BIN=%VENV_DIR%\Scripts\python.exe"
-
-  if not exist "%PYTHON_BIN%" (
-    echo PF Gate runtime: creating runtime environment at %VENV_DIR% 1>&2
-    if not exist "%RUNTIME_HOME%" mkdir "%RUNTIME_HOME%"
-    call %SYSTEM_PYTHON% -m venv "%VENV_DIR%"
-    if errorlevel 1 (
-      echo PF Gate runtime error: failed to create runtime environment at %VENV_DIR% 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
-  )
-)
-
-set "BUNDLED_HASH="
-if "%PF_GATE_PIP_SPEC%"=="" (
-  for /f "skip=1 tokens=* delims=" %%H in ('certutil -hashfile "%BUNDLED_WHEEL%" SHA256 ^| findstr /R /V /C:"hash of file" /C:"CertUtil"') do (
-    set "line=%%H"
-    set "line=!line: =!"
-    if not "!line!"=="" (
-      set "BUNDLED_HASH=!line!"
-      goto :hash_done
-    )
-  )
-)
-:hash_done
-
-set "NEEDS_INSTALL=0"
-set "FORCE_REINSTALL=0"
-set "INSTALL_REASON=persons_field is missing"
-
-call %PYTHON_BIN% -c "import persons_field.terminal.launcher" >nul 2>nul
-if errorlevel 1 (
-  set "NEEDS_INSTALL=1"
-) else (
-  if "%PF_GATE_PIP_SPEC%"=="" if defined BUNDLED_HASH (
-    set "STORED_HASH="
-    if defined WHEEL_STAMP_FILE if exist "%WHEEL_STAMP_FILE%" (
-      set /p STORED_HASH=<"%WHEEL_STAMP_FILE%"
-      set "STORED_HASH=!STORED_HASH: =!"
-    )
-    if /I not "!STORED_HASH!"=="!BUNDLED_HASH!" (
-      set "NEEDS_INSTALL=1"
-      set "FORCE_REINSTALL=1"
-      set "INSTALL_REASON=bundled runtime payload changed"
-    )
-  )
-)
-
-if "%NEEDS_INSTALL%"=="1" (
-  echo PF Gate runtime: !INSTALL_REASON!; installing %PIP_TARGET%... 1>&2
-  set "FORCE_PIP_REINSTALL=%FORCE_REINSTALL%"
-  if "!FORCE_REINSTALL!"=="1" if "!IS_MANAGED_VENV!"=="1" (
-    echo PF Gate runtime: refreshing runtime environment at !VENV_DIR! 1>&2
-    if exist "!VENV_DIR!" rmdir /s /q "!VENV_DIR!"
-    if not exist "!RUNTIME_HOME!" mkdir "!RUNTIME_HOME!"
-    call !SYSTEM_PYTHON! -m venv "!VENV_DIR!"
-    if errorlevel 1 (
-      echo PF Gate runtime error: failed to refresh runtime environment at !VENV_DIR! 1>&2
-      exit /b 1
-    )
-    set "PYTHON_BIN=!VENV_DIR!\Scripts\python.exe"
-    set "FORCE_PIP_REINSTALL=0"
-  )
-  call %PYTHON_BIN% -m pip --version >nul 2>nul
-  if errorlevel 1 (
-    call %PYTHON_BIN% -m ensurepip --upgrade >nul 2>nul
-  )
-
-  if "!FORCE_PIP_REINSTALL!"=="1" (
-    call %PYTHON_BIN% -m pip install --upgrade --force-reinstall --disable-pip-version-check "%PIP_TARGET%"
-    if errorlevel 1 (
-      if "!IS_MANAGED_VENV!"=="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 pip install --user --upgrade --force-reinstall --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
-      )
-    )
-  ) else (
-    call %PYTHON_BIN% -m pip install --upgrade --disable-pip-version-check "%PIP_TARGET%"
-    if errorlevel 1 (
-      if "!IS_MANAGED_VENV!"=="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 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
-      )
-    )
-  )
-)
-
-if "%PF_GATE_PIP_SPEC%"=="" if defined BUNDLED_HASH if defined WHEEL_STAMP_FILE (
-  if not exist "%RUNTIME_HOME%" mkdir "%RUNTIME_HOME%"
-  >"%WHEEL_STAMP_FILE%" echo %BUNDLED_HASH%
-)
-
-call %PYTHON_BIN% -m persons_field.terminal.launcher %*
-exit /b %ERRORLEVEL%