@agent-webui/ai-desk 1.0.54 → 1.0.56

package/bin/aidesk.js

@@ -1,7 +1,276 @@
 #!/usr/bin/env node
 
+const fs = require('fs');
+const path = require('path');
+const { 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']);
+const OFFICIAL_NPM_REGISTRY = 'https://registry.npmjs.org/';
+
+function readJSON(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function currentPackageRoot() {
+  return path.resolve(__dirname, '..');
+}
+
+function currentVersion() {
+  return readJSON(path.join(currentPackageRoot(), 'package.json')).version;
+}
+
+function isPackagedInstall() {
+  return currentPackageRoot().split(path.sep).includes('node_modules');
+}
+
+function parseVersion(version) {
+  return String(version || '')
+    .trim()
+    .replace(/^v/, '')
+    .split('-')[0]
+    .split('.')
+    .map((part) => Number.parseInt(part, 10) || 0);
+}
+
+function compareVersions(left, right) {
+  const leftParts = parseVersion(left);
+  const rightParts = parseVersion(right);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < length; index += 1) {
+    const delta = (leftParts[index] || 0) - (rightParts[index] || 0);
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+  return 0;
+}
+
+function npmCommand() {
+  if (process.env.npm_execpath && fs.existsSync(process.env.npm_execpath)) {
+    return {
+      command: process.execPath,
+      args: [process.env.npm_execpath],
+    };
+  }
+
+  return {
+    command: process.platform === 'win32' ? 'npm.cmd' : 'npm',
+    args: [],
+  };
+}
+
+function runNpm(args, options = {}) {
+  const npm = npmCommand();
+  return spawnSync(npm.command, [...npm.args, ...args], {
+    encoding: 'utf8',
+    ...options,
+  });
+}
+
+function npmOutput(result) {
+  return `${result.stderr || ''}${result.stdout || ''}`.trim();
+}
+
+function withOfficialRegistry(args) {
+  return [...args, `--registry=${OFFICIAL_NPM_REGISTRY}`];
+}
+
+function runNpmWithRegistryFallback(args, options = {}) {
+  const primaryResult = runNpm(withOfficialRegistry(args), options);
+  if (primaryResult.status === 0) {
+    return primaryResult;
+  }
+
+  const fallbackResult = runNpm(args, options);
+  if (fallbackResult.status === 0) {
+    return fallbackResult;
+  }
+
+  fallbackResult.primaryError = npmOutput(primaryResult);
+  return fallbackResult;
+}
+
+function latestPublishedVersion() {
+  const result = runNpmWithRegistryFallback(['view', PACKAGE_NAME, 'version'], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  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');
+  }
+
+  return String(result.stdout || '').trim();
+}
+
+function realpathIfExists(targetPath) {
+  try {
+    return fs.realpathSync(targetPath);
+  } catch {
+    return '';
+  }
+}
+
+function isSubPath(childPath, parentPath) {
+  const relativePath = path.relative(parentPath, childPath);
+  return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+
+function globalNpmRoot() {
+  const result = runNpm(['root', '-g'], {
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  if (result.status !== 0) {
+    return '';
+  }
+  return realpathIfExists(String(result.stdout || '').trim());
+}
+
+function packagePathFromProjectRoot(projectRoot) {
+  return path.join(projectRoot, 'node_modules', ...PACKAGE_NAME.split('/'));
+}
+
+function findLocalProjectRoot(packageRoot) {
+  const realPackageRoot = realpathIfExists(packageRoot);
+  const realGlobalRoot = globalNpmRoot();
+  if (realGlobalRoot && isSubPath(realPackageRoot, realGlobalRoot)) {
+    return '';
+  }
+
+  let currentDir = packageRoot;
+  while (currentDir && currentDir !== path.dirname(currentDir)) {
+    const candidate = realpathIfExists(packagePathFromProjectRoot(currentDir));
+    if (candidate && candidate === realPackageRoot) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  return '';
+}
+
+function installLatestVersion(latestVersion) {
+  const packageRoot = currentPackageRoot();
+  const projectRoot = findLocalProjectRoot(packageRoot);
+  const installTarget = `${PACKAGE_NAME}@${latestVersion}`;
+
+  if (projectRoot) {
+    return runNpmWithRegistryFallback(['install', installTarget, '--include=optional'], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+  }
+
+  return runNpmWithRegistryFallback(['install', '-g', installTarget, '--include=optional'], {
+    stdio: 'inherit',
+  });
+}
+
+function requestedCommand(args) {
+  for (const arg of args) {
+    if (arg === '--') {
+      return '';
+    }
+    if (!arg.startsWith('-')) {
+      return arg;
+    }
+  }
+  return '';
+}
+
+function shouldCheckForUpdate(args) {
+  if (process.env[SKIP_UPDATE_ENV]) {
+    return false;
+  }
+
+  if (!isPackagedInstall() || args.includes('--help') || args.includes('-h')) {
+    return false;
+  }
+
+  const command = requestedCommand(args);
+  return UPDATE_COMMANDS.has(command);
+}
+
+function restartWithUpdatedCli(args) {
+  const scriptPath = path.join(currentPackageRoot(), 'bin', 'aidesk.js');
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      [SKIP_UPDATE_ENV]: '1',
+    },
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+  }
+
+  process.exit(typeof result.status === 'number' ? result.status : 1);
+}
+
+function updateBeforeCommand(args) {
+  if (!shouldCheckForUpdate(args)) {
+    return;
+  }
+
+  const command = requestedCommand(args);
+  console.log('Checking for AI Desk updates...');
+
+  let latestVersion;
+  try {
+    latestVersion = latestPublishedVersion();
+  } catch (error) {
+    console.warn(`Unable to check for AI Desk updates: ${error.message}`);
+    return;
+  }
+
+  const installedVersion = currentVersion();
+  if (compareVersions(latestVersion, installedVersion) <= 0) {
+    return;
+  }
+
+  console.log(`Updating AI Desk from ${installedVersion} to ${latestVersion}...`);
+  const result = installLatestVersion(latestVersion);
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    process.exit(typeof result.status === 'number' ? result.status : 1);
+  }
+
+  const updatedVersion = currentVersion();
+  console.log(`AI Desk updated to ${updatedVersion}.`);
+  console.log(`Restarting aidesk ${command} with the updated CLI...`);
+  restartWithUpdatedCli(args);
+}
+
 try {
-  require(require.resolve('@agent-webui/ai-desk-daemon/bin/cli.js'));
+  updateBeforeCommand(process.argv.slice(2));
 } catch (error) {
-  require('../../../bin/cli.js');
+  console.error(`Failed to update AI Desk: ${error.message}`);
+  process.exit(1);
 }
+
+function loadDaemonCli() {
+  if (!isPackagedInstall()) {
+    require('../../../bin/cli.js');
+    return;
+  }
+
+  try {
+    require(require.resolve('@agent-webui/ai-desk-daemon/bin/cli.js'));
+  } catch (error) {
+    require('../../../bin/cli.js');
+  }
+}
+
+loadDaemonCli();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-webui/ai-desk",
-  "version": "1.0.54",
+  "version": "1.0.56",
   "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.54",
-    "@agent-webui/ai-desk-harness-gimp": "1.0.54"
+    "@agent-webui/ai-desk-daemon": "1.0.56",
+    "@agent-webui/ai-desk-harness-gimp": "1.0.56"
   },
   "license": "MIT"
 }