agent-window 1.0.0

package/src/core/config.js

@@ -0,0 +1,195 @@
+/**
+ * Configuration Module
+ *
+ * Centralizes all configuration loading and validation.
+ * Supports both config file and environment variables.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = join(__dirname, '../..');
+
+/**
+ * Expand tilde (~) in paths to home directory
+ */
+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;
+}
+
+/**
+ * Parse color value (supports hex string "0x...", "#...", or number)
+ */
+function parseColor(value, defaultColor) {
+  if (value === undefined || value === null) return defaultColor;
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') {
+    // Handle "0x..." format
+    if (value.startsWith('0x') || value.startsWith('0X')) {
+      return parseInt(value, 16);
+    }
+    // Handle "#..." format
+    if (value.startsWith('#')) {
+      return parseInt(value.slice(1), 16);
+    }
+    // Try parsing as decimal
+    const num = parseInt(value, 10);
+    if (!isNaN(num)) return num;
+  }
+  return defaultColor;
+}
+
+/**
+ * Load and validate configuration
+ */
+function loadConfig() {
+  // Support CONFIG_PATH environment variable for multi-bot setups
+  const configPath = process.env.CONFIG_PATH || process.env.AGENT_BRIDGE_CONFIG || join(PROJECT_ROOT, 'config', 'config.json');
+  let fileConfig = {};
+
+  if (existsSync(configPath)) {
+    try {
+      fileConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+    } catch (e) {
+      console.error('[Config] Error parsing config.json:', e.message);
+    }
+  }
+
+  // Build configuration with defaults
+  const config = {
+    // === Discord Configuration ===
+    discord: {
+      token: fileConfig.BOT_TOKEN || process.env.DISCORD_BOT_TOKEN || '',
+      allowedChannels: fileConfig.ALLOWED_CHANNELS
+        ? fileConfig.ALLOWED_CHANNELS.split(',').map(id => id.trim())
+        : null,
+    },
+
+    // === Backend Configuration ===
+    backend: {
+      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`,
+    },
+
+    // === Workspace Configuration ===
+    workspace: {
+      projectDir: expandPath(fileConfig.PROJECT_DIR) || process.cwd(),
+      containerName: fileConfig.workspace?.containerName || 'claude-discord-bot',
+      dockerImage: fileConfig.workspace?.dockerImage || 'claude-sandbox',
+      portMappings: fileConfig.workspace?.portMappings || ['5173:5173'],
+    },
+
+    // === Paths (derived from PROJECT_ROOT) ===
+    paths: {
+      root: PROJECT_ROOT,
+      config: join(PROJECT_ROOT, 'config'),
+      hooks: join(PROJECT_ROOT, 'hooks'),
+      pending: join(PROJECT_ROOT, '.pending-permissions'),
+      sessions: join(PROJECT_ROOT, '.discord-channel-sessions.json'),
+    },
+
+    // === CLI Configuration ===
+    cli: {
+      command: fileConfig.cli?.command || 'claude',
+      maxTurns: fileConfig.cli?.maxTurns || 50,
+      outputFormat: 'stream-json',
+      verbose: true,
+      taskTimeout: fileConfig.cli?.taskTimeout || 3600000, // 1 hour default
+    },
+
+    // === Permission Configuration ===
+    permissions: {
+      hookEnabled: fileConfig.permissions?.hookEnabled !== false,
+      pollInterval: fileConfig.permissions?.pollInterval || 300,
+      timeout: fileConfig.permissions?.timeout || 120000,
+    },
+
+    // === Docker Configuration ===
+    docker: {
+      checkTimeout: fileConfig.docker?.checkTimeout || 5000, // 5 seconds default
+      // Container internal paths (usually don't need to change)
+      containerPaths: {
+        workspace: fileConfig.docker?.containerPaths?.workspace || '/workspace',
+        configDir: fileConfig.docker?.containerPaths?.configDir || '/home/claude/.claude',
+        hookDir: fileConfig.docker?.containerPaths?.hookDir || '/permission-hook',
+        pendingDir: fileConfig.docker?.containerPaths?.pendingDir || '/pending-permissions',
+        settingsFile: fileConfig.docker?.containerPaths?.settingsFile || '/permission-hook/settings.json',
+      },
+      // Environment variables passed to container
+      env: {
+        TERM: 'dumb',
+        CI: 'true',
+        NO_COLOR: '1',
+        FORCE_COLOR: '0',
+        HOOK_PENDING_DIR: fileConfig.docker?.containerPaths?.pendingDir || '/pending-permissions',
+      },
+    },
+
+    // === UI Configuration ===
+    ui: {
+      statusUpdateThrottle: fileConfig.ui?.statusUpdateThrottle || 500, // ms
+      theme: {
+        success: parseColor(fileConfig.ui?.theme?.success, 0x9ece6a),
+        error: parseColor(fileConfig.ui?.theme?.error, 0xf7768e),
+        info: parseColor(fileConfig.ui?.theme?.info, 0x7aa2f7),
+        warning: parseColor(fileConfig.ui?.theme?.warning, 0xf0ad4e),
+      },
+    },
+
+    // === Platform Configuration ===
+    platform: {
+      type: fileConfig.platform?.type || 'discord',
+      messageMaxLength: fileConfig.platform?.messageMaxLength || 1900,
+      retryDelay: fileConfig.platform?.retryDelay || 500,
+      previewLengths: {
+        command: fileConfig.platform?.previewLengths?.command || 500,
+        fileContent: fileConfig.platform?.previewLengths?.fileContent || 300,
+        editPreview: fileConfig.platform?.previewLengths?.editPreview || 150,
+        jsonInput: fileConfig.platform?.previewLengths?.jsonInput || 400,
+        response: fileConfig.platform?.previewLengths?.response || 200,
+      },
+    },
+  };
+
+  return config;
+}
+
+/**
+ * Validate required configuration
+ */
+function validateConfig(config) {
+  const errors = [];
+
+  if (!config.discord.token) {
+    errors.push('BOT_TOKEN is required (set in config.json or DISCORD_BOT_TOKEN env)');
+  }
+
+  if (!config.workspace.projectDir) {
+    errors.push('PROJECT_DIR is required');
+  }
+
+  if (errors.length > 0) {
+    console.error('[Config] Validation errors:');
+    errors.forEach(err => console.error(`  - ${err}`));
+    process.exit(1);
+  }
+
+  return config;
+}
+
+// Load and export config
+const config = validateConfig(loadConfig());
+
+export default config;
+export { PROJECT_ROOT, loadConfig, validateConfig };

package/src/core/perf-monitor.js

@@ -0,0 +1,360 @@
+/**
+ * Performance Monitor Module
+ *
+ * Provides lightweight performance monitoring and detailed logging
+ * for AgentBridge bot operations.
+ */
+
+import { writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Performance Monitor Class
+ * Tracks metrics during bot operation
+ */
+export class PerformanceMonitor {
+  constructor(channelId, options = {}) {
+    this.channelId = channelId;
+    this.enabled = options.enabled !== false;
+    this.logFile = options.logFile;
+    this.verbose = options.verbose || false;
+
+    // Metrics
+    this.startTime = Date.now();
+    this.metrics = {
+      // Tool call counts
+      toolCalls: {
+        Read: 0,
+        Write: 0,
+        Edit: 0,
+        Bash: 0,
+        Task: 0,
+        WebFetch: 0,
+        WebSearch: 0,
+        NotebookEdit: 0,
+        Other: 0,
+      },
+      // Subagent tracking
+      subagentDepth: 0,
+      maxSubagentDepth: 0,
+      subagentCalls: 0,
+      // Timing
+      firstToolCall: null,
+      lastToolCall: null,
+      permissionWaits: [],
+      // Bottleneck detection
+      slowOperations: [], // { operation, duration, timestamp }
+    };
+
+    // Detailed log entries (for analysis)
+    this.logEntries = [];
+  }
+
+  /**
+   * Record a tool call
+   */
+  recordToolCall(toolName, input = {}) {
+    if (!this.enabled) return;
+
+    const normalizedTool = this._normalizeToolName(toolName);
+    if (this.metrics.toolCalls[normalizedTool] !== undefined) {
+      this.metrics.toolCalls[normalizedTool]++;
+    } else {
+      this.metrics.toolCalls.Other++;
+    }
+
+    const now = Date.now();
+    if (!this.metrics.firstToolCall) {
+      this.metrics.firstToolCall = now;
+    }
+    this.metrics.lastToolCall = now;
+
+    // Track Task (subagent) depth
+    if (normalizedTool === 'Task') {
+      this.metrics.subagentDepth++;
+      this.metrics.subagentCalls++;
+      if (this.metrics.subagentDepth > this.metrics.maxSubagentDepth) {
+        this.metrics.maxSubagentDepth = this.metrics.subagentDepth;
+      }
+    }
+
+    // Log detailed entry
+    this._log('tool_use', {
+      tool: normalizedTool,
+      input: this._sanitizeInput(input),
+      depth: normalizedTool === 'Task' ? this.metrics.subagentDepth : undefined,
+    });
+  }
+
+  /**
+   * Record a tool result
+   */
+  recordToolResult(toolName, duration = null) {
+    if (!this.enabled) return;
+
+    const normalizedTool = this._normalizeToolName(toolName);
+
+    // Track Task completion (decrease depth)
+    if (normalizedTool === 'Task') {
+      this.metrics.subagentDepth = Math.max(0, this.metrics.subagentDepth - 1);
+    }
+
+    // Track slow operations
+    if (duration && duration > 1000) {
+      this.metrics.slowOperations.push({
+        operation: normalizedTool,
+        duration,
+        timestamp: Date.now(),
+      });
+    }
+
+    // Log detailed entry
+    this._log('tool_result', {
+      tool: normalizedTool,
+      duration,
+      depth: this.metrics.subagentDepth,
+    });
+  }
+
+  /**
+   * Record permission wait time
+   */
+  recordPermissionWait(duration) {
+    if (!this.enabled) return;
+
+    this.metrics.permissionWaits.push({
+      duration,
+      timestamp: Date.now(),
+    });
+
+    this._log('permission_wait', { duration });
+  }
+
+  /**
+   * Get performance summary for display
+   */
+  getSummary() {
+    if (!this.enabled) return '';
+
+    const elapsed = Date.now() - this.startTime;
+    const totalTools = Object.values(this.metrics.toolCalls).reduce((a, b) => a + b, 0);
+    const elapsedSec = Math.floor(elapsed / 1000);
+    const elapsedStr = elapsedSec < 60
+      ? `${elapsedSec}s`
+      : `${Math.floor(elapsedSec / 60)}m${elapsedSec % 60}s`;
+
+    // Build summary line
+    const parts = [];
+
+    // Elapsed time - always show if > 0
+    if (elapsedSec > 0) {
+      parts.push(`⏱️ ${elapsedStr}`);
+    }
+
+    // Tool calls - always show
+    parts.push(`🔧 ${totalTools}`);
+
+    // Subagents - show if any
+    if (this.metrics.subagentCalls > 0) {
+      parts.push(`🤖 ${this.metrics.subagentCalls}`);
+    }
+
+    // Permission waits
+    if (this.metrics.permissionWaits.length > 0) {
+      const totalWait = this.metrics.permissionWaits.reduce((a, b) => a + b.duration, 0);
+      parts.push(`🔒 ${Math.round(totalWait / 1000)}s`);
+    }
+
+    // Bottleneck warning
+    if (this.metrics.slowOperations.length > 0) {
+      const avgSlow = this.metrics.slowOperations.reduce((a, b) => a + b.duration, 0)
+        / this.metrics.slowOperations.length;
+      if (avgSlow > 3000) {
+        parts.push(`⚠️ Slow ops`);
+      }
+    }
+
+    return parts.join(' | ');
+  }
+
+  /**
+   * Get detailed metrics object
+   */
+  getMetrics() {
+    return {
+      ...this.metrics,
+      elapsed: Date.now() - this.startTime,
+      totalToolCalls: Object.values(this.metrics.toolCalls).reduce((a, b) => a + b, 0),
+    };
+  }
+
+  /**
+   * Save detailed logs to file
+   */
+  async saveLogs(outputDir) {
+    if (!this.enabled || this.logEntries.length === 0) return;
+
+    try {
+      if (!existsSync(outputDir)) {
+        mkdirSync(outputDir, { recursive: true });
+      }
+
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const filename = `perf-${this.channelId}-${timestamp}.jsonl`;
+      const filepath = join(outputDir, filename);
+
+      const lines = this.logEntries.map(entry => JSON.stringify(entry)).join('\n');
+      writeFileSync(filepath, lines);
+
+      return filepath;
+    } catch (e) {
+      console.error('[Perf] Failed to save logs:', e.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get bottleneck analysis
+   */
+  analyzeBottlenecks() {
+    const issues = [];
+
+    // Check for excessive tool calls
+    const totalTools = Object.values(this.metrics.toolCalls).reduce((a, b) => a + b, 0);
+    if (totalTools > 50) {
+      issues.push({
+        type: 'excessive_tools',
+        severity: 'warning',
+        message: `Excessive tool calls: ${totalTools}`,
+        suggestion: 'Consider consolidating operations',
+      });
+    }
+
+    // Check for deep subagent nesting
+    if (this.metrics.maxSubagentDepth > 3) {
+      issues.push({
+        type: 'deep_nesting',
+        severity: 'warning',
+        message: `Deep subagent nesting: ${this.metrics.maxSubagentDepth} levels`,
+        suggestion: 'Subagent nesting may cause delays',
+      });
+    }
+
+    // Check for slow operations
+    if (this.metrics.slowOperations.length > 0) {
+      const slowByTool = {};
+      for (const op of this.metrics.slowOperations) {
+        if (!slowByTool[op.operation]) {
+          slowByTool[op.operation] = { count: 0, totalDuration: 0 };
+        }
+        slowByTool[op.operation].count++;
+        slowByTool[op.operation].totalDuration += op.duration;
+      }
+
+      for (const [tool, data] of Object.entries(slowByTool)) {
+        const avg = data.totalDuration / data.count;
+        if (avg > 3000) {
+          issues.push({
+            type: 'slow_tool',
+            severity: 'warning',
+            message: `${tool} averaging ${Math.round(avg / 1000)}s per call`,
+            suggestion: tool === 'Bash' ? 'Commands may be slow' : 'API/IO may be bottleneck',
+          });
+        }
+      }
+    }
+
+    // Check for permission wait times
+    if (this.metrics.permissionWaits.length > 0) {
+      const totalWait = this.metrics.permissionWaits.reduce((a, b) => a + b.duration, 0);
+      const avgWait = totalWait / this.metrics.permissionWaits.length;
+      if (avgWait > 5000) {
+        issues.push({
+          type: 'slow_permissions',
+          severity: 'info',
+          message: `Average permission wait: ${Math.round(avgWait / 1000)}s`,
+          suggestion: 'Consider auto-approving safe operations',
+        });
+      }
+    }
+
+    return issues;
+  }
+
+  /**
+   * Normalize tool name
+   */
+  _normalizeToolName(name) {
+    const map = {
+      'read': 'Read',
+      'write': 'Write',
+      'edit': 'Edit',
+      'bash': 'Bash',
+      'task': 'Task',
+      'webfetch': 'WebFetch',
+      'websearch': 'WebSearch',
+      'notebookedit': 'NotebookEdit',
+    };
+    return map[name.toLowerCase()] || name;
+  }
+
+  /**
+   * Sanitize input for logging
+   */
+  _sanitizeInput(input) {
+    if (!input) return undefined;
+
+    const sanitized = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (key === 'content') {
+        // Truncate content
+        sanitized[key] = typeof value === 'string'
+          ? value.substring(0, 100) + (value.length > 100 ? '...' : '')
+          : value;
+      } else if (key === 'file_path') {
+        // Just show filename
+        sanitized[key] = value?.split('/').pop();
+      } else {
+        sanitized[key] = value;
+      }
+    }
+    return sanitized;
+  }
+
+  /**
+   * Add log entry
+   */
+  _log(type, data) {
+    if (!this.verbose && !this.logFile) return;
+
+    const entry = {
+      timestamp: new Date().toISOString(),
+      type,
+      channelId: this.channelId,
+      elapsed: Date.now() - this.startTime,
+      ...data,
+    };
+
+    this.logEntries.push(entry);
+
+    // Also log to console in verbose mode
+    if (this.verbose) {
+      console.log(`[PERF] ${type}`, JSON.stringify(data).substring(0, 200));
+    }
+  }
+}
+
+/**
+ * Create a monitor instance for a channel
+ */
+export function createMonitor(channelId, options) {
+  return new PerformanceMonitor(channelId, options);
+}
+
+/**
+ * Get summary string for display in status
+ */
+export function formatMonitorSummary(monitor) {
+  if (!monitor || !monitor.enabled) return '';
+  return monitor.getSummary();
+}