@agent-webui/ai-desk-daemon 1.0.17

package/README.md

@@ -0,0 +1,413 @@
+# AI Desk Desktop
+
+一个类似 Docker Desktop 的桌面应用，用于管理本地 AI CLI 工具的守护进程。
+
+<p align="center">
+  <img src="docs/images/screenshot.png" alt="AI Desk Desktop" width="800">
+</p>
+
+## ✨ 特性
+
+- 🎯 **自动启动** - Web 访问时自动检测并启动守护进程
+- 🖥️ **图形化管理** - 系统托盘 + 控制面板，便捷管理
+- 🔄 **实时监控** - 查看守护进程状态、日志和统计信息
+- 🚀 **智能启动器** - 多种方式自动唤醒守护进程
+- 🔒 **安全可靠** - 工作目录白名单、认证支持
+- 📦 **跨平台** - macOS、Windows、Linux 统一体验
+- ⚡ **高性能** - 基于 Tauri，体积小（~15MB）、内存占用低
+
+## 📦 安装
+
+### 方式 1: npm 安装（纯 CLI 工具）
+
+**适合场景**：开发者、服务器环境、CI/CD、命令行用户
+
+```bash
+# 全局安装
+npm install -g @eden_qu/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
+# 下载并安装
+curl -fsSL https://github.com/your-repo/ai-desk-desktop/releases/latest/download/install-macos.sh | bash
+
+# 或手动安装
+./scripts/install-macos.sh
+```
+
+#### Linux
+
+```bash
+# Ubuntu/Debian
+sudo ./scripts/install-linux.sh
+
+# 启用自动启动
+systemctl --user enable ai-desk-daemon
+systemctl --user start ai-desk-daemon
+```
+
+#### Windows
+
+```powershell
+# 以管理员身份运行 PowerShell
+.\scripts\install-windows.ps1
+```
+
+## 🚀 快速开始
+
+### 1. 启动桌面应用
+
+**macOS/Linux:**
+```bash
+# 从应用程序菜单启动
+open /Applications/AI\ Desk\ Desktop.app
+
+# 或命令行启动
+ai-desk-desktop
+```
+
+**Windows:**
+- 从开始菜单启动 "AI Desk Desktop"
+
+### 2. Web 应用集成
+
+在你的 Web 应用中集成智能启动器：
+
+```tsx
+// App.tsx
+import DaemonInitializer from './components/common/DaemonInitializer';
+
+function App() {
+  return (
+    <DaemonInitializer>
+      <YourMainApp />
+    </DaemonInitializer>
+  );
+}
+```
+
+启动器会自动：
+- ✅ 检测守护进程是否运行
+- ✅ 如果未运行，通过多种方式尝试启动
+- ✅ 等待守护进程就绪
+- ✅ 失败时显示友好的错误提示
+
+### 3. 使用 Daemon API
+
+```typescript
+import { daemonService } from './services/DaemonService';
+
+// 执行 CLI 命令
+const result = await daemonService.executeCLI({
+  command: 'claude',
+  args: ['--verbose'],
+  stdin: 'Your prompt here',
+  cwd: '/path/to/workspace',
+  timeout: 300000,
+});
+
+// 流式执行
+await daemonService.executeStreaming(
+  { command: 'claude', args: [], stdin: 'Hello!' },
+  (chunk) => console.log(chunk), // onChunk
+  (result) => console.log(result), // onComplete
+  (error) => console.error(error) // onError
+);
+```
+
+## 🏗️ 架构
+
+```
+┌─────────────────────────────────────────────────────┐
+│              AI Desk Desktop App                    │
+│              (Tauri Application)                    │
+│                                                     │
+│  ┌──────────┐    ┌──────────┐    ┌──────────┐    │
+│  │ System   │    │ Control  │    │ Settings │    │
+│  │ Tray     │    │ Panel    │    │ Panel    │    │
+│  └──────────┘    └──────────┘    └──────────┘    │
+│        │                │                          │
+│        └────────────────┼──────────────────────────┘
+│                         ▼
+│              ┌──────────────────┐
+│              │ Daemon Process   │
+│              │ HTTP Server :9527│
+│              └──────────────────┘
+│                         │
+│        ┌────────────────┼────────────────┐
+│        ▼                ▼                ▼
+│   ┌────────┐      ┌────────┐      ┌────────┐
+│   │ Claude │      │ Gemini │      │ Cursor │
+│   └────────┘      └────────┘      └────────┘
+│
+├─────────────────────────────────────────────────────┤
+│              Web Application                        │
+│              (React/TypeScript)                     │
+│                                                     │
+│  ┌────────────────────────────────────┐           │
+│  │  Smart Daemon Starter              │           │
+│  │  - Auto-detect & Start             │           │
+│  │  - URL Scheme / Extension / HTTP   │           │
+│  └────────────────────────────────────┘           │
+└─────────────────────────────────────────────────────┘
+```
+
+## 📚 组件说明
+
+### 1. Daemon（守护进程）
+
+基于 Go 开发的 HTTP/WebSocket 服务器：
+
+**功能**：
+- CLI 检测（claude、gemini、cursor）
+- CLI 执行（同步和流式）
+- 并发控制和超时管理
+- 安全策略（工作目录白名单）
+- 日志记录
+
+**API 端点**：
+- `GET /health` - 健康检查
+- `GET /api/v1/clis` - 检测 CLI
+- `POST /api/v1/execute` - 执行 CLI（REST）
+- `WS /api/v1/execute/stream` - 执行 CLI（WebSocket）
+- `POST /api/v1/execute/{id}/cancel` - 取消执行
+
+### 2. Tauri Desktop（桌面应用）
+
+基于 Tauri（Rust + React）的桌面应用：
+
+**功能**：
+- 系统托盘图标和菜单
+- 守护进程生命周期管理
+- 实时状态监控
+- 日志查看
+- 设置管理
+- URL Scheme 注册
+
+### 3. Web Integration（Web 集成）
+
+**Smart Daemon Starter（智能启动器）**：
+- 自动检测守护进程
+- 多种启动方式（URL Scheme、Extension、HTTP）
+- 自动重试机制
+- 友好的错误提示
+
+**Daemon Service（守护进程服务）**：
+- HTTP/WebSocket 通信
+- CLI 执行和流式输出
+- 错误处理
+
+## ⚙️ 配置
+
+### Daemon 配置
+
+配置文件位置：`~/.aidesktop/daemon-config.json`
+
+```json
+{
+  "port": 9527,
+  "max_concurrent_executions": 10,
+  "execution_timeout": 300,
+  "allowed_origins": [
+    "*"
+  ],
+  "allowed_working_dirs": [
+    "/path/to/your/home"
+  ],
+  "require_authentication": false,
+  "auth_token": "",
+  "log_level": "INFO"
+}
+```
+
+说明：`9527` 是默认端口，实际运行时以 `~/.aidesktop/daemon-config.json` 中的 `port` 为准。
+
+### 应用配置
+
+配置文件位置：`~/.aidesktop/app-config.json`
+
+```json
+{
+  "auto_start": true,
+  "minimize_to_tray": true,
+  "daemon_port": 9527
+}
+```
+
+如果你修改了 daemon 配置端口，请保持这里的 `daemon_port` 与之同步。
+
+## 🔧 开发
+
+### 前置要求
+
+- **Node.js** 18+
+- **Rust** 1.70+
+- **Go** 1.21+ (用于守护进程)
+- **Tauri CLI** 1.5+
+
+### 构建
+
+```bash
+# 克隆仓库
+git clone https://github.com/your-repo/ai-desk-desktop.git
+cd ai-desk-desktop
+
+# 安装依赖
+npm install
+
+# 构建所有组件
+./scripts/build.sh
+
+# 或分别构建：
+
+# 1. 构建守护进程
+cd daemon && go build -o ai-desk-daemon
+
+# 2. 构建前端
+npm run build
+
+# 3. 构建 Tauri 应用
+npm run tauri build
+```
+
+### 开发模式
+
+```bash
+# 终端 1: 启动守护进程
+cd daemon
+go run .
+
+# 终端 2: 启动 Tauri 应用
+npm run tauri:dev
+```
+
+## 📖 使用示例
+
+### 在 Web 应用中显示守护进程状态
+
+```tsx
+import { DaemonStatusIndicator } from './components/common/DaemonStatusBanner';
+
+function Layout() {
+  return (
+    <div>
+      <Header />
+      <Content />
+      <DaemonStatusIndicator /> {/* 显示在右下角 */}
+    </div>
+  );
+}
+```
+
+### 条件渲染（守护进程可用时）
+
+```tsx
+import { useDaemon } from './hooks/useDaemon';
+
+function AgentPanel() {
+  const { isAvailable, isChecking } = useDaemon();
+
+  if (isChecking) {
+    return <div>Checking daemon...</div>;
+  }
+
+  if (!isAvailable) {
+    return (
+      <div>
+        Daemon not available. 
+        <button onClick={() => window.location.href = 'aidesktop://start'}>
+          Launch Now
+        </button>
+      </div>
+    );
+  }
+
+  return <YourAgentInterface />;
+}
+```
+
+## 🐛 故障排查
+
+### macOS Gatekeeper 警告
+
+**问题**：macOS 阻止运行未签名的应用
+
+**解决方案**：
+```bash
+# 移除隔离属性
+xattr -cr "/Applications/AI Desk Desktop.app"
+```
+
+### 守护进程未启动
+
+**检查日志**：
+```bash
+tail -f ~/.aidesktop/logs/daemon.log
+```
+
+**手动启动测试**：
+```bash
+/usr/local/bin/ai-desk-daemon --config ~/.aidesktop/daemon-config.json
+```
+
+### Web 应用无法连接
+
+1. 检查守护进程是否运行：
+   ```bash
+   curl http://localhost:<port>/health
+   ```
+
+2. 检查防火墙设置
+3. 确认配置文件中的端口未被占用
+
+## 📄 许可证
+
+MIT License
+
+## 🤝 贡献
+
+欢迎提交 Issues 和 Pull Requests！
+
+## 📧 支持
+
+- GitHub Issues: https://github.com/your-repo/ai-desk-desktop/issues
+- 文档: https://docs.aidesktop.com
+
+---
+
+**Version**: 1.0.0  
+**Maintained by**: AI Desk Team

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,189 @@
+/**
+ * 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 child = spawn(binaryPath, ['--port', portNumber.toString(), '--config', configPath], {
+    detached: true,
+    stdio: ['ignore', 'ignore', 'ignore']  // Daemon writes to its own log file
+  });
+
+  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.17';
+
+/**
+ * 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

@@ -0,0 +1,42 @@
+{
+  "name": "@agent-webui/ai-desk-daemon",
+  "version": "1.0.17",
+  "description": "AI Desk Daemon - CLI tool for managing the AI Desk daemon service",
+  "main": "lib/daemon-manager.js",
+  "bin": {
+    "aidesk": "bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node bin/cli.js --help"
+  },
+  "keywords": [
+    "ai-desk",
+    "daemon",
+    "cli",
+    "agent-webui"
+  ],
+  "author": "Agent WebUI",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/postinstall.js",
+    "README.md"
+  ],
+  "dependencies": {
+    "commander": "^11.0.0",
+    "chalk": "^4.1.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agent-webui/ai-desk-daemon.git"
+  },
+  "homepage": "https://github.com/agent-webui",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script to download platform-specific daemon binary from GitHub Releases
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const GITHUB_REPO = 'agent-webui/ai-desk-daemon';
+const PACKAGE_VERSION = require('../package.json').version;
+
+// Platform mapping
+const PLATFORM_MAP = {
+  'darwin-x64': 'darwin-x64',
+  'darwin-arm64': 'darwin-arm64',
+  'linux-x64': 'linux-x64',
+  'linux-arm64': 'linux-arm64',
+  'win32-x64': 'win32-x64'
+};
+
+function getPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const key = `${platform}-${arch}`;
+  
+  if (!PLATFORM_MAP[key]) {
+    console.error(`Unsupported platform: ${platform}-${arch}`);
+    console.error('Supported platforms:', Object.keys(PLATFORM_MAP).join(', '));
+    process.exit(1);
+  }
+  
+  return PLATFORM_MAP[key];
+}
+
+function getBinaryName(platform) {
+  return platform.startsWith('win32') ? 'ai-desk-daemon.exe' : 'ai-desk-daemon';
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    console.log(`Downloading from: ${url}`);
+    
+    const file = fs.createWriteStream(dest);
+    
+    https.get(url, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        // Follow redirect
+        file.close();
+        fs.unlinkSync(dest);
+        return downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+      }
+      
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(dest);
+        return reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
+      }
+      
+      const totalSize = parseInt(response.headers['content-length'], 10);
+      let downloadedSize = 0;
+      let lastPercent = 0;
+      
+      response.on('data', (chunk) => {
+        downloadedSize += chunk.length;
+        const percent = Math.floor((downloadedSize / totalSize) * 100);
+        if (percent > lastPercent && percent % 10 === 0) {
+          console.log(`Progress: ${percent}%`);
+          lastPercent = percent;
+        }
+      });
+      
+      response.pipe(file);
+      
+      file.on('finish', () => {
+        file.close();
+        console.log('Download complete!');
+        resolve();
+      });
+    }).on('error', (err) => {
+      file.close();
+      fs.unlinkSync(dest);
+      reject(err);
+    });
+  });
+}
+
+async function main() {
+  console.log('='.repeat(50));
+  console.log('AI Desk Daemon - Post Install');
+  console.log('='.repeat(50));
+  
+  const platform = getPlatform();
+  const binaryName = getBinaryName(platform);
+  
+  console.log(`Platform: ${platform}`);
+  console.log(`Version: ${PACKAGE_VERSION}`);
+  console.log(`Binary: ${binaryName}`);
+  console.log('');
+  
+  // Create dist directory
+  const distDir = path.join(__dirname, '..', 'dist', platform);
+  if (!fs.existsSync(distDir)) {
+    fs.mkdirSync(distDir, { recursive: true });
+  }
+  
+  const binaryPath = path.join(distDir, binaryName);
+  
+  // Check if binary already exists
+  if (fs.existsSync(binaryPath)) {
+    console.log('Binary already exists, skipping download.');
+    console.log(`Location: ${binaryPath}`);
+    return;
+  }
+  
+  // Download from GitHub Releases
+  // Format: ai-desk-daemon-darwin-arm64 or ai-desk-daemon-win32-x64.exe
+  const assetName = platform.startsWith('win32')
+    ? `ai-desk-daemon-${platform}.exe`
+    : `ai-desk-daemon-${platform}`;
+  const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/${assetName}`;
+  
+  console.log('Downloading daemon binary...');
+  
+  try {
+    await downloadFile(downloadUrl, binaryPath);
+    
+    // Set executable permission (Unix-like systems)
+    if (process.platform !== 'win32') {
+      fs.chmodSync(binaryPath, 0o755);
+      console.log('Set executable permission');
+    }
+    
+    console.log('');
+    console.log('✓ Installation complete!');
+    console.log(`Binary installed at: ${binaryPath}`);
+    console.log('');
+    console.log('Run "aidesk --help" to get started.');
+    console.log('='.repeat(50));
+  } catch (error) {
+    console.error('');
+    console.error('✗ Failed to download daemon binary');
+    console.error(`Error: ${error.message}`);
+    console.error('');
+    console.error('Please try one of the following:');
+    console.error(`1. Download manually from: https://github.com/${GITHUB_REPO}/releases/tag/v${PACKAGE_VERSION}`);
+    console.error(`2. Place the binary at: ${binaryPath}`);
+    console.error('3. Report this issue at: https://github.com/${GITHUB_REPO}/issues');
+    console.error('='.repeat(50));
+    process.exit(1);
+  }
+}
+
+main();
+