@agent-webui/ai-desk 1.0.65 → 1.0.67

package/bin/aidesk.js

@@ -2,12 +2,19 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawnSync } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 
 const PACKAGE_NAME = '@agent-webui/ai-desk';
 const SKIP_UPDATE_ENV = 'AI_DESK_SKIP_SELF_UPDATE';
 const UPDATE_COMMANDS = new Set(['start', 'restart', 'upgrade']);
-const OFFICIAL_NPM_REGISTRY = 'https://registry.npmjs.org/';
+const DEFAULT_NPM_REGISTRIES = [
+  'https://mirrors.cloud.tencent.com/npm/',
+  'https://r.cnpmjs.org/',
+  'https://mirrors.huaweicloud.com/repository/npm/',
+  'https://nexus-xmn02.int.rclabenv.com/nexus/content/groups/npm-all/',
+];
+const NPM_REGISTRIES_ENV = 'AI_DESK_NPM_REGISTRIES';
+const NPM_REGISTRY_TIMEOUT_MS = 5000;
 
 function readJSON(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -69,43 +76,189 @@ function runNpm(args, options = {}) {
   });
 }
 
+function runNpmAsync(args, options = {}) {
+  const npm = npmCommand();
+  const timeoutMs = options.timeoutMs || 0;
+
+  return new Promise((resolve) => {
+    const child = spawn(npm.command, [...npm.args, ...args], {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      resolve({
+        stdout,
+        stderr,
+        ...result,
+      });
+    };
+
+    const timer = timeoutMs > 0
+      ? setTimeout(() => {
+        child.kill();
+        finish({
+          status: null,
+          signal: 'SIGTERM',
+          error: new Error(`npm command timed out after ${timeoutMs}ms`),
+        });
+      }, timeoutMs)
+      : null;
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk;
+    });
+    child.on('error', (error) => {
+      finish({
+        status: null,
+        error,
+      });
+    });
+    child.on('close', (status, signal) => {
+      finish({
+        status,
+        signal,
+      });
+    });
+  });
+}
+
 function npmOutput(result) {
   return `${result.stderr || ''}${result.stdout || ''}`.trim();
 }
 
-function withOfficialRegistry(args) {
-  return [...args, `--registry=${OFFICIAL_NPM_REGISTRY}`];
+function normalizeRegistryUrl(registry) {
+  const value = String(registry || '').trim();
+  if (!value) {
+    return '';
+  }
+  return value.endsWith('/') ? value : `${value}/`;
 }
 
-function runNpmWithRegistryFallback(args, options = {}) {
-  const primaryResult = runNpm(withOfficialRegistry(args), options);
-  if (primaryResult.status === 0) {
-    return primaryResult;
-  }
+function configuredNpmRegistries() {
+  const configured = String(process.env[NPM_REGISTRIES_ENV] || '')
+    .split(',')
+    .map(normalizeRegistryUrl)
+    .filter(Boolean);
+  return Array.from(new Set([
+    ...DEFAULT_NPM_REGISTRIES,
+    ...configured,
+  ]));
+}
 
-  const fallbackResult = runNpm(args, options);
-  if (fallbackResult.status === 0) {
-    return fallbackResult;
+function packageScope(packageName) {
+  const match = String(packageName || '').match(/^(@[^/]+)\//);
+  return match ? match[1] : '';
+}
+
+function registryArgsForPackage(packageName, registry) {
+  const normalizedRegistry = normalizeRegistryUrl(registry);
+  const args = [`--registry=${normalizedRegistry}`];
+  const scope = packageScope(packageName);
+  if (scope) {
+    args.push(`--${scope}:registry=${normalizedRegistry}`);
   }
+  return args;
+}
 
-  fallbackResult.primaryError = npmOutput(primaryResult);
-  return fallbackResult;
+function withPackageRegistry(args, packageName, registry) {
+  return [
+    ...args,
+    ...registryArgsForPackage(packageName, registry),
+  ];
 }
 
-function latestPublishedVersion() {
-  const result = runNpmWithRegistryFallback(['view', PACKAGE_NAME, 'version'], {
-    stdio: ['ignore', 'pipe', 'pipe'],
+function timeoutError(registry, timeoutMs) {
+  return new Error(`npm registry ${registry} timed out after ${timeoutMs}ms`);
+}
+
+function withTimeout(promise, timeoutMs, error) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(error), timeoutMs);
   });
 
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+async function latestVersionFromRegistry(registry) {
+  const normalizedRegistry = normalizeRegistryUrl(registry);
+  const args = withPackageRegistry(['view', PACKAGE_NAME, 'version'], PACKAGE_NAME, normalizedRegistry);
+  const result = await withTimeout(runNpmAsync(args, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeoutMs: NPM_REGISTRY_TIMEOUT_MS,
+  }), NPM_REGISTRY_TIMEOUT_MS, timeoutError(normalizedRegistry, NPM_REGISTRY_TIMEOUT_MS));
+
+  if (result.error) {
+    throw result.error;
+  }
   if (result.status !== 0) {
     const output = npmOutput(result);
-    const primaryError = result.primaryError ? `Official registry error: ${result.primaryError}\n` : '';
-    const fallbackError = output ? `Fallback registry error: ${output}` : '';
-    const errorMessage = `${primaryError}${fallbackError}`.trim();
-    throw new Error(errorMessage || 'Unable to check npm registry');
+    throw new Error(output || `Unable to check npm registry ${normalizedRegistry}`);
   }
 
-  return String(result.stdout || '').trim();
+  const version = String(result.stdout || '').trim();
+  if (!version) {
+    throw new Error(`npm registry ${normalizedRegistry} returned an empty version`);
+  }
+  return version;
+}
+
+function chooseLatestPackageSource(currentBest, candidate) {
+  if (!currentBest) {
+    return candidate;
+  }
+
+  return compareVersions(candidate.version, currentBest.version) > 0 ? candidate : currentBest;
+}
+
+async function latestPublishedPackageSource() {
+  const checks = await Promise.all(configuredNpmRegistries().map(async (registry) => {
+    try {
+      return {
+        registry,
+        version: await latestVersionFromRegistry(registry),
+      };
+    } catch (error) {
+      return {
+        registry,
+        error,
+      };
+    }
+  }));
+
+  const errors = [];
+  let selected = null;
+  for (const check of checks) {
+    if (check.version) {
+      selected = chooseLatestPackageSource(selected, {
+        version: check.version,
+        registry: check.registry,
+      });
+    } else {
+      errors.push(`${check.registry}: ${check.error.message}`);
+    }
+  }
+
+  if (selected) {
+    return selected;
+  }
+
+  throw new Error(`Unable to check npm registries.\n${errors.join('\n')}`.trim());
 }
 
 function realpathIfExists(targetPath) {
@@ -154,19 +307,20 @@ function findLocalProjectRoot(packageRoot) {
   return '';
 }
 
-function installLatestVersion(latestVersion) {
+function installLatestVersion(latestVersion, registry = DEFAULT_NPM_REGISTRIES[0]) {
   const packageRoot = currentPackageRoot();
   const projectRoot = findLocalProjectRoot(packageRoot);
   const installTarget = `${PACKAGE_NAME}@${latestVersion}`;
+  const installArgs = withPackageRegistry(['install', installTarget, '--include=optional'], PACKAGE_NAME, registry);
 
   if (projectRoot) {
-    return runNpmWithRegistryFallback(['install', installTarget, '--include=optional'], {
+    return runNpm(installArgs, {
       cwd: projectRoot,
       stdio: 'inherit',
     });
   }
 
-  return runNpmWithRegistryFallback(['install', '-g', installTarget, '--include=optional'], {
+  return runNpm(withPackageRegistry(['install', '-g', installTarget, '--include=optional'], PACKAGE_NAME, registry), {
     stdio: 'inherit',
   });
 }
@@ -217,7 +371,7 @@ function restartWithUpdatedCli(args) {
   process.exit(typeof result.status === 'number' ? result.status : 1);
 }
 
-function updateBeforeCommand(args) {
+async function updateBeforeCommand(args) {
   if (!shouldCheckForUpdate(args)) {
     return;
   }
@@ -225,14 +379,15 @@ function updateBeforeCommand(args) {
   const command = requestedCommand(args);
   console.log('Checking for AI Desk updates...');
 
-  let latestVersion;
+  let latestSource;
   try {
-    latestVersion = latestPublishedVersion();
+    latestSource = await latestPublishedPackageSource();
   } catch (error) {
     console.warn(`Unable to check for AI Desk updates: ${error.message}`);
     return;
   }
 
+  const latestVersion = latestSource.version;
   const installedVersion = currentVersion();
   const forceUpgrade = command === 'upgrade' && args.includes('--force');
   const alreadyLatest = compareVersions(latestVersion, installedVersion) <= 0;
@@ -246,7 +401,7 @@ function updateBeforeCommand(args) {
 
   const verb = alreadyLatest ? 'Reinstalling' : 'Updating';
   console.log(`${verb} AI Desk from ${installedVersion} to ${latestVersion}...`);
-  const result = installLatestVersion(latestVersion);
+  const result = installLatestVersion(latestVersion, latestSource.registry);
   if (result.error) {
     throw result.error;
   }
@@ -263,13 +418,6 @@ function updateBeforeCommand(args) {
   restartWithUpdatedCli(args);
 }
 
-try {
-  updateBeforeCommand(process.argv.slice(2));
-} catch (error) {
-  console.error(`Failed to update AI Desk: ${error.message}`);
-  process.exit(1);
-}
-
 function loadDaemonCli() {
   if (!isPackagedInstall()) {
     require('../../../bin/cli.js');
@@ -283,4 +431,15 @@ function loadDaemonCli() {
   }
 }
 
-loadDaemonCli();
+async function main() {
+  try {
+    await updateBeforeCommand(process.argv.slice(2));
+  } catch (error) {
+    console.error(`Failed to update AI Desk: ${error.message}`);
+    process.exit(1);
+  }
+
+  loadDaemonCli();
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-webui/ai-desk",
-  "version": "1.0.65",
+  "version": "1.0.67",
   "description": "Single-install AI Desk package with daemon and default harnesses",
   "bin": {
     "aidesk": "bin/aidesk.js"
@@ -14,8 +14,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@agent-webui/ai-desk-daemon": "1.0.65",
-    "@agent-webui/ai-desk-harness-gimp": "1.0.65"
+    "@agent-webui/ai-desk-daemon": "1.0.67",
+    "@agent-webui/ai-desk-harness-gimp": "1.0.67"
   },
   "license": "MIT"
 }