agent-window 1.0.0 → 1.0.2

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

@@ -0,0 +1,279 @@
+/**
+ * Config Manager
+ *
+ * Manages configuration files for AgentWindow instances.
+ * Handles reading, writing, validation, and external modification detection.
+ * Uses platform abstraction layer for cross-platform compatibility.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { existsSync } from 'fs';
+import crypto from 'crypto';
+import { paths } from '../platform/index.js';
+
+/** @private */
+const BACKUP_DIR = path.join(paths.getAgentWindowHome(), 'backups', 'configs');
+
+/**
+ * Ensure backup directory exists
+ * @private
+ */
+async function ensureBackupDir() {
+  if (!existsSync(BACKUP_DIR)) {
+    await fs.mkdir(BACKUP_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Calculate file checksum for change detection
+ * @param {string} content - File content
+ * @returns {string} SHA256 hash
+ */
+function calculateChecksum(content) {
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+/**
+ * Read config file
+ * @param {string} configPath - Path to config file
+ * @returns {Promise<Object>} Config object
+ */
+export async function readConfig(configPath) {
+  if (!existsSync(configPath)) {
+    throw new Error(`配置文件不存在: ${configPath}`);
+  }
+
+  const content = await fs.readFile(configPath, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Write config file with backup
+ * @param {string} configPath - Path to config file
+ * @param {Object} config - Config object to write
+ * @param {Object} options - Options
+ * @param {boolean} options.backup - Create backup before writing
+ * @returns {Promise<Object>} Result with checksum
+ */
+export async function writeConfig(configPath, config, options = {}) {
+  const content = JSON.stringify(config, null, 2);
+  const checksum = calculateChecksum(content);
+
+  // Create backup if requested and file exists
+  if (options.backup !== false && existsSync(configPath)) {
+    await backupConfig(configPath);
+  }
+
+  // Write config atomically
+  const tmpPath = `${configPath}.tmp`;
+  await fs.writeFile(tmpPath, content, 'utf-8');
+  await fs.rename(tmpPath, configPath);
+
+  return { checksum };
+}
+
+/**
+ * Backup config file
+ * @param {string} configPath - Path to config file
+ * @returns {Promise<string>} Backup file path
+ */
+export async function backupConfig(configPath) {
+  await ensureBackupDir();
+
+  if (!existsSync(configPath)) {
+    throw new Error(`无法备份不存在的文件: ${configPath}`);
+  }
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const basename = path.basename(configPath, '.json');
+  const backupPath = path.join(BACKUP_DIR, `${basename}-${timestamp}.json`);
+
+  await fs.copyFile(configPath, backupPath);
+  return backupPath;
+}
+
+/**
+ * List available backups for a config
+ * @param {string} instanceName - Instance name
+ * @returns {Promise<Array>} List of backup files with metadata
+ */
+export async function listBackups(instanceName) {
+  await ensureBackupDir();
+
+  if (!existsSync(BACKUP_DIR)) {
+    return [];
+  }
+
+  const files = await fs.readdir(BACKUP_DIR);
+  const pattern = new RegExp(`^${instanceName}-config-(\\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({
+        instance: instanceName,
+        file,
+        path: filePath,
+        createdAt: new Date(stats.mtime),
+        size: stats.size
+      });
+    }
+  }
+
+  return backups.sort((a, b) => b.createdAt - a.createdAt);
+}
+
+/**
+ * Restore config from backup
+ * @param {string} backupPath - Path to backup file
+ * @param {string} targetPath - Target config path
+ * @returns {Promise<void>}
+ */
+export async function restoreBackup(backupPath, targetPath) {
+  if (!existsSync(backupPath)) {
+    throw new Error(`备份文件不存在: ${backupPath}`);
+  }
+
+  // Create backup of current before restoring
+  if (existsSync(targetPath)) {
+    await backupConfig(targetPath);
+  }
+
+  await fs.copyFile(backupPath, targetPath);
+}
+
+/**
+ * Get a config value by key path
+ * @param {Object} config - Config object
+ * @param {string} keyPath - Dot-separated key path (e.g., 'workspace.containerName')
+ * @returns {*} Config value
+ */
+export function getConfigValue(config, keyPath) {
+  const keys = keyPath.split('.');
+  let value = config;
+
+  for (const key of keys) {
+    if (value && typeof value === 'object') {
+      value = value[key];
+    } else {
+      return undefined;
+    }
+  }
+
+  return value;
+}
+
+/**
+ * Set a config value by key path
+ * @param {Object} config - Config object
+ * @param {string} keyPath - Dot-separated key path
+ * @param {*} value - Value to set
+ * @returns {Object} Modified config
+ */
+export function setConfigValue(config, keyPath, value) {
+  const keys = keyPath.split('.');
+  const result = { ...config };
+  let current = result;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+
+  current[keys[keys.length - 1]] = value;
+  return result;
+}
+
+/**
+ * Detect if config was modified externally
+ * @param {string} configPath - Path to config file
+ * @param {string} storedChecksum - Previously stored checksum
+ * @returns {Promise<boolean>} True if modified
+ */
+export async function detectExternalModification(configPath, storedChecksum) {
+  if (!existsSync(configPath)) {
+    return false;
+  }
+
+  const content = await fs.readFile(configPath, 'utf-8');
+  const currentChecksum = calculateChecksum(content);
+
+  return currentChecksum !== storedChecksum;
+}
+
+/**
+ * Config metadata tracker (stores checksums for external change detection)
+ * @private */
+const METADATA_FILE = path.join(paths.getAgentWindowHome(), 'config-metadata.json');
+
+/**
+ * Read config metadata
+ * @private
+ * @returns {Promise<Object>}
+ */
+async function readMetadata() {
+  if (!existsSync(METADATA_FILE)) {
+    return {};
+  }
+  const content = await fs.readFile(METADATA_FILE, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Write config metadata
+ * @private
+ * @param {Object} metadata
+ * @returns {Promise<void>}
+ */
+async function writeMetadata(metadata) {
+  const dir = path.dirname(METADATA_FILE);
+  if (!existsSync(dir)) {
+    await fs.mkdir(dir, { recursive: true });
+  }
+  await fs.writeFile(METADATA_FILE, JSON.stringify(metadata, null, 2));
+}
+
+/**
+ * Update config metadata after write
+ * @param {string} instanceName - Instance name
+ * @param {string} checksum - Config checksum
+ * @returns {Promise<void>}
+ */
+export async function updateConfigMetadata(instanceName, checksum) {
+  const metadata = await readMetadata();
+  metadata[instanceName] = {
+    checksum,
+    updatedAt: new Date().toISOString()
+  };
+  await writeMetadata(metadata);
+}
+
+/**
+ * Check for external config modifications
+ * @param {string} instanceName - Instance name
+ * @param {string} configPath - Path to config file
+ * @returns {Promise<Object>} Result with modified flag
+ */
+export async function checkExternalModification(instanceName, configPath) {
+  const metadata = await readMetadata();
+  const stored = metadata[instanceName];
+
+  if (!stored) {
+    return { modified: false, reason: 'no_metadata' };
+  }
+
+  const modified = await detectExternalModification(configPath, stored.checksum);
+
+  return {
+    modified,
+    checksum: stored.checksum,
+    updatedAt: stored.updatedAt
+  };
+}

package/src/core/instance/index.js

@@ -0,0 +1,62 @@
+/**
+ * Instance Management Module
+ *
+ * Unified exports for instance management functionality.
+ */
+
+// Validator
+export {
+  validateInstance,
+  formatValidationResult
+} from './validator.js';
+
+// Manager
+export {
+  getInstancesFilePath,
+  readInstances,
+  writeInstances,
+  addInstance,
+  removeInstance,
+  getInstance,
+  listInstances,
+  updateInstance
+} from './manager.js';
+
+// Config Manager
+export {
+  readConfig,
+  writeConfig,
+  backupConfig as backupConfigFile,
+  restoreBackup as restoreConfigBackup,
+  listBackups as listConfigBackups,
+  getConfigValue,
+  setConfigValue,
+  detectExternalModification,
+  checkExternalModification,
+  updateConfigMetadata
+} from './config-manager.js';
+
+// PM2 Bridge
+export {
+  getProcesses,
+  getProcess,
+  getProcessesByPattern,
+  startProcess,
+  stopProcess,
+  restartProcess,
+  deleteProcess,
+  getLogs,
+  getStatus,
+  formatStatus
+} from './pm2-bridge.js';
+
+// Backup Manager
+export {
+  getBackupDir,
+  ensureBackupDir,
+  createBackup,
+  listBackups,
+  restoreBackup,
+  pruneBackups,
+  getLatestBackup
+} from './backup-manager.js';

package/src/core/instance/manager.js

@@ -0,0 +1,220 @@
+/**
+ * Instance Manager
+ *
+ * Manages AgentWindow BMAD plugin instances - add, list, remove, get info.
+ * Uses platform abstraction layer for cross-platform compatibility.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { existsSync } from 'fs';
+import { validateInstance } from './validator.js';
+import { paths } from '../platform/index.js';
+
+/** @private */
+const INSTANCES_DIR = paths.getAgentWindowHome();
+/** @private */
+const INSTANCES_FILE = path.join(INSTANCES_DIR, 'instances.json');
+
+/**
+ * Get instances file path
+ * @returns {string}
+ */
+export function getInstancesFilePath() {
+  return INSTANCES_FILE;
+}
+
+/**
+ * Ensure instances directory and file exist
+ * @private
+ */
+async function ensureInstancesFile() {
+  if (!existsSync(INSTANCES_DIR)) {
+    await fs.mkdir(INSTANCES_DIR, { recursive: true });
+  }
+  if (!existsSync(INSTANCES_FILE)) {
+    await fs.writeFile(INSTANCES_FILE, JSON.stringify({
+      version: '1.0',
+      instances: []
+    }, null, 2));
+  }
+}
+
+/**
+ * Read instances from file
+ * @returns {Promise<Object>} Instances data
+ */
+export async function readInstances() {
+  await ensureInstancesFile();
+  const content = await fs.readFile(INSTANCES_FILE, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Write instances to file
+ * @param {Object} data - Instances data
+ * @returns {Promise<void>}
+ */
+export async function writeInstances(data) {
+  await ensureInstancesFile();
+  await fs.writeFile(INSTANCES_FILE, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Add a new instance
+ * @param {string} name - Instance name (identifier)
+ * @param {string} projectPath - Path to BMAD project
+ * @param {Object} options - Additional options
+ * @param {string} options.displayName - Display name
+ * @param {string[]} options.tags - Tags for categorization
+ * @param {string} options.configPath - Path to config file (optional)
+ * @returns {Promise<Object>} Result with success and message
+ */
+export async function addInstance(name, projectPath, options = {}) {
+  // Validate input
+  if (!name || !name.match(/^[a-z0-9-]+$/)) {
+    return {
+      success: false,
+      error: '实例名称只能包含小写字母、数字和连字符'
+    };
+  }
+
+  // Check if instance already exists
+  const data = await readInstances();
+  if (data.instances.find(i => i.name === name)) {
+    return {
+      success: false,
+      error: `实例 "${name}" 已存在`
+    };
+  }
+
+  // Validate the instance
+  const validation = await validateInstance(projectPath);
+  if (!validation.valid) {
+    return {
+      success: false,
+      error: '验证失败：项目不是有效的 AgentWindow BMAD 插件',
+      validation
+    };
+  }
+
+  // Determine config path
+  const botsDir = paths.getBotsDir();
+  const defaultConfigPath = path.join(botsDir, name, 'config.json');
+  const configPath = options.configPath ||
+    (existsSync(defaultConfigPath) ? defaultConfigPath : null);
+
+  // Add instance
+  const newInstance = {
+    name,
+    displayName: options.displayName || name,
+    projectPath: validation.projectPath,
+    pluginPath: validation.pluginPath,
+    configPath,
+    botName: `bot-${name}`,
+    addedAt: new Date().toISOString(),
+    tags: options.tags || [],
+    enabled: true
+  };
+
+  data.instances.push(newInstance);
+  await writeInstances(data);
+
+  return {
+    success: true,
+    instance: newInstance
+  };
+}
+
+/**
+ * Remove an instance
+ * @param {string} name - Instance name
+ * @returns {Promise<Object>} Result with success and message
+ */
+export async function removeInstance(name) {
+  const data = await readInstances();
+  const index = data.instances.findIndex(i => i.name === name);
+
+  if (index === -1) {
+    return {
+      success: false,
+      error: `实例 "${name}" 不存在`
+    };
+  }
+
+  const removed = data.instances.splice(index, 1)[0];
+  await writeInstances(data);
+
+  return {
+    success: true,
+    instance: removed
+  };
+}
+
+/**
+ * Get an instance by name
+ * @param {string} name - Instance name
+ * @returns {Promise<Object|null>} Instance or null
+ */
+export async function getInstance(name) {
+  const data = await readInstances();
+  return data.instances.find(i => i.name === name) || null;
+}
+
+/**
+ * List all instances
+ * @param {Object} options - Filter options
+ * @param {boolean} options.enabledOnly - Only show enabled instances
+ * @param {string} options.tag - Filter by tag
+ * @returns {Promise<Array>} List of instances
+ */
+export async function listInstances(options = {}) {
+  const data = await readInstances();
+  let instances = data.instances;
+
+  if (options.enabledOnly) {
+    instances = instances.filter(i => i.enabled);
+  }
+
+  if (options.tag) {
+    instances = instances.filter(i => i.tags?.includes(options.tag));
+  }
+
+  return instances;
+}
+
+/**
+ * Update an instance
+ * @param {string} name - Instance name
+ * @param {Object} updates - Fields to update
+ * @returns {Promise<Object>} Result with success and message
+ */
+export async function updateInstance(name, updates) {
+  const data = await readInstances();
+  const index = data.instances.findIndex(i => i.name === name);
+
+  if (index === -1) {
+    return {
+      success: false,
+      error: `实例 "${name}" 不存在`
+    };
+  }
+
+  // Allowed fields to update
+  const allowedFields = ['displayName', 'tags', 'enabled', 'configPath'];
+  const instance = data.instances[index];
+
+  for (const [key, value] of Object.entries(updates)) {
+    if (allowedFields.includes(key)) {
+      instance[key] = value;
+    }
+  }
+
+  instance.updatedAt = new Date().toISOString();
+  await writeInstances(data);
+
+  return {
+    success: true,
+    instance
+  };
+}