@yeaft/webchat-agent 1.0.331 → 1.0.333

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.331",
+  "version": "1.0.333",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/upgrade-command.js

@@ -1,4 +1,5 @@
-import { existsSync, unlinkSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { delimiter, dirname, join, win32 } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 
 export const DEFAULT_UPGRADE_REGISTRY = 'https://pkg.yeaft.com/';
@@ -21,23 +22,43 @@ export function buildUpgradeMetadataArgs(packageSpec, field) {
 }
 
 /** Build argv for an npm install against the Yeaft registry. */
-export function buildUpgradeInstallArgs(packageSpec, { global = true } = {}) {
+export function buildUpgradeInstallArgs(packageSpec, { global = true, quiet = false } = {}) {
   return [
     'install',
     ...(global ? ['-g'] : []),
     packageSpec,
     `--registry=${DEFAULT_UPGRADE_REGISTRY}`,
+    ...(quiet ? ['--no-audit', '--no-fund', '--loglevel=error'] : []),
   ];
 }
 
-/** Build argv for updating an installed package through the Yeaft registry. */
-export function buildUpgradeUpdateArgs(packageName, { global = true } = {}) {
-  return [
-    'update',
-    ...(global ? ['-g'] : []),
-    packageName,
-    `--registry=${DEFAULT_UPGRADE_REGISTRY}`,
-  ];
+function resolveNodeCliPath(nodePath, packageName, relativeCliPaths, fileExists = existsSync, pathValue = process.env.PATH || '') {
+  const pathApi = /^[A-Za-z]:[\\/]/.test(String(nodePath)) ? win32 : { dirname, join };
+  const nodeDir = pathApi.dirname(String(nodePath));
+  const roots = [nodeDir, pathApi.dirname(nodeDir)];
+  const pathDelimiter = pathApi === win32 ? ';' : delimiter;
+  for (const entry of String(pathValue).split(pathDelimiter)) {
+    const trimmed = entry.trim().replace(/^"|"$/g, '');
+    if (trimmed) roots.push(trimmed);
+  }
+
+  for (const root of [...new Set(roots)]) {
+    for (const cliPath of relativeCliPaths) {
+      const candidate = pathApi.join(root, 'node_modules', packageName, ...cliPath);
+      if (fileExists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+/** Resolve npm's JavaScript entry point without a `.cmd` wrapper. */
+export function resolveWindowsNpmCliPath(nodePath, fileExists = existsSync, pathValue) {
+  return resolveNodeCliPath(nodePath, 'npm', [['bin', 'npm-cli.js']], fileExists, pathValue);
+}
+
+/** Resolve PM2's JavaScript entry point without a PowerShell/cmd wrapper. */
+export function resolveWindowsPm2CliPath(nodePath, fileExists = existsSync, pathValue) {
+  return resolveNodeCliPath(nodePath, 'pm2', [['bin', 'pm2'], ['bin', 'pm2.js']], fileExists, pathValue);
 }
 
 /** Build the npm metadata command used by `yeaft-agent upgrade`. */
@@ -50,33 +71,37 @@ export function buildUpgradeInstallCommand(packageSpec, options) {
   return ['npm', ...buildUpgradeInstallArgs(packageSpec, options)].join(' ');
 }
 
-/** Build the npm update command used after a Windows Agent has exited. */
-export function buildUpgradeUpdateCommand(packageName) {
-  return ['npm', ...buildUpgradeUpdateArgs(packageName)].join(' ');
-}
-
-function quoteCmdPath(path) {
-  return `"${String(path).replace(/"/g, '""')}"`;
-}
-
-/**
- * Build the exact CreateProcess contract for a batch file path. cmd.exe needs
- * the full command string quoted once; windowsVerbatimArguments prevents Node
- * from escaping those quotes a second time when the path contains spaces.
- */
-export function buildWindowsUpgradeInvocation(batPath) {
+/** Build a shell-free detached Node invocation for the Windows updater. */
+export function buildWindowsUpgradeInvocation({ nodePath, runnerPath, payloadPath, logPath }) {
   return {
-    command: 'cmd.exe',
-    args: ['/d', '/s', '/c', quoteCmdPath(batPath)],
+    command: nodePath,
+    args: [runnerPath, payloadPath],
     options: {
       detached: true,
       stdio: 'ignore',
       windowsHide: true,
-      windowsVerbatimArguments: true,
+      env: { ...process.env, YEAFT_UPGRADE_LOG: logPath },
     },
   };
 }
 
+/**
+ * Copy the updater out of the npm package before npm replaces that package.
+ * The runner imports only this helper module, so copy both files together.
+ */
+export function prepareWindowsUpgradeRunner({ sourceRunnerPath, sourceCommandPath, runnerPath, commandPath, payloadPath, payload }) {
+  const runtimeDir = dirname(runnerPath);
+  const moduleManifestPath = join(runtimeDir, 'package.json');
+  mkdirSync(runtimeDir, { recursive: true });
+  for (const path of [runnerPath, commandPath, moduleManifestPath, payloadPath, payload.handoffPath]) {
+    try { rmSync(path, { force: true }); } catch {}
+  }
+  copyFileSync(sourceRunnerPath, runnerPath);
+  copyFileSync(sourceCommandPath, commandPath);
+  writeFileSync(moduleManifestPath, JSON.stringify({ type: 'module' }));
+  writeFileSync(payloadPath, JSON.stringify(payload));
+}
+
 function waitForSpawn(child) {
   return new Promise((resolve, reject) => {
     const onError = err => {
@@ -125,16 +150,18 @@ async function waitForUpgradeHandoff({
 }
 
 /**
- * Launch the detached Windows updater and wait for the batch script itself to
- * confirm execution before the caller stops PM2 or exits. `spawn` only proves
- * that cmd.exe was created; the handoff file proves the updater took control.
+ * Launch the detached Windows updater and confirm that its handoff marker
+ * remains present before the caller stops PM2 or exits.
  */
 export async function launchWindowsUpgradeScript({
-  batPath,
+  nodePath,
+  runnerPath,
+  payloadPath,
+  logPath,
   handoffPath,
   spawnProcess,
   fileExists = existsSync,
-  removeFile = unlinkSync,
+  removeFile = path => rmSync(path, { force: true }),
   sleep = delay,
   timeoutMs = 5000,
   pollIntervalMs = 50,
@@ -143,11 +170,7 @@ export async function launchWindowsUpgradeScript({
   if (typeof spawnProcess !== 'function') throw new TypeError('spawnProcess is required');
   if (!handoffPath) throw new TypeError('handoffPath is required');
 
-  try { removeFile(handoffPath); } catch (err) {
-    if (err?.code !== 'ENOENT') throw err;
-  }
-
-  const invocation = buildWindowsUpgradeInvocation(batPath);
+  const invocation = buildWindowsUpgradeInvocation({ nodePath, runnerPath, payloadPath, logPath });
   let child;
   try {
     child = spawnProcess(invocation.command, invocation.args, invocation.options);
@@ -182,7 +205,7 @@ export async function launchWindowsUpgradeScript({
   }
 
   child.unref();
-  return 'cmd.exe';
+  return nodePath;
 }
 
 /** Build the URL used by the startup-only update notification. */

package/windows-upgrade-runner.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+
+import { appendFileSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { setTimeout as delay } from 'node:timers/promises';
+import {
+  buildUpgradeInstallArgs,
+  resolveWindowsNpmCliPath,
+} from './upgrade-command.js';
+
+const PID_POLL_INTERVAL_MS = 100;
+const PID_WAIT_TIMEOUT_MS = 30_000;
+const FILE_LOCK_RETRY_MS = [0, 250, 750, 1_500];
+
+function appendLog(logPath, message) {
+  try {
+    appendFileSync(logPath, `[Upgrade] ${message}\n`);
+  } catch {}
+}
+
+export function isProcessRunning(pid, probe = process.kill) {
+  try {
+    probe(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === 'EPERM';
+  }
+}
+
+export async function waitForProcessExit(pid, {
+  timeoutMs = PID_WAIT_TIMEOUT_MS,
+  pollIntervalMs = PID_POLL_INTERVAL_MS,
+  processRunning = isProcessRunning,
+  sleep = delay,
+  now = Date.now,
+} = {}) {
+  const deadline = now() + timeoutMs;
+  while (processRunning(pid)) {
+    if (now() >= deadline) return false;
+    await sleep(pollIntervalMs);
+  }
+  return true;
+}
+
+function runProcess(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const { onStderr, ...spawnOptions } = options;
+    const child = spawn(command, args, spawnOptions);
+    if (typeof onStderr === 'function') child.stderr?.on('data', onStderr);
+    child.once('error', reject);
+    child.once('exit', (code, signal) => {
+      if (signal) reject(new Error(`${command} exited with signal ${signal}`));
+      else resolve(code ?? 1);
+    });
+  });
+}
+
+function isRetryableWindowsInstallFailure(code, stderr) {
+  if (code === 0) return false;
+  return /\b(EBUSY|EPERM|EACCES)\b|resource busy|operation not permitted|permission denied/iu.test(stderr);
+}
+
+export async function installWindowsUpgrade({
+  nodePath,
+  npmCliPath,
+  packageSpec,
+  globalInstall,
+  installDir,
+  logPath,
+  run = runProcess,
+  sleep = delay,
+  fileExists,
+}) {
+  const resolvedNpmCliPath = npmCliPath || resolveWindowsNpmCliPath(nodePath, fileExists);
+  if (!resolvedNpmCliPath) throw new Error('npm JavaScript CLI entry point could not be resolved');
+  const command = nodePath;
+  const args = [
+    resolvedNpmCliPath,
+    ...buildUpgradeInstallArgs(packageSpec, { global: globalInstall, quiet: true }),
+  ];
+  const cwd = globalInstall ? process.env.TEMP : installDir;
+
+  for (let attempt = 0; attempt < FILE_LOCK_RETRY_MS.length; attempt++) {
+    const retryDelayMs = FILE_LOCK_RETRY_MS[attempt];
+    if (retryDelayMs) {
+      appendLog(logPath, `Retrying npm install after ${retryDelayMs}ms file-lock delay`);
+      await sleep(retryDelayMs);
+    }
+
+    let stderr = '';
+    const exitCode = await run(command, args, {
+      cwd,
+      env: process.env,
+      windowsHide: true,
+      stdio: ['ignore', 'ignore', 'pipe'],
+      onStderr: chunk => { stderr += String(chunk); },
+    });
+    if (exitCode === 0) return { exitCode, attempts: attempt + 1, command, args };
+    if (!isRetryableWindowsInstallFailure(exitCode, stderr) || attempt === FILE_LOCK_RETRY_MS.length - 1) {
+      if (stderr.trim()) appendLog(logPath, `npm stderr: ${stderr.trim()}`);
+      return { exitCode, attempts: attempt + 1, command, args };
+    }
+  }
+
+  return { exitCode: 1, attempts: FILE_LOCK_RETRY_MS.length, command, args };
+}
+
+export async function startPm2Service({ nodePath, pm2CliPath, ecosystemPath, logPath, run = runProcess }) {
+  if (!pm2CliPath || !ecosystemPath) return true;
+  appendLog(logPath, 'Re-registering Agent via PM2');
+  const startCode = await run(nodePath, [pm2CliPath, 'start', ecosystemPath], {
+    env: process.env,
+    windowsHide: true,
+    stdio: 'ignore',
+  });
+  if (startCode !== 0) return false;
+  const saveCode = await run(nodePath, [pm2CliPath, 'save'], {
+    env: process.env,
+    windowsHide: true,
+    stdio: 'ignore',
+  });
+  return saveCode === 0;
+}
+
+/**
+ * Run after the original Agent exits. No shell pipeline is involved: Windows
+ * PID polling is handled by Node and npm/PM2 run through their JS entry points.
+ */
+export async function runWindowsUpgrade(options, dependencies = {}) {
+  const {
+    parentPid,
+    packageSpec,
+    globalInstall,
+    installDir,
+    logPath,
+    handoffPath,
+    runnerPath,
+    commandPath,
+    payloadPath,
+    nodePath,
+    npmCliPath,
+    pm2CliPath,
+    ecosystemPath,
+  } = options;
+  const wait = dependencies.waitForProcessExit || waitForProcessExit;
+  const install = dependencies.installWindowsUpgrade || installWindowsUpgrade;
+  const startService = dependencies.startPm2Service || startPm2Service;
+
+  mkdirSync(dirname(handoffPath), { recursive: true });
+  writeFileSync(handoffPath, 'started');
+  appendLog(logPath, `Started at ${new Date().toISOString()}`);
+  appendLog(logPath, `Waiting for PID ${parentPid} to exit`);
+  const exited = await wait(parentPid);
+  if (!exited) appendLog(logPath, `Timed out waiting for PID ${parentPid}; continuing with bounded npm retries`);
+  else appendLog(logPath, 'Original process exited');
+
+  let result;
+  try {
+    result = await install({ nodePath, npmCliPath, packageSpec, globalInstall, installDir, logPath });
+  } catch (err) {
+    appendLog(logPath, `npm install failed to start: ${err?.message || err}`);
+    result = { exitCode: 1, attempts: 0 };
+  }
+  appendLog(logPath, `npm install ${result.exitCode === 0 ? 'succeeded' : `failed with exit code ${result.exitCode}`} after ${result.attempts} attempt(s)`);
+
+  let restarted = false;
+  try {
+    restarted = await startService({ nodePath, pm2CliPath, ecosystemPath, logPath });
+  } catch (err) {
+    appendLog(logPath, `WARNING: PM2 service restart failed: ${err?.message || err}`);
+  }
+  if (!restarted) appendLog(logPath, 'WARNING: PM2 service was not restarted');
+  appendLog(logPath, `Finished at ${new Date().toISOString()}`);
+
+  // Do not delete the running script. Windows keeps it executable until exit,
+  // but deferred cleanup on the next upgrade is more reliable than self-delete.
+  for (const path of [handoffPath, payloadPath]) {
+    try { rmSync(path, { force: true }); } catch {}
+  }
+  return { exitCode: result.exitCode, restarted, cleanupPaths: [runnerPath, commandPath] };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  let payload;
+  try {
+    payload = JSON.parse(readFileSync(process.argv[2], 'utf8'));
+    const result = await runWindowsUpgrade(payload);
+    process.exitCode = result.exitCode;
+  } catch (err) {
+    const logPath = payload?.logPath || process.env.YEAFT_UPGRADE_LOG;
+    if (logPath) appendLog(logPath, `Runner failed: ${err?.stack || err}`);
+    process.exitCode = 1;
+  }
+}