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

package/bin/cli.js

@@ -11,6 +11,9 @@ const path = require('path');
 const { start, stop, restart, status } = require('../lib/daemon-manager');
 const { getLogPath } = require('../lib/platform');
 const { VERSION } = require('../lib/platform');
+const { getPort } = require('../lib/config');
+const { reportLifecycle } = require('../lib/daemon-registry');
+const { upgradePackage } = require('../lib/self-upgrade');
 
 function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -127,6 +130,17 @@ function configureRequestedMode(mode) {
   });
 }
 
+async function reportRegistryLifecycle(event) {
+  try {
+    await reportLifecycle(event, {
+      port: Number(getPort()),
+      version: VERSION,
+    });
+  } catch (error) {
+    console.warn(chalk.yellow(`[registry] Failed to report daemon ${event}: ${error.message || error}`));
+  }
+}
+
 program
   .name('aidesk')
   .description('AI Desk Daemon - CLI tool for managing the AI Desk daemon service')
@@ -145,6 +159,7 @@ program
       const mode = resolveRequestedMode(options) || 'native';
       const modeResult = configureRequestedMode(mode);
       start();
+      await reportRegistryLifecycle('start');
       if (mode === 'cli-anything' && modeResult?.runtimeInfo?.cliAnythingPath) {
         console.log(chalk.cyan(`CLI-Anything mode configured: ${modeResult.runtimeInfo.cliAnythingPath}`));
       } else if (mode === 'native') {
@@ -170,7 +185,7 @@ program
           const tail = startUnixLogFollow(logPath);
 
           // Handle Ctrl+C - stop the daemon
-          process.on('SIGINT', () => {
+          process.on('SIGINT', async () => {
             console.log(chalk.yellow('\n\n⏹ Stopping daemon...'));
             tail.kill();
 
@@ -178,6 +193,7 @@ program
               // Stop the daemon
               const { stop } = require('../lib/daemon-manager');
               stop();
+              await reportRegistryLifecycle('stop');
               console.log(chalk.green('✓ Daemon stopped successfully'));
             } catch (error) {
               console.error(chalk.red('✗ Failed to stop daemon:'), error.message);
@@ -191,7 +207,7 @@ program
 
           const pollInterval = startWindowsLogFollow(logPath);
 
-          process.on('SIGINT', () => {
+          process.on('SIGINT', async () => {
             clearInterval(pollInterval);
             console.log(chalk.yellow('\n\n⏹ Stopping daemon...'));
 
@@ -199,6 +215,7 @@ program
               // Stop the daemon
               const { stop } = require('../lib/daemon-manager');
               stop();
+              await reportRegistryLifecycle('stop');
               console.log(chalk.green('✓ Daemon stopped successfully'));
             } catch (error) {
               console.error(chalk.red('✗ Failed to stop daemon:'), error.message);
@@ -221,6 +238,7 @@ program
   .action(async () => {
     try {
       stop();
+      await reportRegistryLifecycle('stop');
       console.log(chalk.green('✓ Daemon stopped successfully'));
     } catch (error) {
       console.error(chalk.red('✗ Failed to stop daemon:'), error.message);
@@ -240,6 +258,7 @@ program
       const mode = resolveRequestedMode(options);
       const modeResult = configureRequestedMode(mode);
       restart();
+      await reportRegistryLifecycle('restart');
       if (mode === 'cli-anything' && modeResult?.runtimeInfo?.cliAnythingPath) {
         console.log(chalk.cyan(`CLI-Anything mode configured: ${modeResult.runtimeInfo.cliAnythingPath}`));
       } else if (mode === 'native') {
@@ -286,6 +305,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/daemon-registry.js

@@ -0,0 +1,254 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+const crypto = require('crypto');
+
+const DEFAULT_REGISTRY_API_BASE_URL = 'https://desk.int.rclabenv.com/';
+
+function trim(value) {
+  if (typeof value === 'string') return value.trim();
+  if (typeof value === 'number' && Number.isFinite(value)) return String(value);
+  return '';
+}
+
+function normalizeApiBaseUrl(value) {
+  const raw = trim(value).replace(/\/+$/, '');
+  if (!raw) return '';
+  return raw.endsWith('/api/v1') ? raw : `${raw}/api/v1`;
+}
+
+function parseTruthyEnv(value) {
+  const raw = trim(value).toLowerCase();
+  if (!raw) return null;
+  return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+
+function readRegistrySessionIdentity(homeDir = os.homedir()) {
+  const sessionPath = path.join(homeDir, '.aidesktop', 'session.json');
+  try {
+    if (!fs.existsSync(sessionPath)) return null;
+    const session = JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+    if (!session || typeof session !== 'object') return null;
+    const rcAccountId = trim(session.account_id || session.accountId);
+    const rcExtensionId = trim(session.extension_id || session.extensionId);
+    if (!rcAccountId || !rcExtensionId) return null;
+    return { rcAccountId, rcExtensionId };
+  } catch {
+    return null;
+  }
+}
+
+function readRegistryConfigFromDaemonConfig(homeDir = os.homedir()) {
+  const configPath = path.join(homeDir, '.aidesktop', 'daemon-config.json');
+  try {
+    if (!fs.existsSync(configPath)) return null;
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const registry = config && typeof config === 'object' ? config.registry : null;
+    if (!registry || typeof registry !== 'object') return null;
+    const sessionIdentity = readRegistrySessionIdentity(homeDir);
+    const apiBaseUrl = normalizeApiBaseUrl(
+      registry.api_base_url || registry.apiBaseUrl || DEFAULT_REGISTRY_API_BASE_URL,
+    );
+    const rcAccountId = trim(registry.rc_account_id || registry.rcAccountId) ||
+      sessionIdentity?.rcAccountId || '';
+    const rcExtensionId = trim(registry.rc_extension_id || registry.rcExtensionId) ||
+      sessionIdentity?.rcExtensionId || '';
+    if (!apiBaseUrl || !rcAccountId || !rcExtensionId) return null;
+    return {
+      apiBaseUrl,
+      rcAccountId,
+      rcExtensionId,
+      rcUsername: trim(registry.rc_username || registry.rcUsername),
+      tlsInsecureSkipVerify: Boolean(registry.tls_insecure_skip_verify || registry.tlsInsecureSkipVerify),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function getRegistryConfig(env = process.env, homeDir = os.homedir()) {
+  const daemonConfig = readRegistryConfigFromDaemonConfig(homeDir);
+  const sessionIdentity = readRegistrySessionIdentity(homeDir);
+  const apiBaseUrl = normalizeApiBaseUrl(
+    env.AI_DESK_API_BASE_URL || env.AI_DESK_BACKEND_API_URL || env.AI_DESK_BACKEND_URL,
+  ) || daemonConfig?.apiBaseUrl || normalizeApiBaseUrl(DEFAULT_REGISTRY_API_BASE_URL);
+  const rcAccountId = trim(env.AI_DESK_RC_ACCOUNT_ID || env.rcAccountId) ||
+    daemonConfig?.rcAccountId ||
+    sessionIdentity?.rcAccountId ||
+    '';
+  const rcExtensionId = trim(env.AI_DESK_RC_EXTENSION_ID || env.rcExtensionId) ||
+    daemonConfig?.rcExtensionId ||
+    sessionIdentity?.rcExtensionId ||
+    '';
+  if (apiBaseUrl && rcAccountId && rcExtensionId) {
+    const tlsEnvValue = parseTruthyEnv(env.AI_DESK_TLS_INSECURE_SKIP_VERIFY);
+    return {
+      apiBaseUrl,
+      rcAccountId,
+      rcExtensionId,
+      rcUsername: trim(env.AI_DESK_RC_USERNAME || env.rcUsername) || daemonConfig?.rcUsername || '',
+      tlsInsecureSkipVerify: tlsEnvValue === null
+        ? Boolean(daemonConfig?.tlsInsecureSkipVerify)
+        : tlsEnvValue,
+    };
+  }
+  return null;
+}
+
+function registryStatePaths(homeDir = os.homedir()) {
+  const root = path.join(homeDir, '.aidesktop');
+  return {
+    root,
+    instanceIdPath: path.join(root, 'daemon-instance-id'),
+    runStatePath: path.join(root, 'daemon-run-state.json'),
+  };
+}
+
+function ensureDaemonInstanceId(paths = registryStatePaths()) {
+  try {
+    fs.mkdirSync(paths.root, { recursive: true });
+    if (fs.existsSync(paths.instanceIdPath)) {
+      const existing = fs.readFileSync(paths.instanceIdPath, 'utf8').trim();
+      if (existing) return existing;
+    }
+    const next = `daemon-${crypto.randomUUID()}`;
+    fs.writeFileSync(paths.instanceIdPath, `${next}\n`, 'utf8');
+    return next;
+  } catch {
+    return `daemon-${crypto.randomUUID()}`;
+  }
+}
+
+function readRunState(paths = registryStatePaths()) {
+  try {
+    if (!fs.existsSync(paths.runStatePath)) return null;
+    const data = JSON.parse(fs.readFileSync(paths.runStatePath, 'utf8'));
+    return data && typeof data === 'object' ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeRunState(state, paths = registryStatePaths()) {
+  try {
+    fs.mkdirSync(paths.root, { recursive: true });
+    fs.writeFileSync(paths.runStatePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  } catch {
+    // best effort only
+  }
+}
+
+function listIpAddresses() {
+  const out = [];
+  const interfaces = os.networkInterfaces();
+  for (const items of Object.values(interfaces)) {
+    for (const item of items || []) {
+      if (!item.internal && item.address) {
+        out.push(item.address);
+      }
+    }
+  }
+  return [...new Set(out)];
+}
+
+function buildLifecyclePayload({
+  event,
+  runId,
+  seq = 1,
+  port,
+  version,
+  daemonInstanceId,
+}) {
+  return {
+    daemonInstanceId,
+    runId,
+    event,
+    seq,
+    hostname: os.hostname(),
+    osUsername: os.userInfo().username,
+    daemonVersion: version,
+    port,
+    ipAddresses: listIpAddresses(),
+  };
+}
+
+function postJSON(urlString, payload, config) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlString);
+    const body = JSON.stringify(payload);
+    const transport = url.protocol === 'https:' ? https : http;
+    const req = transport.request(
+      url,
+      {
+        method: 'POST',
+        ...(url.protocol === 'https:' && config.tlsInsecureSkipVerify
+          ? { agent: new https.Agent({ rejectUnauthorized: false }) }
+          : {}),
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+          rcAccountId: config.rcAccountId,
+          rcExtensionId: config.rcExtensionId,
+          ...(config.rcUsername ? { rcUsername: config.rcUsername } : {}),
+        },
+        timeout: 3000,
+      },
+      (res) => {
+        res.resume();
+        res.on('end', () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(true);
+          } else {
+            reject(new Error(`registry returned ${res.statusCode}`));
+          }
+        });
+      },
+    );
+    req.on('timeout', () => {
+      req.destroy(new Error('registry request timed out'));
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+async function reportLifecycle(event, { port, version, seq = 1 } = {}) {
+  const config = getRegistryConfig();
+  if (!config) return false;
+
+  const paths = registryStatePaths();
+  const daemonInstanceId = ensureDaemonInstanceId(paths);
+  let runState = readRunState(paths);
+  if (event === 'start' || event === 'restart' || !runState?.runId) {
+    runState = { runId: crypto.randomUUID(), seq: 0 };
+  }
+  runState.seq = Math.max(Number(runState.seq || 0) + 1, seq);
+  writeRunState(runState, paths);
+
+  const payload = buildLifecyclePayload({
+    event,
+    runId: runState.runId,
+    seq: runState.seq,
+    port,
+    version,
+    daemonInstanceId,
+  });
+  await postJSON(`${config.apiBaseUrl}/daemon-instances/lifecycle`, payload, config);
+  return true;
+}
+
+module.exports = {
+  buildLifecyclePayload,
+  DEFAULT_REGISTRY_API_BASE_URL,
+  getRegistryConfig,
+  readRegistrySessionIdentity,
+  readRegistryConfigFromDaemonConfig,
+  registryStatePaths,
+  ensureDaemonInstanceId,
+  readRunState,
+  writeRunState,
+  reportLifecycle,
+};

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-beta4",
   "description": "AI Desk Daemon - CLI tool for managing the AI Desk daemon service",
   "workspaces": [
     "packages/*"
@@ -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-beta4",
+    "@agent-webui/ai-desk-daemon-darwin-x64": "1.0.61-beta4",
+    "@agent-webui/ai-desk-daemon-linux-arm64": "1.0.61-beta4",
+    "@agent-webui/ai-desk-daemon-linux-x64": "1.0.61-beta4",
+    "@agent-webui/ai-desk-daemon-win32-x64": "1.0.61-beta4",
+    "@agent-webui/ai-desk-python-darwin-arm64": "1.0.61-beta4",
+    "@agent-webui/ai-desk-python-darwin-x64": "1.0.61-beta4",
+    "@agent-webui/ai-desk-python-linux-arm64": "1.0.61-beta4",
+    "@agent-webui/ai-desk-python-linux-x64": "1.0.61-beta4",
+    "@agent-webui/ai-desk-python-win32-x64": "1.0.61-beta4"
   },
   "repository": {
     "type": "git",