deepseek-cowork 0.1.0

package/bin/cli.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+/**
+ * DeepSeek Cowork CLI 入口
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import { program } from 'commander';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync } from 'fs';
+
+// 获取包根目录
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = join(__dirname, '..');
+
+// 读取 package.json
+const packageJson = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+
+// 导入命令
+import { startCommand } from '../commands/start.mjs';
+import { stopCommand } from '../commands/stop.mjs';
+import { statusCommand } from '../commands/status.mjs';
+import { configCommand } from '../commands/config.mjs';
+import { openCommand } from '../commands/open.mjs';
+import { loginCommand } from '../commands/login.mjs';
+import { logoutCommand } from '../commands/logout.mjs';
+
+// 配置程序
+program
+    .name('deepseek-cowork')
+    .description('Open-Source Alternative to Claude Cowork - CLI Tool')
+    .version(packageJson.version);
+
+// 注册命令
+program
+    .command('start')
+    .description('Start the local service')
+    .option('-d, --daemon', 'Run in background as daemon')
+    .option('-p, --port <port>', 'HTTP port', '3333')
+    .option('--ws-port <port>', 'WebSocket port', '8080')
+    .option('-w, --work-dir <path>', 'Working directory')
+    .option('--debug', 'Enable debug mode')
+    .action(startCommand);
+
+program
+    .command('stop')
+    .description('Stop the local service')
+    .action(stopCommand);
+
+program
+    .command('status')
+    .description('Show service status')
+    .option('-j, --json', 'Output as JSON')
+    .action(statusCommand);
+
+program
+    .command('config')
+    .description('Manage configuration')
+    .argument('[action]', 'Action: list, get, set', 'list')
+    .argument('[key]', 'Configuration key')
+    .argument('[value]', 'Configuration value')
+    .action(configCommand);
+
+program
+    .command('open')
+    .description('Open web interface in browser')
+    .option('-l, --local', 'Open local interface instead of public website')
+    .action(openCommand);
+
+program
+    .command('login')
+    .description('Login with your Happy AI account')
+    .option('-s, --secret <secret>', 'Provide secret directly')
+    .action(loginCommand);
+
+program
+    .command('logout')
+    .description('Logout from your account')
+    .action(logoutCommand);
+
+// 默认命令：显示帮助
+program
+    .action(() => {
+        program.help();
+    });
+
+// 解析命令行参数
+program.parse();

package/commands/config.mjs

@@ -0,0 +1,154 @@
+/**
+ * config 命令 - 管理配置
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import chalk from 'chalk';
+import { getConfig, getUserSettings } from '../index.mjs';
+
+/**
+ * 配置管理命令
+ */
+export async function configCommand(action = 'list', key = null, value = null) {
+    try {
+        const config = await getConfig();
+        const userSettings = await getUserSettings();
+        
+        // 初始化用户设置
+        userSettings.initialize();
+        
+        switch (action) {
+            case 'list':
+                listConfig(userSettings, config);
+                break;
+                
+            case 'get':
+                if (!key) {
+                    console.error(chalk.red('Error: Key is required'));
+                    console.log(chalk.dim('Usage: deepseek-cowork config get <key>'));
+                    process.exit(1);
+                }
+                getConfigValue(userSettings, key);
+                break;
+                
+            case 'set':
+                if (!key) {
+                    console.error(chalk.red('Error: Key is required'));
+                    console.log(chalk.dim('Usage: deepseek-cowork config set <key> <value>'));
+                    process.exit(1);
+                }
+                setConfigValue(userSettings, key, value);
+                break;
+                
+            default:
+                console.error(chalk.red(`Unknown action: ${action}`));
+                console.log(chalk.dim('Available actions: list, get, set'));
+                process.exit(1);
+        }
+        
+    } catch (error) {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+}
+
+/**
+ * 列出所有配置
+ */
+function listConfig(userSettings, config) {
+    const settings = userSettings.getAll();
+    
+    console.log('');
+    console.log(chalk.bold('DeepSeek Cowork Configuration'));
+    console.log(chalk.dim('─'.repeat(50)));
+    
+    // 服务器配置
+    console.log('');
+    console.log(chalk.cyan('Server:'));
+    console.log(`  server.httpPort:       ${settings.server?.httpPort || config.DEFAULT_HTTP_PORT}`);
+    console.log(`  server.wsPort:         ${settings.server?.wsPort || config.DEFAULT_WS_PORT}`);
+    console.log(`  server.autoStart:      ${settings.server?.autoStart || false}`);
+    
+    // Happy AI 配置
+    console.log('');
+    console.log(chalk.cyan('Happy AI:'));
+    console.log(`  happy.workspaceDir:    ${settings.happy?.workspaceDir || '(default)'}`);
+    console.log(`  happy.permissionMode:  ${settings.happy?.permissionMode || 'default'}`);
+    console.log(`  happy.serverUrl:       ${settings.happy?.serverUrl || '(default)'}`);
+    console.log(`  happy.autoMonitor:     ${settings.happy?.autoMonitor !== false}`);
+    console.log(`  happy.debug:           ${settings.happy?.debug || false}`);
+    
+    // Claude Code 配置
+    console.log('');
+    console.log(chalk.cyan('Claude Code:'));
+    const claudeCode = settings.happy?.claudeCode || {};
+    console.log(`  happy.claudeCode.provider:         ${claudeCode.provider || 'anthropic'}`);
+    console.log(`  happy.claudeCode.baseUrl:          ${claudeCode.baseUrl || '(default)'}`);
+    console.log(`  happy.claudeCode.model:            ${claudeCode.model || '(default)'}`);
+    console.log(`  happy.claudeCode.smallFastModel:   ${claudeCode.smallFastModel || '(default)'}`);
+    console.log(`  happy.claudeCode.timeoutMs:        ${claudeCode.timeoutMs || 600000}`);
+    
+    // 路径信息
+    console.log('');
+    console.log(chalk.cyan('Paths:'));
+    console.log(`  Data directory:        ${config.getDataDir()}`);
+    console.log(`  Settings file:         ${userSettings.getSettingsPath()}`);
+    console.log(`  Default workspace:     ${config.getDefaultWorkspaceDir()}`);
+    
+    console.log('');
+    console.log(chalk.dim('To modify a setting:'));
+    console.log(chalk.dim('  deepseek-cowork config set <key> <value>'));
+    console.log('');
+}
+
+/**
+ * 获取配置值
+ */
+function getConfigValue(userSettings, key) {
+    const value = userSettings.get(key);
+    
+    if (value === undefined) {
+        console.log(chalk.yellow(`Key "${key}" is not set`));
+    } else if (typeof value === 'object') {
+        console.log(JSON.stringify(value, null, 2));
+    } else {
+        console.log(value);
+    }
+}
+
+/**
+ * 设置配置值
+ */
+function setConfigValue(userSettings, key, value) {
+    // 解析值类型
+    let parsedValue = value;
+    
+    if (value === 'true') {
+        parsedValue = true;
+    } else if (value === 'false') {
+        parsedValue = false;
+    } else if (value === 'null' || value === null) {
+        parsedValue = null;
+    } else if (!isNaN(value) && value !== '') {
+        // 尝试解析为数字
+        const num = parseFloat(value);
+        if (!isNaN(num)) {
+            parsedValue = num;
+        }
+    }
+    
+    // 保存设置
+    userSettings.set(key, parsedValue);
+    
+    console.log(chalk.green('✓'), `Set ${chalk.cyan(key)} = ${chalk.white(JSON.stringify(parsedValue))}`);
+    
+    // 某些设置可能需要重启服务
+    const needsRestart = ['server.httpPort', 'server.wsPort', 'happy.serverUrl'];
+    if (needsRestart.includes(key)) {
+        console.log(chalk.yellow('\nNote: This change will take effect after restarting the service'));
+        console.log(chalk.dim('  deepseek-cowork stop && deepseek-cowork start'));
+    }
+}
+
+export default configCommand;

package/commands/login.mjs

@@ -0,0 +1,155 @@
+/**
+ * login 命令 - 登录账户
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { createInterface } from 'readline';
+import { getConfig, getSecureSettings, getUserSettings } from '../index.mjs';
+
+/**
+ * 登录命令
+ */
+export async function loginCommand(options) {
+    const spinner = ora();
+    
+    try {
+        const config = await getConfig();
+        const secureSettings = await getSecureSettings();
+        const userSettings = await getUserSettings();
+        
+        // 初始化设置
+        config.initializeDirectories();
+        userSettings.initialize();
+        await secureSettings.initialize();
+        
+        // 检查是否已登录
+        if (secureSettings.hasSecret('happy.secret')) {
+            console.log(chalk.yellow('⚠  You are already logged in'));
+            console.log('');
+            console.log(chalk.dim('To switch accounts, logout first:'));
+            console.log(chalk.white('  deepseek-cowork logout'));
+            console.log('');
+            return;
+        }
+        
+        let secret = options.secret;
+        
+        // 如果没有通过参数提供 secret，提示用户输入
+        if (!secret) {
+            console.log('');
+            console.log(chalk.bold('DeepSeek Cowork Login'));
+            console.log(chalk.dim('─'.repeat(40)));
+            console.log('');
+            console.log('Please enter your Happy AI Secret.');
+            console.log(chalk.dim('You can find it at: https://deepseek-cowork.com/account'));
+            console.log('');
+            
+            secret = await promptSecret('Secret: ');
+            console.log('');
+        }
+        
+        if (!secret || secret.trim() === '') {
+            console.log(chalk.red('Error: Secret is required'));
+            process.exit(1);
+        }
+        
+        // 动态导入验证模块
+        spinner.start('Validating secret...');
+        
+        const { createRequire } = await import('module');
+        const require = createRequire(import.meta.url);
+        const SecretGenerator = require(config.getDataDir() + '/../../lib/happy-client/utils/SecretGenerator');
+        
+        // 验证格式
+        const validation = SecretGenerator.validateSecretFormat(secret.trim());
+        
+        if (!validation.valid) {
+            spinner.fail(`Invalid secret format: ${validation.error}`);
+            process.exit(1);
+        }
+        
+        spinner.text = 'Verifying with server...';
+        
+        // 尝试获取 Token 验证有效性
+        try {
+            const Auth = require(config.getDataDir() + '/../../lib/happy-client/core/Auth');
+            const auth = new Auth();
+            const serverUrl = userSettings.get('happy.serverUrl') || 'https://api.deepseek-cowork.com';
+            const masterSecret = Buffer.from(validation.normalized, 'base64url');
+            
+            const token = await auth.getToken(masterSecret, serverUrl);
+            
+            if (!token) {
+                spinner.fail('Failed to verify secret with server');
+                process.exit(1);
+            }
+            
+            spinner.text = 'Saving credentials...';
+            
+            // 保存 secret
+            secureSettings.setSecret('happy.secret', validation.normalized);
+            
+            // 同步到 ~/.happy/access.key
+            const path = await import('path');
+            const fs = await import('fs');
+            const os = await import('os');
+            
+            const happyHomeDir = path.join(os.homedir(), '.happy');
+            const accessKeyPath = path.join(happyHomeDir, 'access.key');
+            
+            if (!fs.existsSync(happyHomeDir)) {
+                fs.mkdirSync(happyHomeDir, { recursive: true });
+            }
+            
+            const secretBytes = Buffer.from(validation.normalized, 'base64url');
+            const credentials = {
+                secret: secretBytes.toString('base64'),
+                token: token
+            };
+            
+            fs.writeFileSync(accessKeyPath, JSON.stringify(credentials, null, 2), 'utf8');
+            
+            spinner.succeed('Login successful!');
+            console.log('');
+            console.log(chalk.green('You are now logged in.'));
+            console.log('');
+            console.log(chalk.cyan('Start the service:'), chalk.white('deepseek-cowork start'));
+            console.log(chalk.cyan('Open web interface:'), chalk.white('deepseek-cowork open'));
+            console.log('');
+            
+        } catch (error) {
+            spinner.fail(`Verification failed: ${error.message}`);
+            process.exit(1);
+        }
+        
+    } catch (error) {
+        spinner.fail(`Login failed: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+/**
+ * 提示用户输入（隐藏输入）
+ */
+async function promptSecret(prompt) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        
+        // 隐藏输入
+        process.stdout.write(prompt);
+        
+        // 在 Windows 上可能不支持隐藏输入，使用普通输入
+        rl.question('', (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+
+export default loginCommand;

package/commands/logout.mjs

@@ -0,0 +1,69 @@
+/**
+ * logout 命令 - 登出账户
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getConfig, getSecureSettings, getUserSettings } from '../index.mjs';
+import { readPidFile, isProcessRunning, killProcess, waitForProcessExit, removePidFile } from '../utils/process.mjs';
+
+/**
+ * 登出命令
+ */
+export async function logoutCommand(options) {
+    const spinner = ora('Logging out...').start();
+    
+    try {
+        const config = await getConfig();
+        const secureSettings = await getSecureSettings();
+        const userSettings = await getUserSettings();
+        
+        // 初始化设置
+        userSettings.initialize();
+        await secureSettings.initialize();
+        
+        // 检查是否已登录
+        if (!secureSettings.hasSecret('happy.secret')) {
+            spinner.info('You are not logged in');
+            return;
+        }
+        
+        // 检查服务是否运行，如果是则先停止
+        const pid = readPidFile(config.getPidFilePath());
+        if (pid && isProcessRunning(pid)) {
+            spinner.text = 'Stopping service...';
+            
+            killProcess(pid, 'SIGTERM');
+            await waitForProcessExit(pid, 5000);
+            removePidFile(config.getPidFilePath());
+        }
+        
+        // 删除 secret
+        spinner.text = 'Removing credentials...';
+        secureSettings.deleteSecret('happy.secret');
+        secureSettings.deleteSecret('claude.authToken');
+        
+        // 删除 ~/.happy/access.key
+        const accessKeyPath = join(homedir(), '.happy', 'access.key');
+        if (existsSync(accessKeyPath)) {
+            unlinkSync(accessKeyPath);
+        }
+        
+        spinner.succeed('Logged out successfully');
+        console.log('');
+        console.log(chalk.dim('Your local data has been preserved.'));
+        console.log(chalk.dim('To login again: deepseek-cowork login'));
+        console.log('');
+        
+    } catch (error) {
+        spinner.fail(`Logout failed: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+export default logoutCommand;

package/commands/open.mjs

@@ -0,0 +1,91 @@
+/**
+ * open 命令 - 打开 Web 界面
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import open from 'open';
+import { getConfig } from '../index.mjs';
+import { readPidFile, isProcessRunning } from '../utils/process.mjs';
+
+// 公域网站地址
+const PUBLIC_URL = 'https://deepseek-cowork.com';
+
+/**
+ * 打开 Web 界面命令
+ */
+export async function openCommand(options) {
+    try {
+        const config = await getConfig();
+        const port = config.DEFAULT_HTTP_PORT;
+        
+        // 检查本地服务是否运行
+        const pid = readPidFile(config.getPidFilePath());
+        const isRunning = pid && isProcessRunning(pid);
+        
+        let serviceAvailable = false;
+        
+        if (isRunning) {
+            // 尝试连接本地服务
+            try {
+                const response = await fetch(`http://localhost:${port}/api/ping`, {
+                    signal: AbortSignal.timeout(2000)
+                });
+                serviceAvailable = response.ok;
+            } catch (e) {
+                // 服务未响应
+            }
+        }
+        
+        if (!serviceAvailable) {
+            console.log(chalk.yellow('⚠  Local service is not running'));
+            console.log('');
+            
+            if (!options.local) {
+                // 询问是否启动服务
+                console.log('The web interface requires the local service to function properly.');
+                console.log('');
+                console.log(chalk.cyan('Start the service first:'));
+                console.log(chalk.white('  deepseek-cowork start --daemon'));
+                console.log('');
+                console.log(chalk.dim('Or open the public website without local features:'));
+                console.log(chalk.dim(`  ${PUBLIC_URL}`));
+                console.log('');
+                return;
+            }
+        }
+        
+        // 确定要打开的 URL
+        let url;
+        
+        if (options.local) {
+            // 打开本地界面（如果部署了本地前端）
+            // 目前本地前端使用 Electron，这里打开的是公域网站连接本地服务
+            url = `${PUBLIC_URL}?local=true`;
+            console.log(chalk.dim('Opening local interface...'));
+        } else {
+            // 打开公域网站
+            url = PUBLIC_URL;
+            console.log(chalk.dim('Opening web interface...'));
+        }
+        
+        // 打开浏览器
+        await open(url);
+        
+        console.log('');
+        console.log(chalk.green('✓'), `Opened ${chalk.cyan(url)}`);
+        
+        if (serviceAvailable) {
+            console.log(chalk.dim(`  Local service: http://localhost:${port}`));
+        }
+        console.log('');
+        
+    } catch (error) {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+}
+
+export default openCommand;

package/commands/start.mjs

@@ -0,0 +1,228 @@
+/**
+ * start 命令 - 启动本地服务
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync, writeFileSync, readFileSync } from 'fs';
+import { getLocalService, getConfig } from '../index.mjs';
+import { checkPort, writePidFile, readPidFile, isProcessRunning } from '../utils/process.mjs';
+
+/**
+ * 启动服务命令
+ */
+export async function startCommand(options) {
+    const spinner = ora('Starting DeepSeek Cowork...').start();
+    
+    try {
+        // 获取配置
+        const config = await getConfig();
+        const httpPort = parseInt(options.port) || config.DEFAULT_HTTP_PORT;
+        const wsPort = parseInt(options.wsPort) || config.DEFAULT_WS_PORT;
+        const workDir = options.workDir || null;
+        const debug = options.debug || false;
+        
+        // 检查是否已有服务运行
+        const existingPid = readPidFile(config.getPidFilePath());
+        if (existingPid && isProcessRunning(existingPid)) {
+            spinner.fail(`DeepSeek Cowork is already running (PID: ${existingPid})`);
+            console.log(chalk.yellow('\nUse `deepseek-cowork status` to check status'));
+            console.log(chalk.yellow('Use `deepseek-cowork stop` to stop the service'));
+            process.exit(1);
+        }
+        
+        // 检查端口是否可用
+        const httpPortAvailable = await checkPort(httpPort);
+        if (!httpPortAvailable) {
+            spinner.fail(`Port ${httpPort} is already in use`);
+            console.log(chalk.yellow(`\nTry using a different port with --port <port>`));
+            process.exit(1);
+        }
+        
+        if (options.daemon) {
+            // 后台模式运行
+            spinner.text = 'Starting in background mode...';
+            
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            const startScript = join(__dirname, 'start-daemon.mjs');
+            
+            // 创建后台启动脚本（如果不存在）
+            if (!existsSync(startScript)) {
+                createDaemonScript(startScript);
+            }
+            
+            // 启动后台进程
+            const child = spawn(process.execPath, [
+                '--no-warnings',
+                startScript,
+                '--port', httpPort.toString(),
+                '--ws-port', wsPort.toString(),
+                ...(workDir ? ['--work-dir', workDir] : []),
+                ...(debug ? ['--debug'] : [])
+            ], {
+                detached: true,
+                stdio: 'ignore',
+                env: { ...process.env, FORCE_COLOR: '1' }
+            });
+            
+            child.unref();
+            
+            // 保存 PID
+            writePidFile(config.getPidFilePath(), child.pid);
+            
+            // 等待服务启动
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            // 检查服务是否启动成功
+            try {
+                const response = await fetch(`http://localhost:${httpPort}/api/ping`);
+                if (response.ok) {
+                    spinner.succeed('DeepSeek Cowork started in background');
+                    console.log('');
+                    console.log(chalk.green(`  PID:       ${child.pid}`));
+                    console.log(chalk.green(`  HTTP:      http://localhost:${httpPort}`));
+                    console.log(chalk.green(`  WebSocket: ws://localhost:${wsPort}`));
+                    console.log('');
+                    console.log(chalk.cyan('  Open web interface:'), chalk.white('deepseek-cowork open'));
+                    console.log(chalk.cyan('  Check status:      '), chalk.white('deepseek-cowork status'));
+                    console.log(chalk.cyan('  Stop service:      '), chalk.white('deepseek-cowork stop'));
+                } else {
+                    throw new Error('Service not responding');
+                }
+            } catch (e) {
+                spinner.warn('Service started but may not be fully ready');
+                console.log(chalk.yellow('\nCheck status with: deepseek-cowork status'));
+            }
+            
+        } else {
+            // 前台模式运行
+            spinner.text = 'Initializing services...';
+            
+            const localService = await getLocalService();
+            
+            // 初始化服务
+            const initResult = await localService.initialize({
+                httpPort,
+                wsPort,
+                workDir,
+                debug
+            });
+            
+            if (!initResult.success) {
+                spinner.fail(`Initialization failed: ${initResult.error}`);
+                process.exit(1);
+            }
+            
+            spinner.text = 'Starting HTTP server...';
+            
+            // 启动服务
+            const startResult = await localService.start();
+            
+            if (!startResult.success) {
+                spinner.fail(`Failed to start: ${startResult.error}`);
+                process.exit(1);
+            }
+            
+            // 保存 PID
+            writePidFile(config.getPidFilePath(), process.pid);
+            
+            spinner.succeed('DeepSeek Cowork started');
+            console.log('');
+            console.log(chalk.green(`  HTTP:      http://localhost:${startResult.httpPort}`));
+            console.log(chalk.green(`  WebSocket: ws://localhost:${startResult.wsPort}`));
+            console.log('');
+            console.log(chalk.dim('  Press Ctrl+C to stop'));
+            console.log('');
+            
+            // 处理退出信号
+            const cleanup = async () => {
+                console.log('\n');
+                const stopSpinner = ora('Stopping service...').start();
+                await localService.stop();
+                
+                // 删除 PID 文件
+                const fs = await import('fs');
+                try {
+                    fs.unlinkSync(config.getPidFilePath());
+                } catch (e) {
+                    // 忽略错误
+                }
+                
+                stopSpinner.succeed('Service stopped');
+                process.exit(0);
+            };
+            
+            process.on('SIGINT', cleanup);
+            process.on('SIGTERM', cleanup);
+        }
+        
+    } catch (error) {
+        spinner.fail(`Failed to start: ${error.message}`);
+        if (options.debug) {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+}
+
+/**
+ * 创建后台启动脚本
+ */
+function createDaemonScript(scriptPath) {
+    const script = `#!/usr/bin/env node
+
+/**
+ * DeepSeek Cowork Daemon 启动脚本
+ * 自动生成，请勿手动修改
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// 解析命令行参数
+const args = process.argv.slice(2);
+const options = {};
+
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--port') {
+        options.httpPort = parseInt(args[++i]);
+    } else if (args[i] === '--ws-port') {
+        options.wsPort = parseInt(args[++i]);
+    } else if (args[i] === '--work-dir') {
+        options.workDir = args[++i];
+    } else if (args[i] === '--debug') {
+        options.debug = true;
+    }
+}
+
+// 导入并启动服务
+const { getLocalService } = await import('../index.mjs');
+const localService = await getLocalService();
+
+async function main() {
+    try {
+        await localService.initialize(options);
+        await localService.start();
+        console.log('DeepSeek Cowork daemon started');
+    } catch (error) {
+        console.error('Failed to start daemon:', error.message);
+        process.exit(1);
+    }
+}
+
+main();
+`;
+
+    writeFileSync(scriptPath, script, 'utf8');
+}
+
+export default startCommand;

package/commands/status.mjs

@@ -0,0 +1,129 @@
+/**
+ * status 命令 - 显示服务状态
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import chalk from 'chalk';
+import { getConfig } from '../index.mjs';
+import { readPidFile, isProcessRunning } from '../utils/process.mjs';
+
+/**
+ * 状态命令
+ */
+export async function statusCommand(options) {
+    try {
+        const config = await getConfig();
+        const pidPath = config.getPidFilePath();
+        const pid = readPidFile(pidPath);
+        const port = config.DEFAULT_HTTP_PORT;
+        
+        // 基础状态
+        const status = {
+            pid: pid,
+            running: false,
+            httpPort: port,
+            wsPort: config.DEFAULT_WS_PORT,
+            dataDir: config.getDataDir(),
+            service: null
+        };
+        
+        // 检查进程是否运行
+        if (pid && isProcessRunning(pid)) {
+            status.running = true;
+            
+            // 尝试获取详细状态
+            try {
+                const response = await fetch(`http://localhost:${port}/api/status`, {
+                    signal: AbortSignal.timeout(3000)
+                });
+                
+                if (response.ok) {
+                    const data = await response.json();
+                    status.service = data.status;
+                }
+            } catch (e) {
+                // 服务可能未完全启动或未响应
+            }
+        }
+        
+        // JSON 输出
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        
+        // 人类可读输出
+        console.log('');
+        console.log(chalk.bold('DeepSeek Cowork Status'));
+        console.log(chalk.dim('─'.repeat(40)));
+        
+        if (status.running) {
+            console.log(chalk.green('● Service:      Running'));
+            console.log(chalk.white(`  PID:          ${status.pid}`));
+            console.log(chalk.white(`  HTTP:         http://localhost:${status.httpPort}`));
+            console.log(chalk.white(`  WebSocket:    ws://localhost:${status.wsPort}`));
+            
+            if (status.service) {
+                console.log('');
+                console.log(chalk.dim('Components:'));
+                
+                // HappyService 状态
+                if (status.service.happy) {
+                    const happy = status.service.happy;
+                    const connStatus = happy.clientConnected ? chalk.green('Connected') : chalk.yellow('Disconnected');
+                    console.log(`  Happy AI:     ${connStatus}`);
+                    
+                    if (happy.eventStatus) {
+                        console.log(`  Event Status: ${happy.eventStatus}`);
+                    }
+                }
+                
+                // Daemon 状态
+                if (status.service.happy?.daemon) {
+                    const daemon = status.service.happy.daemon;
+                    const daemonStatus = daemon.running ? chalk.green('Running') : chalk.red('Stopped');
+                    console.log(`  Daemon:       ${daemonStatus}`);
+                }
+                
+                // BrowserControl 状态
+                if (status.service.browserControl) {
+                    const bcStatus = status.service.browserControl === 'running' ? chalk.green('Running') : chalk.red('Stopped');
+                    console.log(`  Browser:      ${bcStatus}`);
+                }
+                
+                // Explorer 状态
+                if (status.service.explorer) {
+                    const expStatus = status.service.explorer === 'running' ? chalk.green('Running') : chalk.red('Stopped');
+                    console.log(`  Explorer:     ${expStatus}`);
+                }
+            }
+        } else {
+            console.log(chalk.red('○ Service:      Not running'));
+            
+            if (pid) {
+                console.log(chalk.dim(`  (Stale PID file found: ${pid})`));
+            }
+        }
+        
+        console.log('');
+        console.log(chalk.dim('Data Directory:'));
+        console.log(`  ${status.dataDir}`);
+        console.log('');
+        
+        // 提示命令
+        if (!status.running) {
+            console.log(chalk.cyan('Start service:'), chalk.white('deepseek-cowork start'));
+        } else {
+            console.log(chalk.cyan('Stop service: '), chalk.white('deepseek-cowork stop'));
+            console.log(chalk.cyan('Open web UI:  '), chalk.white('deepseek-cowork open'));
+        }
+        console.log('');
+        
+    } catch (error) {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+}
+
+export default statusCommand;

package/commands/stop.mjs

@@ -0,0 +1,90 @@
+/**
+ * stop 命令 - 停止本地服务
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { getConfig } from '../index.mjs';
+import { readPidFile, removePidFile, isProcessRunning, killProcess, waitForProcessExit } from '../utils/process.mjs';
+
+/**
+ * 停止服务命令
+ */
+export async function stopCommand(options) {
+    const spinner = ora('Stopping DeepSeek Cowork...').start();
+    
+    try {
+        const config = await getConfig();
+        const pidPath = config.getPidFilePath();
+        const pid = readPidFile(pidPath);
+        
+        if (!pid) {
+            spinner.info('No running service found');
+            removePidFile(pidPath);
+            return;
+        }
+        
+        if (!isProcessRunning(pid)) {
+            spinner.info('Service is not running (stale PID file removed)');
+            removePidFile(pidPath);
+            return;
+        }
+        
+        // 首先尝试通过 API 优雅关闭
+        try {
+            spinner.text = 'Requesting graceful shutdown...';
+            
+            // 获取端口配置
+            const port = config.DEFAULT_HTTP_PORT;
+            
+            const response = await fetch(`http://localhost:${port}/api/status`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(3000)
+            });
+            
+            if (response.ok) {
+                // 服务正在运行，尝试优雅关闭
+                // 注意：实际的停止 API 需要在服务端实现
+                // 这里先直接发送 SIGTERM
+            }
+        } catch (e) {
+            // 服务可能已经不响应，直接终止进程
+        }
+        
+        // 发送 SIGTERM 信号
+        spinner.text = 'Sending stop signal...';
+        killProcess(pid, 'SIGTERM');
+        
+        // 等待进程退出
+        spinner.text = 'Waiting for service to stop...';
+        const stopped = await waitForProcessExit(pid, 10000);
+        
+        if (stopped) {
+            removePidFile(pidPath);
+            spinner.succeed('DeepSeek Cowork stopped');
+        } else {
+            // 强制终止
+            spinner.text = 'Force stopping...';
+            killProcess(pid, 'SIGKILL');
+            
+            const forceStopped = await waitForProcessExit(pid, 3000);
+            
+            if (forceStopped) {
+                removePidFile(pidPath);
+                spinner.succeed('DeepSeek Cowork force stopped');
+            } else {
+                spinner.fail('Failed to stop service');
+                console.log(chalk.yellow(`\nProcess ${pid} may still be running`));
+                console.log(chalk.yellow('You may need to kill it manually'));
+            }
+        }
+        
+    } catch (error) {
+        spinner.fail(`Failed to stop: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+export default stopCommand;

package/index.mjs

@@ -0,0 +1,66 @@
+/**
+ * DeepSeek Cowork CLI 模块入口
+ * 
+ * 用于程序化调用 CLI 功能
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// 获取项目根目录
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// 项目根目录（packages/cli 的父目录的父目录）
+export const PROJECT_ROOT = join(__dirname, '../..');
+
+// 导出服务模块路径
+export const LOCAL_SERVICE_PATH = join(PROJECT_ROOT, 'lib/local-service');
+
+/**
+ * 动态导入 local-service 模块
+ * 由于 local-service 是 CommonJS 模块，需要动态导入
+ */
+export async function getLocalService() {
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    return require(LOCAL_SERVICE_PATH);
+}
+
+/**
+ * 获取配置模块
+ */
+export async function getConfig() {
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    return require(join(LOCAL_SERVICE_PATH, 'config'));
+}
+
+/**
+ * 获取用户设置模块
+ */
+export async function getUserSettings() {
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    return require(join(LOCAL_SERVICE_PATH, 'user-settings-cli'));
+}
+
+/**
+ * 获取安全设置模块
+ */
+export async function getSecureSettings() {
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    return require(join(LOCAL_SERVICE_PATH, 'secure-settings-cli'));
+}
+
+export default {
+    PROJECT_ROOT,
+    LOCAL_SERVICE_PATH,
+    getLocalService,
+    getConfig,
+    getUserSettings,
+    getSecureSettings
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "deepseek-cowork",
+  "version": "0.1.0",
+  "description": "Open-Source Alternative to Claude Cowork - CLI Tool",
+  "author": "imjszhang",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "deepseek-cowork": "bin/cli.mjs",
+    "dsc": "bin/cli.mjs"
+  },
+  "main": "./index.mjs",
+  "files": [
+    "bin",
+    "commands",
+    "index.mjs",
+    "utils"
+  ],
+  "keywords": [
+    "deepseek",
+    "claude-cowork",
+    "open-source",
+    "ai-assistant",
+    "browser-automation",
+    "file-management",
+    "llm",
+    "claude-code",
+    "cli"
+  ],
+  "scripts": {
+    "start": "node bin/cli.mjs start",
+    "dev": "node bin/cli.mjs start --debug",
+    "link": "npm link",
+    "prepublishOnly": "echo 准备发布...",
+    "version:patch": "npm version patch",
+    "version:minor": "npm version minor",
+    "version:major": "npm version major"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "open": "^10.1.0",
+    "ora": "^8.0.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/imjszhang/deepseek-cowork.git"
+  },
+  "homepage": "https://deepseek-cowork.com",
+  "bugs": {
+    "url": "https://github.com/imjszhang/deepseek-cowork/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}

package/utils/process.mjs

@@ -0,0 +1,148 @@
+/**
+ * 进程管理工具
+ * 
+ * 创建时间: 2026-01-20
+ */
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { dirname } from 'path';
+import { mkdirSync } from 'fs';
+import net from 'net';
+
+/**
+ * 检查端口是否可用
+ * @param {number} port 端口号
+ * @returns {Promise<boolean>} 是否可用
+ */
+export async function checkPort(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+            } else {
+                resolve(true);
+            }
+        });
+        
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        
+        server.listen(port, 'localhost');
+    });
+}
+
+/**
+ * 写入 PID 文件
+ * @param {string} pidPath PID 文件路径
+ * @param {number} pid 进程 ID
+ */
+export function writePidFile(pidPath, pid) {
+    try {
+        const dir = dirname(pidPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(pidPath, pid.toString(), 'utf8');
+    } catch (error) {
+        console.error('Failed to write PID file:', error.message);
+    }
+}
+
+/**
+ * 读取 PID 文件
+ * @param {string} pidPath PID 文件路径
+ * @returns {number|null} 进程 ID 或 null
+ */
+export function readPidFile(pidPath) {
+    try {
+        if (existsSync(pidPath)) {
+            const content = readFileSync(pidPath, 'utf8').trim();
+            const pid = parseInt(content);
+            return isNaN(pid) ? null : pid;
+        }
+    } catch (error) {
+        // 忽略读取错误
+    }
+    return null;
+}
+
+/**
+ * 删除 PID 文件
+ * @param {string} pidPath PID 文件路径
+ */
+export function removePidFile(pidPath) {
+    try {
+        if (existsSync(pidPath)) {
+            unlinkSync(pidPath);
+        }
+    } catch (error) {
+        // 忽略删除错误
+    }
+}
+
+/**
+ * 检查进程是否运行
+ * @param {number} pid 进程 ID
+ * @returns {boolean} 是否运行
+ */
+export function isProcessRunning(pid) {
+    if (!pid) return false;
+    
+    try {
+        // 发送信号 0 检查进程是否存在
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 终止进程
+ * @param {number} pid 进程 ID
+ * @param {string} signal 信号（默认 SIGTERM）
+ * @returns {boolean} 是否成功
+ */
+export function killProcess(pid, signal = 'SIGTERM') {
+    if (!pid) return false;
+    
+    try {
+        process.kill(pid, signal);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 等待进程退出
+ * @param {number} pid 进程 ID
+ * @param {number} timeout 超时时间（毫秒）
+ * @returns {Promise<boolean>} 是否退出
+ */
+export async function waitForProcessExit(pid, timeout = 5000) {
+    const startTime = Date.now();
+    
+    while (Date.now() - startTime < timeout) {
+        if (!isProcessRunning(pid)) {
+            return true;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    
+    return !isProcessRunning(pid);
+}
+
+export default {
+    checkPort,
+    writePidFile,
+    readPidFile,
+    removePidFile,
+    isProcessRunning,
+    killProcess,
+    waitForProcessExit
+};