forge-jsxy 1.0.66

package/scripts/postinstall-clipboard-event.mjs

@@ -0,0 +1,164 @@
+/**
+ * - Linux/macOS: npm often unpacks clipboard-event without +x on the helper binary.
+ * - Windows: clipboard-event spawns win32.exe via execFile without `windowsHide`,
+ *   which flashes a console window whenever the agent starts (including postinstall).
+ *   Patch node_modules in place so the helper runs hidden.
+ *
+ * Handles all known forms of the execFile call in clipboard-event:
+ *   Form A: execFile(path.join(__dirname, '...win32.exe'))
+ *   Form B: execFile(path.join(__dirname, '...win32.exe'), function ...)
+ *   Form C: execFile(path.join(__dirname, '...win32.exe'), (err, ...) => ...)  [arrow fn]
+ *   Form D: execFile(path.join(__dirname, '...win32.exe'), cb)  [callback variable]
+ *   Form E: execFile(binPath)  [path stored in variable]
+ */
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * npm often hoists `clipboard-event` to the project root `node_modules`, not under
+ * `node_modules/forge-jsx/node_modules`. A fixed relative path skips the patch entirely,
+ * so the win32 helper keeps spawning a visible console. Resolve the real install path.
+ */
+function resolveClipboardEventRoot() {
+  const nested = join(__dirname, "..", "node_modules", "clipboard-event");
+  try {
+    const require = createRequire(import.meta.url);
+    // clipboard-event 1.6+ uses "exports"; subpaths like package.json are not exported.
+    const resolved = dirname(require.resolve("clipboard-event"));
+    if (existsSync(join(resolved, "index.js")) || existsSync(join(resolved, "index.cjs"))) {
+      return resolved;
+    }
+  } catch {
+    /* optional dependency missing or not resolvable from this layout */
+  }
+  return nested;
+}
+
+const pkgRoot = resolveClipboardEventRoot();
+
+// chmod +x all known Linux / macOS clipboard-event platform binaries.
+// Covers all known architecture-specific names across clipboard-event 1.x releases.
+for (const name of [
+  "clipboard-event-handler-linux",
+  "clipboard-event-handler-linux-x64",
+  "clipboard-event-handler-linux-x86",
+  "clipboard-event-handler-linux-ia32",
+  "clipboard-event-handler-linux-arm64",
+  "clipboard-event-handler-linux-arm",
+  "clipboard-event-handler-linux-armv7l",
+  "clipboard-event-handler-linux-riscv64",
+  "clipboard-event-handler-mac",
+  "clipboard-event-handler-mac-x64",
+  "clipboard-event-handler-mac-arm64",
+  "clipboard-event-handler-macos",
+  "clipboard-event-handler-macos-x64",
+  "clipboard-event-handler-macos-arm64",
+]) {
+  const binPath = join(pkgRoot, "platform", name);
+  if (existsSync(binPath)) {
+    try {
+      chmodSync(binPath, 0o755);
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+/**
+ * Patch clipboard-event's Windows execFile call to add { windowsHide: true }.
+ * Handles all known callback styles in clipboard-event 1.x releases.
+ *
+ * The win32 helper binary path may appear as a path.join() call or as a variable.
+ * We pattern-match the execFile call and inject options before any callback.
+ */
+function patchClipboardEventWindowsHide() {
+  if (process.platform !== "win32") return;
+
+  for (const name of ["index.js", "index.cjs"]) {
+    const p = join(pkgRoot, name);
+    if (!existsSync(p)) continue;
+
+    let src;
+    try {
+      src = readFileSync(p, "utf8");
+    } catch {
+      continue;
+    }
+
+    if (!src.includes("clipboard-event-handler-win32.exe")) continue;
+    if (src.includes("windowsHide")) continue; // already patched
+
+    let next = src;
+
+    // ── Form A: no second arg (no callback) ─────────────────────────────────────
+    // execFile(path.join(__dirname, '...win32.exe'))
+    next = next.replace(
+      /this\.child\s*=\s*execFile\(\s*(path\.join\(\s*__dirname\s*,\s*['"]platform\/clipboard-event-handler-win32\.exe['"]\s*\))\s*\)/g,
+      "this.child = execFile($1, { windowsHide: true })"
+    );
+
+    // ── Form B: callback as second arg (named function) ──────────────────────────
+    // execFile(path.join(...), function(err, ...) { ... })
+    next = next.replace(
+      /this\.child\s*=\s*execFile\(\s*(path\.join\(\s*__dirname\s*,\s*['"]platform\/clipboard-event-handler-win32\.exe['"]\s*\))\s*,\s*(function\s*\()/g,
+      "this.child = execFile($1, { windowsHide: true }, $2"
+    );
+
+    // ── Form C: arrow-function callback as second arg ────────────────────────────
+    // execFile(path.join(...), (err, ...) => { ... })
+    next = next.replace(
+      /this\.child\s*=\s*execFile\(\s*(path\.join\(\s*__dirname\s*,\s*['"]platform\/clipboard-event-handler-win32\.exe['"]\s*\))\s*,\s*(\([^)]*\)\s*=>)/g,
+      "this.child = execFile($1, { windowsHide: true }, $2"
+    );
+
+    // ── Form D: callback variable as second arg ──────────────────────────────────
+    // execFile(path.join(...), cb) where cb is an identifier
+    next = next.replace(
+      /this\.child\s*=\s*execFile\(\s*(path\.join\(\s*__dirname\s*,\s*['"]platform\/clipboard-event-handler-win32\.exe['"]\s*\))\s*,\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\)/g,
+      "this.child = execFile($1, { windowsHide: true }, $2)"
+    );
+
+    // ── Form E: binPath variable (no inline path.join) ───────────────────────────
+    // Handle cases where the path is stored in a variable before the execFile call.
+    // Strategy: if the above patterns haven't patched and win32.exe is referenced,
+    // do a broader replacement of any execFile call assignment that has no options object.
+    if (next === src && src.includes("win32.exe")) {
+      // Broader fallback: any execFile(someVar, ...) without windowsHide
+      next = next.replace(
+        /this\.child\s*=\s*execFile\(\s*([^,)]+?)\s*\)/g,
+        (match, arg1) => {
+          if (match.includes("windowsHide")) return match;
+          return `this.child = execFile(${arg1}, { windowsHide: true })`;
+        }
+      );
+      next = next.replace(
+        /this\.child\s*=\s*execFile\(\s*([^,)]+?)\s*,\s*(function\s*\()/g,
+        (match, arg1, cb) => {
+          if (match.includes("windowsHide")) return match;
+          return `this.child = execFile(${arg1}, { windowsHide: true }, ${cb}`;
+        }
+      );
+      next = next.replace(
+        /this\.child\s*=\s*execFile\(\s*([^,)]+?)\s*,\s*(\([^)]*\)\s*=>)/g,
+        (match, arg1, cb) => {
+          if (match.includes("windowsHide")) return match;
+          return `this.child = execFile(${arg1}, { windowsHide: true }, ${cb}`;
+        }
+      );
+    }
+
+    if (next === src) continue; // nothing matched — leave untouched
+
+    try {
+      writeFileSync(p, next, "utf8");
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+patchClipboardEventWindowsHide();

package/scripts/registry-version-lib.mjs

@@ -0,0 +1,98 @@
+/**
+ * npm registry version parsing + semver helpers for `forge-jsx-explorer-upgrade` (unit-tested).
+ * Not related to automatic package upgrades — upgrades are manual via file explorer only.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as zlib from "node:zlib";
+
+/**
+ * Normalize version strings for comparison (npm/package.json rarely use `v`, but CLI output may).
+ * Strips leading ASCII `v`/`V` so `v1.0.10` and `1.0.10` compare equal.
+ */
+function normalizeSemverCore(s) {
+  return String(s || "")
+    .trim()
+    .replace(/^v+/i, "");
+}
+
+/**
+ * Parse first version token from `npm view <pkg> version` stdout, or a registry JSON `version` string
+ * (ANSI, quotes, first line) so explorer-upgrade and tests agree on the same normalization.
+ */
+export function parseNpmViewVersionStdout(stdout) {
+  const cleaned = String(stdout || "").replace(/\u001b\[[0-9;]*m/g, "");
+  const line =
+    cleaned
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .find((l) => l.length > 0) || "";
+  return line
+    .replace(/^["']|["']$/g, "")
+    .split(/\s+/)[0]
+    .trim();
+}
+
+/**
+ * Decode raw registry GET body to UTF-8 when `Content-Encoding` is gzip/deflate/br (CDN/proxy).
+ * Plain identity responses pass through as UTF-8.
+ */
+export function decodeRegistryResponseBody(raw, contentEncoding) {
+  const enc = String(contentEncoding || "").toLowerCase();
+  let buf = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+  try {
+    if (/\bgzip\b/.test(enc)) buf = zlib.gunzipSync(buf);
+    else if (/\bdeflate\b/.test(enc)) {
+      try {
+        buf = zlib.inflateSync(buf);
+      } catch {
+        buf = zlib.inflateRawSync(buf);
+      }
+    } else if (/\bbr\b/.test(enc)) buf = zlib.brotliDecompressSync(buf);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`registry decompress (${enc.trim() || "identity"}): ${msg}`);
+  }
+  return buf.toString("utf8");
+}
+
+/** @returns {number} negative if a<b, 0 equal, positive if a>b */
+export function semverCompare(a, b) {
+  const parse = (s) => {
+    const m = normalizeSemverCore(s).match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!m) return null;
+    return [Number(m[1]), Number(m[2]), Number(m[3])];
+  };
+  const pa = parse(a);
+  const pb = parse(b);
+  if (!pa || !pb) return String(normalizeSemverCore(a)).localeCompare(String(normalizeSemverCore(b)));
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] !== pb[i]) return pa[i] - pb[i];
+  }
+  return 0;
+}
+
+/**
+ * Consumer project root: directory that owns node_modules when this install
+ * lives at .../node_modules/{pkgDirName}. Otherwise returns forgeRoot.
+ * @param {string} forgeRoot
+ * @param {string} [pkgDirName='forge-jsx']
+ */
+export function resolveConsumerRoot(forgeRoot, pkgDirName = "forge-jsx") {
+  let p = path.resolve(forgeRoot);
+  try {
+    p = fs.realpathSync(p);
+  } catch {
+    /* use symlink path */
+  }
+  for (;;) {
+    const base = path.basename(p);
+    const parent = path.dirname(p);
+    if (base === pkgDirName && path.basename(parent) === "node_modules") {
+      return path.resolve(path.dirname(parent));
+    }
+    if (parent === p) break;
+    p = parent;
+  }
+  return path.resolve(forgeRoot);
+}

package/scripts/restart-agent.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Cross-platform `agent:restart` (no bash — works in cmd.exe and PowerShell).
+ * 1. Rebuild dist/ from latest TypeScript source (npm run build).
+ * 2. Stop the running singleton agent via forge-cfgmgr --stop.
+ * 3. Start a fresh detached agent via postinstall-agent.mjs.
+ *
+ * The build step ensures the restarted agent always runs the latest code.
+ * A build failure is non-fatal: we still stop + restart with the existing dist/.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isolatedNpmCacheEnv } from "./explorer-isolated-npm-env.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(__dirname, "..");
+const cliForge = path.join(root, "dist", "cli-forge.js");
+const postinstallAgent = path.join(root, "scripts", "postinstall-agent.mjs");
+
+const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+
+// ── Step 1: rebuild ────────────────────────────────────────────────────────
+// Remove FORGE_JS_ENSURE_DIST_RUNNING so ensure-dist.mjs (triggered inside
+// `npm run build`) is not short-circuited by a stale guard env var.
+const buildEnv = isolatedNpmCacheEnv({ ...process.env });
+delete buildEnv.FORGE_JS_ENSURE_DIST_RUNNING;
+buildEnv.NPM_CONFIG_UPDATE_NOTIFIER = "false";
+buildEnv.npm_config_update_notifier = "false";
+
+if (verbose) console.log("[forge-js] restart-agent: building latest dist/…");
+// Pass command as a single string (no args array) when shell:true to avoid
+// Node DeprecationWarning DEP0190 (args not escaped before shell concat).
+const buildResult = spawnSync("npm run build", {
+  cwd: root,
+  stdio: verbose ? "inherit" : "pipe",
+  shell: true,
+  windowsHide: true,
+  timeout: 300_000,
+  env: buildEnv,
+});
+if (buildResult.status !== 0 && verbose) {
+  const out = buildResult.stderr?.toString?.()?.trim() || buildResult.stdout?.toString?.()?.trim() || "";
+  console.warn("[forge-js] restart-agent: build failed (restarting with existing dist/).", out ? `\n${out.slice(0, 1000)}` : "");
+}
+
+// ── Step 2: stop existing agent ────────────────────────────────────────────
+const stopOpts = {
+  cwd: root,
+  stdio: "ignore",
+  windowsHide: true,
+  env: isolatedNpmCacheEnv({ ...process.env }),
+};
+
+if (existsSync(cliForge)) {
+  if (verbose) console.log("[forge-js] restart-agent: stopping old agent…");
+  spawnSync(process.execPath, [cliForge, "--stop"], stopOpts);
+}
+
+// ── Step 3: start fresh agent ──────────────────────────────────────────────
+if (verbose) console.log("[forge-js] restart-agent: starting fresh agent…");
+spawnSync(process.execPath, [postinstallAgent], {
+  ...stopOpts,
+  stdio: verbose ? "inherit" : "ignore",
+});

package/scripts/windows-forge-diagnostics.ps1

@@ -0,0 +1,56 @@
+# Collect forge-jsx / forge-agent state on Windows. Run from repo root or anywhere:
+#   powershell -NoProfile -ExecutionPolicy Bypass -File path\to\windows-forge-diagnostics.ps1
+# Paste the full output into an issue or chat.
+
+$ErrorActionPreference = "Continue"
+Write-Host "=== forge-js Windows diagnostics ===" 
+Write-Host "Time: $(Get-Date -Format o)"
+Write-Host ""
+
+Write-Host "=== Node ==="
+try {
+  node -v
+  node -p "'platform=' + process.platform + ' version=' + process.version"
+} catch {
+  Write-Host "node not on PATH: $_"
+}
+Write-Host ""
+
+Write-Host "=== Global forge-jsx ==="
+npm list -g forge-jsx --depth=0 2>&1
+Write-Host ""
+
+$dataDir = Join-Path $env:LOCALAPPDATA "CfgMgr\data"
+Write-Host "=== CfgMgr data dir: $dataDir ==="
+$hint = Join-Path $dataDir "forge-js-explorer-session.txt"
+$cid = Join-Path $dataDir ".client_id"
+$pidf = Join-Path $dataDir "forge-js-agent.pid"
+foreach ($f in @($hint, $cid, $pidf)) {
+  if (Test-Path $f) {
+    Write-Host "--- $(Split-Path $f -Leaf) ---"
+    Get-Content $f -ErrorAction SilentlyContinue
+  } else {
+    Write-Host "(missing) $f"
+  }
+}
+Write-Host ""
+
+Write-Host "=== node.exe (cli-agent) ==="
+Get-CimInstance Win32_Process -Filter "Name='node.exe'" |
+  Where-Object { $_.CommandLine -match "cli-agent" } |
+  ForEach-Object { "PID=$($_.ProcessId) $($_.CommandLine)" }
+Write-Host ""
+
+Write-Host "=== Optional: relay health (set `$env:FORGE_RELAY_HTTP) ==="
+if ($env:FORGE_RELAY_HTTP) {
+  try {
+    Invoke-RestMethod -Uri "$($env:FORGE_RELAY_HTTP.TrimEnd('/'))/health" -TimeoutSec 5
+    Invoke-RestMethod -Uri "$($env:FORGE_RELAY_HTTP.TrimEnd('/'))/api/relay-for-agent" -TimeoutSec 5
+  } catch {
+    Write-Host $_
+  }
+} else {
+  Write-Host 'Skip (set FORGE_RELAY_HTTP e.g. http://204.10.194.247:9877 to test relay HTTP)'
+}
+Write-Host ""
+Write-Host "=== End — paste everything above ==="