@agent-webui/ai-desk-daemon 1.0.20 → 1.0.21

package/README.md

@@ -18,7 +18,48 @@
 
 ## 📦 安装
 
-### macOS
+### 方式 1: npm 安装（纯 CLI 工具）
+
+**适合场景**：开发者、服务器环境、CI/CD、命令行用户
+
+```bash
+# 全局安装
+npm install -g agent-webui/ai-desk-daemon
+
+# 启动 daemon
+aidesk start
+
+# 查看状态
+aidesk status
+```
+
+**包含内容**：
+- ✅ AI Desk Daemon 后台服务
+- ✅ CLI 命令行管理工具
+- ✅ HTTP API (http://localhost:9527)
+
+**不包含**：
+- ❌ 系统托盘应用 (Tray)
+- ❌ 桌面 GUI 应用
+
+**可用命令**：
+- `aidesk start` - 启动守护进程（后台运行）
+- `aidesk start --log` - 启动守护进程（前台运行，跟随日志）
+- `aidesk stop` - 停止守护进程
+- `aidesk restart` - 重启守护进程
+- `aidesk status` - 查看状态
+- `aidesk logs` - 查看日志
+- `aidesk logs -f` - 实时查看日志（不会停止守护进程）
+
+📖 详细使用说明：[NPM_CLI.md](NPM_CLI.md)
+
+---
+
+### 方式 2: 完整安装（Daemon + Tray）
+
+**适合场景**：桌面用户、需要系统托盘图标、完整 GUI 体验
+
+#### macOS
 
 ```bash
 # 下载并安装
@@ -28,7 +69,7 @@ curl -fsSL https://github.com/your-repo/ai-desk-desktop/releases/latest/download
 ./scripts/install-macos.sh
 ```
 
-### Linux
+#### Linux
 
 ```bash
 # Ubuntu/Debian
@@ -39,7 +80,7 @@ systemctl --user enable ai-desk-daemon
 systemctl --user start ai-desk-daemon
 ```
 
-### Windows
+#### Windows
 
 ```powershell
 # 以管理员身份运行 PowerShell

package/bin/cli.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+
+/**
+ * AI Desk Daemon CLI
+ */
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const fs = require('fs');
+const { start, stop, restart, status } = require('../lib/daemon-manager');
+const { getLogPath } = require('../lib/platform');
+const { VERSION } = require('../lib/platform');
+
+program
+  .name('ai-desk-daemon')
+  .description('AI Desk Daemon - CLI tool for managing the AI Desk daemon service')
+  .version(VERSION);
+
+// Start command
+program
+  .command('start')
+  .description('Start the daemon')
+  .option('--log', 'Follow daemon logs in foreground (Ctrl+C to stop daemon)')
+  .action(async (options) => {
+    try {
+      const { getPidPath } = require('../lib/platform');
+      const daemonPid = start();
+      console.log(chalk.green('✓ Daemon started successfully'));
+
+      // Only follow logs if --log is specified
+      if (options.log) {
+        console.log(chalk.cyan('\n📋 Following daemon logs (Ctrl+C to stop daemon)...\n'));
+
+        // Wait a moment for daemon to start writing logs
+        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        const logPath = getLogPath();
+        if (!fs.existsSync(logPath)) {
+          console.log(chalk.yellow('Waiting for logs...'));
+          await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+
+        // Follow logs (tail -f) - works on Unix-like systems
+        if (process.platform !== 'win32') {
+          const { spawn } = require('child_process');
+          const tail = spawn('tail', ['-f', logPath]);
+
+          tail.stdout.on('data', (data) => {
+            process.stdout.write(data);
+          });
+
+          tail.stderr.on('data', (data) => {
+            process.stderr.write(data);
+          });
+
+          tail.on('error', (error) => {
+            console.error(chalk.red('Failed to follow logs:'), error.message);
+            process.exit(1);
+          });
+
+          // Handle Ctrl+C - stop the daemon
+          process.on('SIGINT', () => {
+            console.log(chalk.yellow('\n\n⏹ Stopping daemon...'));
+            tail.kill();
+
+            try {
+              // Stop the daemon
+              const { stop } = require('../lib/daemon-manager');
+              stop();
+              console.log(chalk.green('✓ Daemon stopped successfully'));
+            } catch (error) {
+              console.error(chalk.red('✗ Failed to stop daemon:'), error.message);
+            }
+
+            process.exit(0);
+          });
+        } else {
+          // Windows: use polling to read log file
+          console.log(chalk.yellow('Log following on Windows - press Ctrl+C to stop daemon\n'));
+
+          let lastSize = 0;
+          const pollInterval = setInterval(() => {
+            try {
+              const stats = fs.statSync(logPath);
+              if (stats.size > lastSize) {
+                const stream = fs.createReadStream(logPath, {
+                  start: lastSize,
+                  end: stats.size
+                });
+                stream.on('data', (chunk) => {
+                  process.stdout.write(chunk);
+                });
+                lastSize = stats.size;
+              }
+            } catch (error) {
+              // Ignore errors
+            }
+          }, 500);
+
+          process.on('SIGINT', () => {
+            clearInterval(pollInterval);
+            console.log(chalk.yellow('\n\n⏹ Stopping daemon...'));
+
+            try {
+              // Stop the daemon
+              const { stop } = require('../lib/daemon-manager');
+              stop();
+              console.log(chalk.green('✓ Daemon stopped successfully'));
+            } catch (error) {
+              console.error(chalk.red('✗ Failed to stop daemon:'), error.message);
+            }
+
+            process.exit(0);
+          });
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to start daemon:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Stop command
+program
+  .command('stop')
+  .description('Stop the daemon')
+  .action(async () => {
+    try {
+      stop();
+      console.log(chalk.green('✓ Daemon stopped successfully'));
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to stop daemon:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Restart command
+program
+  .command('restart')
+  .description('Restart the daemon')
+  .action(async () => {
+    try {
+      restart();
+      console.log(chalk.green('✓ Daemon restarted successfully'));
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to restart daemon:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Status command
+program
+  .command('status')
+  .description('Check daemon status')
+  .action(async () => {
+    try {
+      const statusInfo = await status();
+      
+      console.log('\n' + chalk.bold('AI Desk Daemon Status'));
+      console.log('─'.repeat(40));
+      
+      if (statusInfo.running) {
+        console.log(chalk.green('● Running'));
+        
+        if (statusInfo.health && statusInfo.health.data) {
+          const { status: healthStatus, version } = statusInfo.health.data;
+          console.log(`Version: ${version || 'unknown'}`);
+          console.log(`Status: ${healthStatus}`);
+        }
+        
+        console.log(`Port: ${statusInfo.port}`);
+        console.log(`Dashboard: http://localhost:${statusInfo.port}/daemon-dashboard.html`);
+      } else {
+        console.log(chalk.red('○ Stopped'));
+      }
+      
+      console.log(`Logs: ${statusInfo.logPath}`);
+      console.log('');
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to get status:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Logs command
+program
+  .command('logs')
+  .description('View daemon logs')
+  .option('-f, --follow', 'Follow log output')
+  .option('-n, --lines <number>', 'Number of lines to show', '50')
+  .action((options) => {
+    const logPath = getLogPath();
+    
+    if (!fs.existsSync(logPath)) {
+      console.log(chalk.yellow('No logs found'));
+      return;
+    }
+    
+    if (options.follow) {
+      // Follow logs (tail -f)
+      const { spawn } = require('child_process');
+      const tail = spawn('tail', ['-f', logPath]);
+      
+      tail.stdout.on('data', (data) => {
+        process.stdout.write(data);
+      });
+      
+      tail.on('error', (error) => {
+        console.error(chalk.red('Failed to follow logs:'), error.message);
+        process.exit(1);
+      });
+    } else {
+      // Show last N lines
+      const { execSync } = require('child_process');
+      try {
+        const output = execSync(`tail -n ${options.lines} "${logPath}"`, { encoding: 'utf8' });
+        console.log(output);
+      } catch (error) {
+        console.error(chalk.red('Failed to read logs:'), error.message);
+        process.exit(1);
+      }
+    }
+  });
+
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}
+

package/lib/config.js

@@ -0,0 +1,103 @@
+/**
+ * Configuration management
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getConfigDir, getConfigPath } = require('./platform');
+
+const DEFAULT_PORT = 9527;
+
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+  const configDir = getConfigDir();
+  const logsDir = path.join(configDir, 'logs');
+  
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+}
+
+/**
+ * Load config from file
+ */
+function loadConfig() {
+  ensureConfigDir();
+  
+  const configPath = getConfigPath();
+  
+  if (!fs.existsSync(configPath)) {
+    // Create default config
+    const defaultConfig = {
+      port: DEFAULT_PORT,
+      logLevel: 'info',
+      autoStart: true
+    };
+    saveConfig(defaultConfig);
+    return defaultConfig;
+  }
+  
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error('Failed to load config:', error.message);
+    return { port: DEFAULT_PORT };
+  }
+}
+
+/**
+ * Save config to file
+ */
+function saveConfig(config) {
+  ensureConfigDir();
+  
+  const configPath = getConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+
+/**
+ * Get port from config
+ */
+function getPort() {
+  const config = loadConfig();
+  const port = config.port || DEFAULT_PORT;
+  // Ensure port is a valid integer
+  const portNum = parseInt(port, 10);
+  if (isNaN(portNum) || portNum <= 0 || portNum > 65535) {
+    console.warn(`Invalid port ${port}, using default ${DEFAULT_PORT}`);
+    return DEFAULT_PORT;
+  }
+  return portNum;
+}
+
+/**
+ * Set port in config
+ */
+function setPort(port) {
+  const config = loadConfig();
+  // Ensure port is stored as integer
+  const portNum = parseInt(port, 10);
+  if (isNaN(portNum) || portNum <= 0 || portNum > 65535) {
+    throw new Error(`Invalid port number: ${port}`);
+  }
+  config.port = portNum;
+  saveConfig(config);
+}
+
+module.exports = {
+  ensureConfigDir,
+  loadConfig,
+  saveConfig,
+  getPort,
+  setPort,
+  getConfigPath,  // Re-export from platform.js
+  DEFAULT_PORT
+};
+

package/lib/daemon-manager.js

@@ -0,0 +1,197 @@
+/**
+ * Daemon process management
+ */
+
+const fs = require('fs');
+const { spawn, execSync } = require('child_process');
+const http = require('http');
+const { getDaemonBinaryPath, getPidPath, getLogPath } = require('./platform');
+const { getPort, getConfigPath } = require('./config');
+
+/**
+ * Check if daemon is running
+ */
+function isRunning() {
+  const pidPath = getPidPath();
+  
+  if (!fs.existsSync(pidPath)) {
+    return false;
+  }
+  
+  try {
+    const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim());
+    
+    // Check if process exists
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // Process doesn't exist
+    return false;
+  }
+}
+
+/**
+ * Get daemon health status
+ */
+function getHealth() {
+  return new Promise((resolve) => {
+    const port = getPort();
+    const options = {
+      hostname: 'localhost',
+      port: port,
+      path: '/health',
+      method: 'GET',
+      timeout: 2000
+    };
+    
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const health = JSON.parse(data);
+          resolve(health);
+        } catch (error) {
+          resolve(null);
+        }
+      });
+    });
+    
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+    
+    req.end();
+  });
+}
+
+/**
+ * Start daemon
+ */
+function start() {
+  if (isRunning()) {
+    throw new Error('Daemon is already running');
+  }
+
+  const binaryPath = getDaemonBinaryPath();
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(
+      `Daemon binary not found at: ${binaryPath}\n` +
+      `This might be a corrupted installation. Try reinstalling:\n` +
+      `  npm install -g @ringcentral/ai-desk-daemon --force`
+    );
+  }
+
+  // Ensure binary is executable (Unix-like systems)
+  if (process.platform !== 'win32') {
+    try {
+      fs.chmodSync(binaryPath, 0o755);
+    } catch (error) {
+      // Ignore permission errors
+    }
+  }
+
+  const port = getPort();
+  const configPath = getConfigPath();
+  const logPath = getLogPath();
+
+  // Ensure port is a number
+  const portNumber = typeof port === 'number' ? port : parseInt(port, 10);
+  if (isNaN(portNumber)) {
+    throw new Error(`Invalid port number: ${port}`);
+  }
+
+  // Ensure log directory exists
+  const logDir = require('path').dirname(logPath);
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  // The daemon handles its own logging to file (see daemon/logger.go)
+  // It uses io.MultiWriter to write to both stdout and the log file
+  // So we should ignore stdout/stderr here to avoid duplication
+  const spawnOptions = {
+    detached: true,
+    stdio: ['ignore', 'ignore', 'ignore']  // Daemon writes to its own log file
+  };
+
+  // Windows-specific: hide console window
+  // This prevents the daemon process from showing a terminal window
+  if (process.platform === 'win32') {
+    spawnOptions.windowsHide = true;
+  }
+
+  const child = spawn(binaryPath, ['--port', portNumber.toString(), '--config', configPath], spawnOptions);
+
+  child.unref();
+
+  // Save PID
+  fs.writeFileSync(getPidPath(), child.pid.toString());
+
+  console.log(`Daemon started (PID: ${child.pid})`);
+  console.log(`Port: ${portNumber}`);
+  console.log(`Logs: ${logPath}`);
+
+  return child.pid;
+}
+
+/**
+ * Stop daemon
+ */
+function stop() {
+  const pidPath = getPidPath();
+  
+  if (!fs.existsSync(pidPath)) {
+    throw new Error('Daemon is not running');
+  }
+  
+  const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim());
+  
+  try {
+    process.kill(pid, 'SIGTERM');
+    fs.unlinkSync(pidPath);
+    console.log('Daemon stopped');
+  } catch (error) {
+    fs.unlinkSync(pidPath);
+    throw new Error(`Failed to stop daemon: ${error.message}`);
+  }
+}
+
+/**
+ * Restart daemon
+ */
+function restart() {
+  if (isRunning()) {
+    stop();
+    // Wait a bit for graceful shutdown
+    execSync('sleep 1');
+  }
+  start();
+}
+
+/**
+ * Get daemon status
+ */
+async function status() {
+  const running = isRunning();
+  const health = running ? await getHealth() : null;
+  
+  return {
+    running,
+    health,
+    port: getPort(),
+    logPath: getLogPath()
+  };
+}
+
+module.exports = {
+  isRunning,
+  getHealth,
+  start,
+  stop,
+  restart,
+  status
+};
+

package/lib/platform.js

@@ -0,0 +1,87 @@
+/**
+ * Platform detection and binary path resolution
+ */
+
+const os = require('os');
+const path = require('path');
+
+const VERSION = '1.0.21';
+
+/**
+ * Detect current platform and architecture
+ */
+function detectPlatform() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  let platformKey;
+
+  // Map Node.js platform to binary directory name
+  switch (platform) {
+    case 'darwin':
+      platformKey = arch === 'arm64' ? 'darwin-arm64' : 'darwin-x64';
+      break;
+    case 'linux':
+      platformKey = arch === 'arm64' ? 'linux-arm64' : 'linux-x64';
+      break;
+    case 'win32':
+      platformKey = 'win32-x64';
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}-${arch}`);
+  }
+
+  return { platform, arch, platformKey };
+}
+
+/**
+ * Get daemon binary path from npm package
+ */
+function getDaemonBinaryPath() {
+  const { platform, platformKey } = detectPlatform();
+
+  // Binary is in the npm package under dist/<platform>/
+  const binaryName = platform === 'win32' ? 'ai-desk-daemon.exe' : 'ai-desk-daemon';
+  const binaryPath = path.join(__dirname, '..', 'dist', platformKey, binaryName);
+
+  return binaryPath;
+}
+
+/**
+ * Get config directory
+ */
+function getConfigDir() {
+  return path.join(os.homedir(), '.aidesktop');
+}
+
+/**
+ * Get config file path
+ */
+function getConfigPath() {
+  return path.join(getConfigDir(), 'daemon-config.json');
+}
+
+/**
+ * Get log file path
+ */
+function getLogPath() {
+  return path.join(getConfigDir(), 'logs', 'daemon.log');
+}
+
+/**
+ * Get PID file path
+ */
+function getPidPath() {
+  return path.join(getConfigDir(), 'daemon.pid');
+}
+
+module.exports = {
+  detectPlatform,
+  getDaemonBinaryPath,
+  getConfigDir,
+  getConfigPath,
+  getLogPath,
+  getPidPath,
+  VERSION
+};
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-webui/ai-desk-daemon",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "description": "AI Desk Daemon - CLI tool for managing the AI Desk daemon service",
   "main": "lib/daemon-manager.js",
   "bin": {
@@ -24,6 +24,11 @@
   "files": [
     "bin/",
     "lib/",
+    "dist/darwin-arm64/",
+    "dist/darwin-x64/",
+    "dist/linux-arm64/",
+    "dist/linux-x64/",
+    "dist/win32-x64/",
     "scripts/postinstall.js",
     "README.md"
   ],

package/scripts/postinstall.js

@@ -2,12 +2,15 @@
 
 /**
  * Post-install script for @agent-webui/ai-desk-daemon
- * This script does nothing - binaries are managed separately
  * 
- * In the future, this could download platform-specific binaries from GitHub Releases
+ * This script runs after npm install to verify the installation
  */
 
-console.log('✓ @agent-webui/ai-desk-daemon installed successfully');
+const chalk = require('chalk');
+
+console.log('');
+console.log(chalk.green('✓ @agent-webui/ai-desk-daemon installed successfully'));
 console.log('');
-console.log('Note: This is a CLI wrapper. The actual daemon binaries are managed separately.');
+console.log('Run ' + chalk.cyan('aidesk --help') + ' to get started');
 console.log('');
+