@agent-webui/ai-desk-daemon 1.0.60 → 1.0.61

package/bin/cli.js

@@ -11,6 +11,7 @@ const path = require('path');
 const { start, stop, restart, status } = require('../lib/daemon-manager');
 const { getLogPath } = require('../lib/platform');
 const { VERSION } = require('../lib/platform');
+const { upgradePackage } = require('../lib/self-upgrade');
 
 function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -286,6 +287,24 @@ program
     }
   });
 
+// Upgrade command
+program
+  .command('upgrade')
+  .description('Upgrade AI Desk CLI to the latest published version')
+  .option('--force', 'Reinstall the latest version even when the current version is already latest')
+  .action(async (options) => {
+    try {
+      upgradePackage({
+        packageName: '@agent-webui/ai-desk-daemon',
+        packageRoot: path.join(__dirname, '..'),
+        force: Boolean(options.force),
+      });
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to upgrade AI Desk:'), error.message);
+      process.exit(error.exitCode || 1);
+    }
+  });
+
 // Logs command
 program
   .command('logs')

package/lib/daemon-manager.js

@@ -3,7 +3,7 @@
  */
 
 const fs = require('fs');
-const { spawn, execSync } = require('child_process');
+const { spawn, spawnSync, execSync } = require('child_process');
 const http = require('http');
 const { getDaemonBinaryPath, getPidPath, getConfiguredLogPath, getLogPath, VERSION } = require('./platform');
 const { getPort, getConfigPath } = require('./config');
@@ -143,26 +143,166 @@ function start() {
   return child.pid;
 }
 
+function parsePid(value) {
+  const pid = Number.parseInt(String(value || '').trim(), 10);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  return pid;
+}
+
+function parsePidList(output) {
+  return String(output || '')
+    .split(/\r?\n/)
+    .map((line) => parsePid(line))
+    .filter((pid) => pid && pid !== process.pid);
+}
+
+function listPidsByNameUnix(processName) {
+  const pgrep = spawnSync('pgrep', ['-x', processName], { encoding: 'utf8' });
+  if (pgrep.status === 0) {
+    return parsePidList(pgrep.stdout);
+  }
+
+  if (pgrep.error && pgrep.error.code !== 'ENOENT') {
+    throw pgrep.error;
+  }
+
+  const ps = spawnSync('ps', ['-A', '-o', 'pid=', '-o', 'comm='], { encoding: 'utf8' });
+  if (ps.status !== 0) {
+    return [];
+  }
+
+  const pids = [];
+  for (const line of String(ps.stdout || '').split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+
+    const match = trimmed.match(/^(\d+)\s+(.+)$/);
+    if (!match) {
+      continue;
+    }
+
+    if (require('path').basename(match[2]) === processName) {
+      const pid = parsePid(match[1]);
+      if (pid && pid !== process.pid) {
+        pids.push(pid);
+      }
+    }
+  }
+  return pids;
+}
+
+function isIgnorableKillError(error) {
+  return error && (error.code === 'ESRCH' || error.message === 'kill ESRCH');
+}
+
+function terminatePid(pid, signal = 'SIGTERM') {
+  process.kill(pid, signal);
+}
+
+function terminateAllByNameUnix(processName) {
+  const killedPids = [];
+  for (const pid of listPidsByNameUnix(processName)) {
+    try {
+      terminatePid(pid, 'SIGTERM');
+      killedPids.push(pid);
+    } catch (error) {
+      if (!isIgnorableKillError(error)) {
+        throw error;
+      }
+    }
+  }
+  return killedPids;
+}
+
+function terminateAllByNameWindows(processName) {
+  const imageName = processName.endsWith('.exe') ? processName : `${processName}.exe`;
+  const result = spawnSync('taskkill', ['/F', '/T', '/IM', imageName], { encoding: 'utf8' });
+  if (result.status === 0) {
+    return [];
+  }
+
+  const output = `${result.stderr || ''}${result.stdout || ''}`;
+  if (/not found|no running instance|not running/i.test(output)) {
+    return [];
+  }
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  throw new Error(output.trim() || `taskkill failed for ${imageName}`);
+}
+
+function terminateAllByName(processName) {
+  if (process.platform === 'win32') {
+    return terminateAllByNameWindows(processName);
+  }
+  return terminateAllByNameUnix(processName);
+}
+
+function addKilledPid(killedPids, pid) {
+  if (pid && !killedPids.includes(pid)) {
+    killedPids.push(pid);
+  }
+}
+
 /**
  * Stop daemon
  */
-function stop() {
-  const pidPath = getPidPath();
-  
-  if (!fs.existsSync(pidPath)) {
-    throw new Error('Daemon is not running');
+function stop(deps = {}) {
+  const fsApi = deps.fs || fs;
+  const platformApi = deps.platform || { getPidPath };
+  const processManager = deps.processManager || {
+    terminatePid,
+    terminateAllByName,
+  };
+  const logger = deps.logger || console;
+  const pidPath = platformApi.getPidPath();
+  let pidFilePid = null;
+  const killedPids = [];
+  const errors = [];
+
+  if (fsApi.existsSync(pidPath)) {
+    pidFilePid = parsePid(fsApi.readFileSync(pidPath, 'utf8'));
+    if (pidFilePid) {
+      try {
+        processManager.terminatePid(pidFilePid, 'SIGTERM');
+        addKilledPid(killedPids, pidFilePid);
+      } catch (error) {
+        if (!isIgnorableKillError(error)) {
+          errors.push(error);
+        }
+      }
+    }
+
+    try {
+      fsApi.unlinkSync(pidPath);
+    } catch (error) {
+      errors.push(error);
+    }
   }
-  
-  const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim());
-  
+
   try {
-    process.kill(pid, 'SIGTERM');
-    fs.unlinkSync(pidPath);
-    console.log('Daemon stopped');
+    for (const pid of processManager.terminateAllByName('ai-desk-daemon') || []) {
+      addKilledPid(killedPids, pid);
+    }
   } catch (error) {
-    fs.unlinkSync(pidPath);
-    throw new Error(`Failed to stop daemon: ${error.message}`);
+    errors.push(error);
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Failed to stop daemon: ${errors.map((error) => error.message).join('; ')}`);
   }
+
+  logger.log('Daemon stopped');
+  return {
+    pidFilePid,
+    killedPids,
+  };
 }
 
 /**

package/lib/self-upgrade.js

@@ -0,0 +1,313 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const OFFICIAL_NPM_REGISTRY = 'https://registry.npmjs.org/';
+const DEFAULT_PACKAGE_NAME = '@agent-webui/ai-desk';
+const SKIP_UPDATE_ENV = 'AI_DESK_SKIP_SELF_UPDATE';
+const DEFAULT_UPDATE_COMMANDS = new Set(['start', 'restart', 'upgrade']);
+
+function readJSON(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function currentVersion(packageRoot) {
+  return readJSON(path.join(packageRoot, 'package.json')).version;
+}
+
+function isPackagedInstall(packageRoot) {
+  return path.resolve(packageRoot).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(env = process.env) {
+  if (env.npm_execpath && fs.existsSync(env.npm_execpath)) {
+    return {
+      command: process.execPath,
+      args: [env.npm_execpath],
+    };
+  }
+
+  return {
+    command: process.platform === 'win32' ? 'npm.cmd' : 'npm',
+    args: [],
+  };
+}
+
+function runNpm(args, options = {}) {
+  const npm = npmCommand(options.env || process.env);
+  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(packageName = DEFAULT_PACKAGE_NAME) {
+  const result = runNpmWithRegistryFallback(['view', packageName, '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, packageName = DEFAULT_PACKAGE_NAME) {
+  return path.join(projectRoot, 'node_modules', ...packageName.split('/'));
+}
+
+function findLocalProjectRoot(packageRoot, packageName = DEFAULT_PACKAGE_NAME) {
+  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, packageName));
+    if (candidate && candidate === realPackageRoot) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  return '';
+}
+
+function installLatestVersion({
+  packageName = DEFAULT_PACKAGE_NAME,
+  packageRoot,
+  latestVersion,
+}) {
+  const projectRoot = findLocalProjectRoot(packageRoot, packageName);
+  const installTarget = `${packageName}@${latestVersion}`;
+
+  if (projectRoot) {
+    return runNpmWithRegistryFallback(['install', installTarget, '--include=optional'], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+  }
+
+  return runNpmWithRegistryFallback(['install', '-g', installTarget, '--include=optional'], {
+    stdio: 'inherit',
+  });
+}
+
+function assertInstallSucceeded(result) {
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    const error = new Error(`npm install failed with exit code ${result.status}`);
+    error.exitCode = typeof result.status === 'number' ? result.status : 1;
+    throw error;
+  }
+}
+
+function upgradePackage({
+  packageName = DEFAULT_PACKAGE_NAME,
+  packageRoot,
+  installedVersion,
+  latestVersion,
+  force = false,
+  logger = console,
+  latestPublishedVersion: latestPublishedVersionFn = latestPublishedVersion,
+  installLatestVersion: installLatestVersionFn = (version) => installLatestVersion({
+    packageName,
+    packageRoot,
+    latestVersion: version,
+  }),
+} = {}) {
+  const current = installedVersion || currentVersion(packageRoot);
+  const latest = latestVersion || latestPublishedVersionFn(packageName);
+
+  if (!force && compareVersions(latest, current) <= 0) {
+    logger.log(`AI Desk is already up to date (${current}).`);
+    return {
+      upgraded: false,
+      installedVersion: current,
+      latestVersion: latest,
+    };
+  }
+
+  const verb = force && compareVersions(latest, current) <= 0 ? 'Reinstalling' : 'Updating';
+  logger.log(`${verb} AI Desk from ${current} to ${latest}...`);
+  const installResult = installLatestVersionFn(latest);
+  assertInstallSucceeded(installResult);
+  logger.log(`AI Desk updated to ${latest}.`);
+
+  return {
+    upgraded: true,
+    installedVersion: current,
+    latestVersion: latest,
+  };
+}
+
+function requestedCommand(args) {
+  for (const arg of args) {
+    if (arg === '--') {
+      return '';
+    }
+    if (!arg.startsWith('-')) {
+      return arg;
+    }
+  }
+  return '';
+}
+
+function shouldCheckForUpdate({
+  args,
+  isPackagedInstall: packagedInstall,
+  skipUpdate,
+  updateCommands = DEFAULT_UPDATE_COMMANDS,
+}) {
+  if (skipUpdate) {
+    return false;
+  }
+
+  if (!packagedInstall || args.includes('--help') || args.includes('-h')) {
+    return false;
+  }
+
+  return updateCommands.has(requestedCommand(args));
+}
+
+function updateBeforeCommand({
+  args,
+  packageName = DEFAULT_PACKAGE_NAME,
+  packageRoot,
+  env = process.env,
+  logger = console,
+  restartWithUpdatedCli,
+  updateCommands = DEFAULT_UPDATE_COMMANDS,
+} = {}) {
+  const command = requestedCommand(args);
+  if (!shouldCheckForUpdate({
+    args,
+    isPackagedInstall: isPackagedInstall(packageRoot),
+    skipUpdate: Boolean(env[SKIP_UPDATE_ENV]),
+    updateCommands,
+  })) {
+    return { checked: false };
+  }
+
+  logger.log('Checking for AI Desk updates...');
+
+  let result;
+  try {
+    result = upgradePackage({
+      packageName,
+      packageRoot,
+      logger,
+    });
+  } catch (error) {
+    if (command === 'upgrade') {
+      throw error;
+    }
+    logger.warn(`Unable to check for AI Desk updates: ${error.message}`);
+    return { checked: true, upgraded: false, error };
+  }
+
+  if (result.upgraded && command !== 'upgrade' && typeof restartWithUpdatedCli === 'function') {
+    logger.log(`Restarting aidesk ${command} with the updated CLI...`);
+    restartWithUpdatedCli(args);
+  }
+
+  return {
+    checked: true,
+    command,
+    ...result,
+  };
+}
+
+module.exports = {
+  DEFAULT_PACKAGE_NAME,
+  DEFAULT_UPDATE_COMMANDS,
+  SKIP_UPDATE_ENV,
+  compareVersions,
+  currentVersion,
+  findLocalProjectRoot,
+  installLatestVersion,
+  isPackagedInstall,
+  latestPublishedVersion,
+  requestedCommand,
+  shouldCheckForUpdate,
+  updateBeforeCommand,
+  upgradePackage,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-webui/ai-desk-daemon",
-  "version": "1.0.60",
+  "version": "1.0.61",
   "description": "AI Desk Daemon - CLI tool for managing the AI Desk daemon service",
   "workspaces": [
     "packages/*"
@@ -13,7 +13,7 @@
     "postinstall": "node scripts/postinstall.js",
     "prepare:packages": "node scripts/prepare-npm-packages.js",
     "publish:npm:workspaces": "node scripts/publish-npm-packages.js",
-    "test": "node bin/cli.js --help"
+    "test": "node bin/cli.js --help && node test/daemon-manager-output.test.js && node test/daemon-manager-stop-all.test.js && node test/self-upgrade.test.js"
   },
   "keywords": [
     "ai-desk",
@@ -39,16 +39,16 @@
     "chalk": "^4.1.2"
   },
   "optionalDependencies": {
-    "@agent-webui/ai-desk-daemon-darwin-arm64": "1.0.60",
-    "@agent-webui/ai-desk-daemon-darwin-x64": "1.0.60",
-    "@agent-webui/ai-desk-daemon-linux-arm64": "1.0.60",
-    "@agent-webui/ai-desk-daemon-linux-x64": "1.0.60",
-    "@agent-webui/ai-desk-daemon-win32-x64": "1.0.60",
-    "@agent-webui/ai-desk-python-darwin-arm64": "1.0.60",
-    "@agent-webui/ai-desk-python-darwin-x64": "1.0.60",
-    "@agent-webui/ai-desk-python-linux-arm64": "1.0.60",
-    "@agent-webui/ai-desk-python-linux-x64": "1.0.60",
-    "@agent-webui/ai-desk-python-win32-x64": "1.0.60"
+    "@agent-webui/ai-desk-daemon-darwin-arm64": "1.0.61",
+    "@agent-webui/ai-desk-daemon-darwin-x64": "1.0.61",
+    "@agent-webui/ai-desk-daemon-linux-arm64": "1.0.61",
+    "@agent-webui/ai-desk-daemon-linux-x64": "1.0.61",
+    "@agent-webui/ai-desk-daemon-win32-x64": "1.0.61",
+    "@agent-webui/ai-desk-python-darwin-arm64": "1.0.61",
+    "@agent-webui/ai-desk-python-darwin-x64": "1.0.61",
+    "@agent-webui/ai-desk-python-linux-arm64": "1.0.61",
+    "@agent-webui/ai-desk-python-linux-x64": "1.0.61",
+    "@agent-webui/ai-desk-python-win32-x64": "1.0.61"
   },
   "repository": {
     "type": "git",