agent-window 1.0.1 → 1.0.2

package/src/cli/commands/restart.js

@@ -0,0 +1,67 @@
+/**
+ * restart command - Restart an instance
+ *
+ * Usage: agent-window restart <name>
+ */
+
+import { getInstance } from '../../core/instance/manager.js';
+import { restartProcess, getStatus } from '../../core/instance/pm2-bridge.js';
+
+/**
+ * Execute restart command
+ * @param {string} name - Instance name
+ * @returns {Promise<number>} Exit code
+ */
+export async function execute(name) {
+  if (!name) {
+    console.error('错误: 请提供实例名称');
+    console.error('用法: agent-window restart <name>');
+    return 1;
+  }
+
+  const instance = await getInstance(name);
+  if (!instance) {
+    console.error(`错误: 实例 "${name}" 不存在`);
+    return 1;
+  }
+
+  // Check if running
+  let wasRunning = false;
+  try {
+    const status = await getStatus(instance.botName);
+    wasRunning = status.exists && status.status === 'online';
+  } catch {
+    // Ignore
+  }
+
+  if (!wasRunning) {
+    console.log(`实例 "${name}" 未运行，正在启动...`);
+    const { execute: startCmd } = await import('./start.js');
+    return startCmd.execute(name);
+  }
+
+  console.log(`重启实例 "${name}"...`);
+
+  const result = await restartProcess(instance.botName);
+
+  if (!result.success) {
+    console.error(`\n错误: ${result.error}`);
+    return 1;
+  }
+
+  console.log(`✓ 实例 "${name}" 已重启`);
+
+  // Check status after restart
+  await new Promise(r => setTimeout(r, 1000));
+  try {
+    const status = await getStatus(instance.botName);
+    if (status.exists) {
+      console.log(`  状态: ${status.status}`);
+      console.log(`  PID: ${status.pid || 'N/A'}`);
+    }
+  } catch {
+    // Ignore
+  }
+
+  return 0;
+}

package/src/cli/commands/start.js

@@ -0,0 +1,101 @@
+/**
+ * start command - Start an instance
+ *
+ * Usage: agent-window start <name>
+ */
+
+import { getInstance } from '../../core/instance/manager.js';
+import { startProcess, getStatus } from '../../core/instance/pm2-bridge.js';
+import { existsSync } from 'fs';
+
+/**
+ * Execute start command
+ * @param {string} name - Instance name
+ * @param {Object} options - Options
+ * @returns {Promise<number>} Exit code
+ */
+export async function execute(name, options = {}) {
+  if (!name) {
+    console.error('错误: 请提供实例名称');
+    console.error('用法: agent-window start <name>');
+    return 1;
+  }
+
+  const instance = await getInstance(name);
+  if (!instance) {
+    console.error(`错误: 实例 "${name}" 不存在`);
+    return 1;
+  }
+
+  if (!instance.enabled) {
+    console.error(`错误: 实例 "${name}" 已禁用`);
+    return 1;
+  }
+
+  // Check if already running
+  try {
+    const status = await getStatus(instance.botName);
+    if (status.exists && status.status === 'online') {
+      console.log(`实例 "${name}" 已经在运行`);
+      if (!options.force) {
+        return 0;
+      }
+    }
+  } catch {
+    // Ignore PM2 check errors
+  }
+
+  // Find bot script
+  const botScript = options.script ||
+    (instance.pluginPath ? `${instance.pluginPath}/src/bot.js` : null);
+
+  if (!botScript || !existsSync(botScript)) {
+    console.error(`错误: 找不到 bot 脚本: ${botScript}`);
+    return 1;
+  }
+
+  // Find config file
+  const configPath = instance.configPath;
+  if (!configPath || !existsSync(configPath)) {
+    console.error(`错误: 找不到配置文件: ${configPath}`);
+    return 1;
+  }
+
+  console.log(`启动实例 "${name}"...`);
+  console.log(`  脚本: ${botScript}`);
+  console.log(`  配置: ${configPath}`);
+
+  // Start process
+  const result = await startProcess(botScript, instance.botName, {
+    cwd: instance.pluginPath,
+    env: {
+      CONFIG_PATH: configPath,
+      NODE_ENV: options.production ? 'production' : 'development'
+    }
+  });
+
+  if (!result.success) {
+    console.error(`\n错误: ${result.error}`);
+    return 1;
+  }
+
+  console.log(`\n✓ 实例 "${name}" 已启动`);
+  console.log(`  进程名: ${instance.botName}`);
+
+  // Wait a moment and check status
+  await new Promise(r => setTimeout(r, 1000));
+  try {
+    const status = await getStatus(instance.botName);
+    if (status.exists) {
+      console.log(`  状态: ${status.status}`);
+      console.log(`  PID: ${status.pid || 'N/A'}`);
+    }
+  } catch {
+    // Ignore
+  }
+
+  console.log(`\n使用以下命令查看日志:`);
+  console.log(`  agent-window logs ${name}`);
+
+  return 0;
+}

package/src/cli/commands/status.js

@@ -0,0 +1,95 @@
+/**
+ * status command - Show status of all instances
+ *
+ * Usage: agent-window status
+ */
+
+import { listInstances } from '../../core/instance/manager.js';
+import { getStatus, formatStatus } from '../../core/instance/pm2-bridge.js';
+import Table from 'cli-table3';
+
+/**
+ * Execute status command
+ * @returns {Promise<number>} Exit code
+ */
+export async function execute() {
+  const instances = await listInstances();
+
+  if (instances.length === 0) {
+    console.log('没有配置实例');
+    console.log('\n使用 agent-window add <name> <path> 添加新实例');
+    return 0;
+  }
+
+  console.log(`\nAgentWindow 实例状态 (${instances.length} 个)\n`);
+
+  // Get status for each instance
+  const results = await Promise.all(
+    instances.map(async (inst) => {
+      try {
+        const status = await getStatus(inst.botName);
+        return { ...inst, status };
+      } catch {
+        return { ...inst, status: null };
+      }
+    })
+  );
+
+  // Count by status
+  let online = 0;
+  let stopped = 0;
+  let error = 0;
+
+  for (const r of results) {
+    if (!r.status || !r.status.exists) {
+      stopped++;
+    } else if (r.status.status === 'online') {
+      online++;
+    } else if (r.status.status === 'errored') {
+      error++;
+    } else {
+      stopped++;
+    }
+  }
+
+  // Display table
+  const table = new Table({
+    head: ['实例', '状态', 'PID', '内存', '重启', '项目'],
+    colWidths: [18, 12, 8, 10, 8, 25],
+    style: {
+      head: ['cyan', 'bold']
+    }
+  });
+
+  for (const r of results) {
+    const s = r.status;
+    if (s && s.exists) {
+      const statusIcon = { online: '✓', stopped: '○', errored: '✗' }[s.status] || '?';
+      const memMB = s.memory ? Math.round(s.memory / 1024 / 1024) : '-';
+      table.push([
+        r.name,
+        statusIcon + ' ' + s.status,
+        s.pid || '-',
+        memMB + 'MB',
+        s.restarts || 0,
+        r.displayName || r.name
+      ]);
+    } else {
+      table.push([
+        r.name,
+        '○ 未配置',
+        '-',
+        '-',
+        '-',
+        r.displayName || r.name
+      ]);
+    }
+  }
+
+  console.log(table.toString());
+
+  // Summary
+  console.log(`\n总结: ${online} 运行中, ${stopped} 已停止, ${error} 错误`);
+
+  return 0;
+}

package/src/cli/commands/stop.js

@@ -0,0 +1,53 @@
+/**
+ * stop command - Stop an instance
+ *
+ * Usage: agent-window stop <name>
+ */
+
+import { getInstance } from '../../core/instance/manager.js';
+import { stopProcess, getStatus } from '../../core/instance/pm2-bridge.js';
+
+/**
+ * Execute stop command
+ * @param {string} name - Instance name
+ * @returns {Promise<number>} Exit code
+ */
+export async function execute(name) {
+  if (!name) {
+    console.error('错误: 请提供实例名称');
+    console.error('用法: agent-window stop <name>');
+    return 1;
+  }
+
+  const instance = await getInstance(name);
+  if (!instance) {
+    console.error(`错误: 实例 "${name}" 不存在`);
+    return 1;
+  }
+
+  // Check if running
+  try {
+    const status = await getStatus(instance.botName);
+    if (!status.exists || status.status === 'stopped') {
+      console.log(`实例 "${name}" 未运行`);
+      return 0;
+    }
+  } catch {
+    // Assume not running
+    console.log(`实例 "${name}" 未运行`);
+    return 0;
+  }
+
+  console.log(`停止实例 "${name}"...`);
+
+  const result = await stopProcess(instance.botName);
+
+  if (!result.success) {
+    console.error(`\n错误: ${result.error}`);
+    return 1;
+  }
+
+  console.log(`✓ 实例 "${name}" 已停止`);
+
+  return 0;
+}

package/src/cli/commands/ui.js

@@ -0,0 +1,51 @@
+/**
+ * UI Command
+ *
+ * Launch the AgentWindow Web UI.
+ * Starts the API server and serves the frontend.
+ */
+
+export const help = `
+Launch the AgentWindow Web UI
+
+Usage:
+  agent-window ui [options]
+
+Options:
+  --port, -p <port>  Port to listen on (default: 3721)
+  --no-open          Don't open browser automatically
+  --dev              Run in development mode
+
+The UI provides a web-based interface for managing your bot instances:
+  - View instance status at a glance
+  - Start/stop/restart instances
+  - View real-time logs
+  - Manage configurations
+`;
+
+export async function execute(args = []) {
+  // Parse arguments
+  const portIndex = args.indexOf('--port') ?? args.indexOf('-p');
+  const port = portIndex >= 0 && args[portIndex + 1]
+    ? parseInt(args[portIndex + 1], 10)
+    : 3721;
+
+  const noOpen = args.includes('--no-open');
+  const dev = args.includes('--dev');
+
+  console.log(`\n🪟 AgentWindow Web UI\n`);
+
+  // Import and start server
+  const { startServer } = await import('../../api/server.js');
+
+  try {
+    await startServer({
+      port,
+      logger: true,
+      open: !noOpen
+    });
+  } catch (error) {
+    console.error(`Failed to start server: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/cli/index.js

@@ -0,0 +1,110 @@
+/**
+ * AgentWindow CLI
+ *
+ * Main entry point for instance management commands
+ */
+
+import { commands } from './commands/index.js';
+
+/**
+ * Show help message
+ */
+function showHelp() {
+  console.log('\nAgentWindow - BMAD 实例管理\n');
+  console.log('用法: agent-window <command> [options]\n');
+  console.log('命令:\n');
+
+  for (const [name, info] of Object.entries(commands)) {
+    console.log(`  ${name.padEnd(12)} ${info.description}`);
+  }
+
+  console.log('\n使用 "agent-window <command> --help" 查看详细帮助\n');
+}
+
+/**
+ * Parse command line arguments
+ * @param {string[]} args - Command line arguments
+ * @returns {Object} Parsed command and options
+ */
+function parseArgs(args) {
+  const command = args[0];
+  const commandArgs = args.slice(1);
+  const options = {};
+
+  const remaining = [];
+  for (let i = 0; i < commandArgs.length; i++) {
+    const arg = commandArgs[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      if (key.includes('=')) {
+        const [k, v] = key.split('=');
+        options[k] = v;
+      } else if (i + 1 < commandArgs.length && !commandArgs[i + 1].startsWith('-')) {
+        options[k] = commandArgs[++i];
+      } else {
+        options[k] = true;
+      }
+    } else if (arg.startsWith('-')) {
+      const key = arg.slice(1);
+      if (key.length === 1) {
+        options[key] = true;
+      } else {
+        // Handle short flags like -f, -n
+        for (const char of key) {
+          options[char] = true;
+        }
+      }
+    } else {
+      remaining.push(arg);
+    }
+  }
+
+  return { command, args: remaining, options };
+}
+
+/**
+ * Main CLI entry point
+ * @param {string[]} args - Process arguments (excluding node and script)
+ * @returns {Promise<number>} Exit code
+ */
+export async function main(args) {
+  if (args.length === 0 || args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
+    showHelp();
+    return 0;
+  }
+
+  const { command, args: commandArgs, options } = parseArgs(args);
+
+  // Check if command exists
+  const commandInfo = commands[command];
+  if (!commandInfo) {
+    console.error(`错误: 未知命令 "${command}"`);
+    console.error('\n使用 "agent-window help" 查看可用命令');
+    return 1;
+  }
+
+  // Import and execute command
+  try {
+    const cmdModule = await import(`./commands/${command}.js`);
+    return cmdModule.execute(commandArgs, options);
+  } catch (err) {
+    console.error(`错误执行命令 "${command}": ${err.message}`);
+    if (options.debug) {
+      console.error(err.stack);
+    }
+    return 1;
+  }
+}
+
+/**
+ * Run CLI when executed directly
+ */
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  main(args).then(exitCode => {
+    process.exit(exitCode);
+  }).catch(err => {
+    console.error('未处理的错误:', err);
+    process.exit(1);
+  });
+}

package/src/core/config.js

@@ -3,27 +3,22 @@
  *
  * Centralizes all configuration loading and validation.
  * Supports both config file and environment variables.
+ * Uses platform abstraction layer for cross-platform compatibility.
  */
 
 import { readFileSync, existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
+import { paths } from './platform/index.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = join(__dirname, '../..');
 
 /**
- * Expand tilde (~) in paths to home directory
+ * Expand tilde (~) in paths to home directory (cross-platform)
  */
 function expandPath(path) {
-  if (!path) return path;
-  if (path.startsWith('~/')) {
-    return join(process.env.HOME, path.slice(2));
-  }
-  if (path === '~') {
-    return process.env.HOME;
-  }
-  return path;
+  return paths.expandTilde(path);
 }
 
 /**
@@ -79,7 +74,7 @@ function loadConfig() {
       type: fileConfig.backend?.type || 'claude-code',
       oauthToken: fileConfig.CLAUDE_CODE_OAUTH_TOKEN || process.env.CLAUDE_CODE_OAUTH_TOKEN || '',
       apiKey: fileConfig.backend?.apiKey || process.env.ANTHROPIC_API_KEY || '',
-      configDir: expandPath(fileConfig.backend?.configDir) || `${process.env.HOME}/.claude`,
+      configDir: expandPath(fileConfig.backend?.configDir) || paths.getClaudeConfigDir(),
     },
 
     // === Workspace Configuration ===

package/src/core/instance/backup-manager.js

@@ -0,0 +1,172 @@
+/**
+ * Backup Manager
+ *
+ * Manages configuration backups and rollback operations.
+ * Uses platform abstraction layer for cross-platform compatibility.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { existsSync } from 'fs';
+import { paths } from '../platform/index.js';
+
+/** @private */
+const BACKUP_DIR = path.join(paths.getAgentWindowHome(), 'backups', 'configs');
+
+/**
+ * Get backup directory path
+ * @returns {string}
+ */
+export function getBackupDir() {
+  return BACKUP_DIR;
+}
+
+/**
+ * Ensure backup directory exists
+ * @returns {Promise<void>}
+ */
+export async function ensureBackupDir() {
+  if (!existsSync(BACKUP_DIR)) {
+    await fs.mkdir(BACKUP_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Create a backup
+ * @param {string} sourcePath - Source file path
+ * @param {string} instanceName - Instance name (for naming)
+ * @returns {Promise<string>} Backup file path
+ */
+export async function createBackup(sourcePath, instanceName) {
+  await ensureBackupDir();
+
+  if (!existsSync(sourcePath)) {
+    throw new Error(`源文件不存在: ${sourcePath}`);
+  }
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupFileName = `${instanceName}-${timestamp}.json`;
+  const backupPath = path.join(BACKUP_DIR, backupFileName);
+
+  await fs.copyFile(sourcePath, backupPath);
+
+  // Create symlink to latest
+  const latestPath = path.join(BACKUP_DIR, `${instanceName}-latest.json`);
+  try {
+    if (existsSync(latestPath)) {
+      await fs.unlink(latestPath);
+    }
+    await fs.symlink(backupFileName, latestPath);
+  } catch {
+    // Symlink creation might fail, ignore
+  }
+
+  return backupPath;
+}
+
+/**
+ * List all backups for an instance
+ * @param {string} instanceName - Instance name
+ * @returns {Promise<Array>} List of backup info
+ */
+export async function listBackups(instanceName) {
+  await ensureBackupDir();
+
+  if (!existsSync(BACKUP_DIR)) {
+    return [];
+  }
+
+  const files = await fs.readdir(BACKUP_DIR);
+  const pattern = new RegExp(`^${instanceName}-(\\d{4}-\\d{2}-\\d{2}T.+?)\\.json$`);
+
+  const backups = [];
+  for (const file of files) {
+    const match = file.match(pattern);
+    if (match) {
+      const filePath = path.join(BACKUP_DIR, file);
+      const stats = await fs.stat(filePath);
+      backups.push({
+        name: instanceName,
+        filename: file,
+        path: filePath,
+        createdAt: new Date(stats.mtime),
+        size: stats.size,
+        isLatest: file.includes('latest')
+      });
+    }
+  }
+
+  return backups.sort((a, b) => b.createdAt - a.createdAt);
+}
+
+/**
+ * Restore from backup
+ * @param {string} backupPath - Backup file path
+ * @param {string} targetPath - Target file path
+ * @param {boolean} createBackupOfCurrent - Backup current before restore
+ * @returns {Promise<Object>} Result
+ */
+export async function restoreBackup(backupPath, targetPath, createBackupOfCurrent = true) {
+  if (!existsSync(backupPath)) {
+    return {
+      success: false,
+      error: `备份文件不存在: ${backupPath}`
+    };
+  }
+
+  // Backup current file if it exists
+  if (createBackupOfCurrent && existsSync(targetPath)) {
+    const targetName = path.basename(targetPath, '.json');
+    try {
+      await createBackup(targetPath, `${targetName}-pre-restore`);
+    } catch {
+      // Ignore backup failure
+    }
+  }
+
+  try {
+    await fs.copyFile(backupPath, targetPath);
+    return { success: true, restoredFrom: backupPath };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Delete old backups (keep only N latest)
+ * @param {string} instanceName - Instance name
+ * @param {number} keep - Number of backups to keep
+ * @returns {Promise<number>} Number of deleted backups
+ */
+export async function pruneBackups(instanceName, keep = 10) {
+  const backups = await listBackups(instanceName);
+  const toDelete = backups.slice(keep); // Keep first N, delete rest
+
+  let deleted = 0;
+  for (const backup of toDelete) {
+    if (!backup.isLatest) {
+      try {
+        await fs.unlink(backup.path);
+        deleted++;
+      } catch {
+        // Ignore deletion errors
+      }
+    }
+  }
+
+  return deleted;
+}
+
+/**
+ * Get latest backup for an instance
+ * @param {string} instanceName - Instance name
+ * @returns {Promise<string|null>} Backup path or null
+ */
+export async function getLatestBackup(instanceName) {
+  const backups = await listBackups(instanceName);
+  const latest = backups.find(b => b.isLatest);
+  return latest ? latest.path : (backups[0]?.path || null);
+}