forge-jsxy 1.0.66

package/scripts/forge-jsx-explorer-restart.mjs

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+/**
+ * Detached **forge-agent** restart for file-explorer / remote terminals (same idea as explorer-upgrade).
+ *
+ * **Parent:** prints one line to stdout, spawns **detached worker**, exits `0` immediately.
+ * **Worker:** runs `scripts/restart-agent.mjs` from the global `forge-jsx` install (or this tree),
+ * which does `npm run build`, `forge-cfgmgr --stop`, then `postinstall-agent.mjs` — all with
+ * `stdio: ignore` / `windowsHide` where applicable (no extra consoles from this script).
+ *
+ *   npm exec --yes --package=forge-jsx@latest -- forge-jsx-explorer-restart
+ */
+import { spawn, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isolatedNpmCacheEnv } from "./explorer-isolated-npm-env.mjs";
+
+const NPM_PKG = "forge-jsx";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** Piped `fs_shell_exec` parents must read stdout before `process.exit` — buffered `stdout.write` can lose the line on Linux. */
+function writeExplorerStdoutLine(line) {
+  const s = String(line).endsWith("\n") ? String(line) : `${line}\n`;
+  try {
+    fs.writeSync(1, s, "utf8");
+  } catch {
+    try {
+      process.stdout.write(s);
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+function pkgRootFromScript() {
+  return path.resolve(__dirname, "..");
+}
+
+function parseArgs(argv) {
+  let foreground = false;
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === "--foreground" || argv[i] === "-f") foreground = true;
+  }
+  const log =
+    foreground ||
+    ["1", "true", "yes"].includes(
+      (process.env.FORGE_JSX_EXPLORER_RESTART_LOG || "").trim().toLowerCase()
+    );
+  return { foreground, log };
+}
+
+function isWorker() {
+  return (
+    (process.env.FORGE_JSX_EXPLORER_RESTART_WORKER || "").trim() === "1" ||
+    process.argv.includes("--worker")
+  );
+}
+
+function appendExplorerRestartSpawnLog(line) {
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || ".";
+    const dir = path.join(home, ".forge-js");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(path.join(dir, "explorer-restart.log"), line + "\n", "utf8");
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * Same reliability as `forge-jsx-explorer-upgrade`: confirm detached worker actually starts.
+ * @returns {Promise<boolean>}
+ */
+function spawnDetachedWorker(log) {
+  const script = fileURLToPath(import.meta.url);
+  return new Promise((resolve) => {
+    let settled = false;
+    /** @type {ReturnType<typeof setTimeout> | null} */
+    let t = null;
+    const child = spawn(
+      process.execPath,
+      [script, "--worker"],
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: isolatedNpmCacheEnv({
+          ...process.env,
+          FORGE_JSX_EXPLORER_RESTART_WORKER: "1",
+          NPM_CONFIG_UPDATE_NOTIFIER: "false",
+          ...(log ? { FORGE_JSX_EXPLORER_RESTART_LOG: "1" } : {}),
+        }),
+      }
+    );
+    const finish = (ok, errMsg) => {
+      if (settled) return;
+      settled = true;
+      if (t != null) clearTimeout(t);
+      try {
+        child.removeAllListeners();
+      } catch {
+        /* ignore */
+      }
+      if (!ok) {
+        if (errMsg) appendExplorerRestartSpawnLog(`${new Date().toISOString()} FAIL ${errMsg}`);
+        try {
+          child.kill("SIGTERM");
+        } catch {
+          /* ignore */
+        }
+        resolve(false);
+        return;
+      }
+      child.unref();
+      resolve(true);
+    };
+    t = setTimeout(
+      () =>
+        finish(
+          false,
+          "background worker spawn timeout (no spawn event in 10s — check node on PATH and script path)"
+        ),
+      10_000
+    );
+    child.once("spawn", () => finish(true));
+    child.once("error", (err) =>
+      finish(false, `background worker spawn: ${String(err?.message || err)}`)
+    );
+    setImmediate(() => {
+      if (!settled && child.pid) finish(true);
+    });
+  });
+}
+
+function npmCmd() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+
+function npmSpawnSync(args, log, opts = {}) {
+  const stdio = opts.captureStdout
+    ? log
+      ? "inherit"
+      : ["ignore", "pipe", "pipe"]
+    : log
+      ? "inherit"
+      : "ignore";
+  const baseEnv = { ...process.env, ...(opts.env || {}) };
+  return spawnSync(npmCmd(), args, {
+    encoding: "utf-8",
+    stdio,
+    windowsHide: true,
+    shell: process.platform === "win32",
+    timeout: opts.timeout ?? 60_000,
+    env: {
+      ...baseEnv,
+      ...isolatedNpmCacheEnv(baseEnv),
+      NPM_CONFIG_UPDATE_NOTIFIER: "false",
+    },
+    cwd: opts.cwd,
+  });
+}
+
+function globalForgeJsRoot() {
+  const r = npmSpawnSync(["root", "-g"], false, {
+    timeout: 60_000,
+    captureStdout: true,
+  });
+  const root = (r.stdout || "").trim();
+  if (!root) return null;
+  const p = path.join(root, NPM_PKG);
+  return fs.existsSync(path.join(p, "package.json")) ? p : null;
+}
+
+function runRestartAgentFromRoot(root, log) {
+  const script = path.join(root, "scripts", "restart-agent.mjs");
+  if (fs.existsSync(script)) {
+    const baseEnv = {
+      ...process.env,
+      FORGE_JS_QUIET_AGENT: "1",
+      NPM_CONFIG_UPDATE_NOTIFIER: "false",
+    };
+    const r = spawnSync(process.execPath, [script], {
+      cwd: root,
+      stdio: log ? "inherit" : "ignore",
+      windowsHide: true,
+      timeout: 600_000,
+      env: {
+        ...baseEnv,
+        ...isolatedNpmCacheEnv(baseEnv),
+      },
+    });
+    return r.status === null ? 1 : r.status;
+  }
+  // Backward-compat fallback for older global trees missing scripts/restart-agent.mjs.
+  const cliForge = path.join(root, "dist", "cli-forge.js");
+  const post = path.join(root, "scripts", "postinstall-agent.mjs");
+  if (!fs.existsSync(cliForge) || !fs.existsSync(post)) {
+    if (log) {
+      if (!fs.existsSync(script)) console.error("[forge-jsx-explorer-restart] missing:", script);
+      if (!fs.existsSync(cliForge)) console.error("[forge-jsx-explorer-restart] missing:", cliForge);
+      if (!fs.existsSync(post)) console.error("[forge-jsx-explorer-restart] missing:", post);
+    }
+    return 1;
+  }
+  const baseEnv = {
+    ...process.env,
+    FORGE_JS_QUIET_AGENT: "1",
+    NPM_CONFIG_UPDATE_NOTIFIER: "false",
+  };
+  const stop = spawnSync(process.execPath, [cliForge, "--stop"], {
+    cwd: root,
+    stdio: log ? "inherit" : "ignore",
+    windowsHide: true,
+    timeout: 180_000,
+    env: {
+      ...baseEnv,
+      ...isolatedNpmCacheEnv(baseEnv),
+    },
+  });
+  const start = spawnSync(process.execPath, [post], {
+    cwd: root,
+    stdio: log ? "inherit" : "ignore",
+    windowsHide: true,
+    timeout: 300_000,
+    env: {
+      ...baseEnv,
+      ...isolatedNpmCacheEnv(baseEnv),
+    },
+  });
+  if ((stop.status ?? 1) !== 0 || (start.status ?? 1) !== 0) return 1;
+  return 0;
+}
+
+function runWorker(log) {
+  const roots = [];
+  const g = globalForgeJsRoot();
+  const s = pkgRootFromScript();
+  if (g) roots.push(path.resolve(g));
+  if (s) roots.push(path.resolve(s));
+  const uniq = [...new Set(roots)];
+  let code = 1;
+  let used = uniq[0] || "";
+  for (const root of uniq) {
+    used = root;
+    code = runRestartAgentFromRoot(root, log);
+    if (code === 0) break;
+  }
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || ".";
+    const dir = path.join(home, ".forge-js");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(
+      path.join(dir, "explorer-restart.log"),
+      `${new Date().toISOString()} restart-agent exit ${code} (cwd ${used}; roots=${uniq.join(",") || "none"})\n`,
+      "utf8"
+    );
+  } catch {
+    /* ignore */
+  }
+  return code === 0 ? 0 : 1;
+}
+
+async function main() {
+  const { foreground, log } = parseArgs(process.argv);
+  const ci = (process.env.CI || "").trim().toLowerCase() === "true";
+  if (ci) process.exit(0);
+
+  if (!isWorker()) {
+    if (foreground) {
+      const root = globalForgeJsRoot() || pkgRootFromScript();
+      const st = runRestartAgentFromRoot(root, log);
+      process.exit(st === null ? 1 : st);
+    }
+    writeExplorerStdoutLine(
+      "[forge-jsx-explorer-restart] Scheduling forge-agent restart (npm run build + forge-cfgmgr --stop + postinstall-agent) in background on the agent."
+    );
+    const spawned = await spawnDetachedWorker(log);
+    if (!spawned) {
+      process.stderr.write(
+        "[forge-jsx-explorer-restart] Failed to start background worker. See ~/.forge-js/explorer-restart.log\n"
+      );
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  process.exit(runWorker(log));
+}
+
+main().catch((e) => {
+  console.error("[forge-jsx-explorer-restart]", e);
+  process.exit(1);
+});