agentgui 1.0.64 → 1.0.66

package/static/styles.css

@@ -1690,3 +1690,138 @@ p code {
   border-radius: 4px;
   line-height: 1.6;
 }
+
+/* Claude Execution Blocks - Full message structure rendering */
+.execution-blocks {
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+  width: 100%;
+}
+
+.message-block {
+  padding: 0.75rem 1rem;
+  border-radius: 0.5rem;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-color);
+  word-wrap: break-word;
+}
+
+.block-text {
+  color: var(--text-primary);
+  white-space: pre-wrap;
+  line-height: 1.5;
+}
+
+.block-tool-use {
+  background: rgba(59, 130, 246, 0.05);
+  border: 1px solid rgba(59, 130, 246, 0.2);
+  border-radius: 0.5rem;
+  padding: 0.75rem;
+}
+
+.tool-name {
+  color: var(--color-info);
+  font-weight: 600;
+  display: block;
+  margin-bottom: 0.5rem;
+}
+
+.tool-input {
+  background: var(--bg-tertiary);
+  border-radius: 0.375rem;
+  padding: 0.5rem;
+  overflow-x: auto;
+  font-size: 0.8rem;
+  font-family: 'Courier New', monospace;
+}
+
+.tool-input pre {
+  margin: 0;
+  color: var(--text-secondary);
+}
+
+.block-tool-result {
+  background: rgba(16, 185, 129, 0.05);
+  border: 1px solid rgba(16, 185, 129, 0.2);
+  border-radius: 0.5rem;
+  padding: 0.75rem;
+}
+
+.block-tool-result strong {
+  color: var(--color-success);
+  display: block;
+  margin-bottom: 0.5rem;
+}
+
+.tool-result {
+  background: var(--bg-tertiary);
+  border-radius: 0.375rem;
+  padding: 0.5rem;
+  overflow-x: auto;
+  font-size: 0.8rem;
+  font-family: 'Courier New', monospace;
+  max-height: 300px;
+  overflow-y: auto;
+}
+
+.tool-result pre {
+  margin: 0;
+  color: var(--text-secondary);
+}
+
+.block-file-op {
+  background: rgba(245, 158, 11, 0.05);
+  border: 1px solid rgba(245, 158, 11, 0.2);
+  border-radius: 0.5rem;
+  padding: 0.75rem;
+}
+
+.file-action {
+  color: var(--color-warning);
+  font-weight: 600;
+  display: block;
+  margin-bottom: 0.5rem;
+}
+
+.file-path {
+  color: var(--text-secondary);
+  font-size: 0.875rem;
+  font-family: 'Courier New', monospace;
+  margin-bottom: 0.5rem;
+  padding: 0.25rem 0.5rem;
+  background: var(--bg-tertiary);
+  border-radius: 0.25rem;
+}
+
+.file-content {
+  background: var(--bg-tertiary);
+  border-radius: 0.375rem;
+  padding: 0.5rem;
+  overflow-x: auto;
+  font-size: 0.8rem;
+  font-family: 'Courier New', monospace;
+  max-height: 200px;
+  overflow-y: auto;
+}
+
+.file-content pre {
+  margin: 0;
+  color: var(--text-secondary);
+}
+
+.block-unknown {
+  background: var(--bg-tertiary);
+  border-radius: 0.375rem;
+  padding: 0.5rem;
+  overflow-x: auto;
+  font-size: 0.75rem;
+  font-family: 'Courier New', monospace;
+}
+
+.message-content {
+  color: var(--text-primary);
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  line-height: 1.5;
+}

package/conversation-sync.js

@@ -1,196 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { queries } from './database.js';
-
-/**
- * ConversationSync - Watches for changes to Claude Code conversation files
- * and keeps the database synchronized with the latest versions
- */
-export class ConversationSync {
-  constructor() {
-    this.watchers = new Map();
-    this.lastSync = new Map();
-    this.syncInterval = 5000; // Check for changes every 5 seconds
-    this.isRunning = false;
-  }
-
-  /**
-   * Start watching for conversation file changes
-   */
-  start() {
-    if (this.isRunning) return;
-    this.isRunning = true;
-
-    // Watch for changes to sessions-index.json files
-    this.watchProjectDirectory();
-
-    // Periodic sync check
-    this.syncCheckInterval = setInterval(() => {
-      this.checkForUpdates();
-    }, this.syncInterval);
-
-    console.log('[ConversationSync] Started watching for conversation changes');
-  }
-
-  /**
-   * Stop watching for changes
-   */
-  stop() {
-    if (!this.isRunning) return;
-    this.isRunning = false;
-
-    // Clear all watchers
-    for (const [, watcher] of this.watchers) {
-      watcher.close();
-    }
-    this.watchers.clear();
-
-    // Clear interval
-    if (this.syncCheckInterval) {
-      clearInterval(this.syncCheckInterval);
-    }
-
-    console.log('[ConversationSync] Stopped watching for conversation changes');
-  }
-
-  /**
-   * Watch the .claude/projects directory for changes
-   */
-  watchProjectDirectory() {
-    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
-    if (!fs.existsSync(projectsDir)) {
-      console.log('[ConversationSync] Projects directory does not exist:', projectsDir);
-      return;
-    }
-
-    try {
-      const watcher = fs.watch(projectsDir, { recursive: true }, (eventType, filename) => {
-        if (filename && filename.endsWith('sessions-index.json')) {
-          this.handleFileChange(projectsDir, filename);
-        }
-      });
-
-      this.watchers.set(projectsDir, watcher);
-      console.log('[ConversationSync] Watching:', projectsDir);
-    } catch (err) {
-      console.error('[ConversationSync] Error setting up file watcher:', err.message);
-    }
-  }
-
-  /**
-   * Handle changes to sessions-index.json files
-   */
-  handleFileChange(projectsDir, filename) {
-    const fullPath = path.join(projectsDir, filename);
-
-    // Debounce rapid changes
-    if (this.lastSync.has(fullPath)) {
-      const lastTime = this.lastSync.get(fullPath);
-      if (Date.now() - lastTime < 1000) {
-        return; // Skip if changed within last second
-      }
-    }
-
-    this.lastSync.set(fullPath, Date.now());
-    this.syncConversationFile(fullPath);
-  }
-
-  /**
-   * Sync a specific sessions-index.json file
-   */
-  syncConversationFile(indexPath) {
-    try {
-      if (!fs.existsSync(indexPath)) return;
-
-      const index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
-      const entries = index.entries || [];
-      let synced = 0;
-      let updated = 0;
-
-      for (const entry of entries) {
-        const existing = queries.getConversationByExternalId('claude-code', entry.sessionId);
-
-        if (existing) {
-          // Check if conversation has been updated
-          const existingModified = new Date(existing.modified).getTime();
-          const newModified = new Date(entry.modified).getTime();
-
-          if (newModified > existingModified) {
-            // Update with new information
-            queries.updateConversation(existing.id, {
-              title: entry.summary || entry.firstPrompt || `Conversation ${entry.sessionId.slice(0, 8)}`,
-              messageCount: entry.messageCount || 0,
-              modified: newModified
-            });
-            updated++;
-          }
-        } else {
-          // New conversation - import it
-          const conversation = {
-            externalId: entry.sessionId,
-            agentType: 'claude-code',
-            title: entry.summary || entry.firstPrompt || `Conversation ${entry.sessionId.slice(0, 8)}`,
-            firstPrompt: entry.firstPrompt,
-            messageCount: entry.messageCount || 0,
-            created: new Date(entry.created).getTime(),
-            modified: new Date(entry.modified).getTime(),
-            projectPath: entry.projectPath,
-            gitBranch: entry.gitBranch,
-            sourcePath: entry.fullPath,
-            source: 'imported'
-          };
-
-          queries.createImportedConversation(conversation);
-          synced++;
-        }
-      }
-
-      if (synced > 0 || updated > 0) {
-        console.log(`[ConversationSync] File: ${path.basename(indexPath)} - synced: ${synced}, updated: ${updated}`);
-      }
-    } catch (err) {
-      console.error('[ConversationSync] Error syncing file:', indexPath, err.message);
-    }
-  }
-
-  /**
-   * Periodic check for any missed updates
-   */
-  checkForUpdates() {
-    try {
-      const projectsDir = path.join(os.homedir(), '.claude', 'projects');
-      if (!fs.existsSync(projectsDir)) return;
-
-      const projects = fs.readdirSync(projectsDir);
-
-      for (const projectName of projects) {
-        const indexPath = path.join(projectsDir, projectName, 'sessions-index.json');
-        if (fs.existsSync(indexPath)) {
-          // Check file's modification time
-          const stat = fs.statSync(indexPath);
-          const lastModified = stat.mtime.getTime();
-          const lastSyncTime = this.lastSync.get(indexPath) || 0;
-
-          if (lastModified > lastSyncTime) {
-            this.syncConversationFile(indexPath);
-          }
-        }
-      }
-    } catch (err) {
-      console.error('[ConversationSync] Error during periodic check:', err.message);
-    }
-  }
-}
-
-// Singleton instance
-let syncInstance = null;
-
-export function getConversationSync() {
-  if (!syncInstance) {
-    syncInstance = new ConversationSync();
-  }
-  return syncInstance;
-}
-
-export default ConversationSync;

package/state-manager.js

@@ -1,360 +0,0 @@
-/**
- * StateManager - Explicit state machine for all prompt processing
- * Ensures predictable, auditable state transitions with no surprises
- */
-
-export class StateManager {
-  // Valid session states
-  static STATES = {
-    PENDING: 'pending',
-    ACQUIRING_ACP: 'acquiring_acp',
-    ACP_ACQUIRED: 'acp_acquired',
-    SENDING_PROMPT: 'sending_prompt',
-    PROCESSING: 'processing',
-    COMPLETED: 'completed',
-    ERROR: 'error',
-    TIMEOUT: 'timeout',
-    CANCELLED: 'cancelled'
-  };
-
-  // Valid state transitions - only these are allowed
-  static VALID_TRANSITIONS = {
-    [this.STATES.PENDING]: [
-      this.STATES.ACQUIRING_ACP,
-      this.STATES.CANCELLED
-    ],
-    [this.STATES.ACQUIRING_ACP]: [
-      this.STATES.ACP_ACQUIRED,
-      this.STATES.ERROR,
-      this.STATES.TIMEOUT,
-      this.STATES.CANCELLED
-    ],
-    [this.STATES.ACP_ACQUIRED]: [
-      this.STATES.SENDING_PROMPT,
-      this.STATES.ERROR,
-      this.STATES.TIMEOUT,
-      this.STATES.CANCELLED
-    ],
-    [this.STATES.SENDING_PROMPT]: [
-      this.STATES.PROCESSING,
-      this.STATES.ERROR,
-      this.STATES.TIMEOUT,
-      this.STATES.CANCELLED
-    ],
-    [this.STATES.PROCESSING]: [
-      this.STATES.COMPLETED,
-      this.STATES.ERROR,
-      this.STATES.TIMEOUT,
-      this.STATES.CANCELLED
-    ],
-    [this.STATES.COMPLETED]: [],
-    [this.STATES.ERROR]: [],
-    [this.STATES.TIMEOUT]: [],
-    [this.STATES.CANCELLED]: []
-  };
-
-  constructor(sessionId, conversationId, messageId, timeout = 120000) {
-    this.sessionId = sessionId;
-    this.conversationId = conversationId;
-    this.messageId = messageId;
-    this.timeout = timeout;
-
-    // State tracking
-    this.state = this.constructor.STATES.PENDING;
-    this.previousState = null;
-    this.stateHistory = [{ state: this.state, timestamp: Date.now(), reason: 'initialized' }];
-    
-    // Data tracking
-    this.data = {
-      acpConnectionTime: null,
-      promptSentTime: null,
-      responseReceivedTime: null,
-      fullText: '',
-      blocks: [],
-      error: null,
-      stackTrace: null
-    };
-
-    // Promise resolution
-    this.promiseResolve = null;
-    this.promiseReject = null;
-    this.completionPromise = new Promise((resolve, reject) => {
-      this.promiseResolve = resolve;
-      this.promiseReject = reject;
-    });
-
-    // Start timeout
-    this.startTimeout();
-
-    console.log(`[StateManager] Session ${sessionId} initialized (timeout: ${timeout}ms)`);
-  }
-
-  /**
-   * Transition to a new state with validation
-   * @param {string} newState - Target state
-   * @param {object} data - State-specific data
-   * @throws {Error} If transition is invalid
-   */
-  transition(newState, data = {}) {
-    const validTransitions = this.constructor.VALID_TRANSITIONS[this.state] || [];
-    
-    if (!validTransitions.includes(newState)) {
-      const error = `Invalid state transition: ${this.state} → ${newState}. Valid: [${validTransitions.join(', ')}]`;
-      console.error(`[StateManager] ${error}`);
-      throw new Error(error);
-    }
-
-    this.previousState = this.state;
-    this.state = newState;
-
-    // Record transition
-    this.stateHistory.push({
-      state: newState,
-      timestamp: Date.now(),
-      reason: data.reason || 'manual transition',
-      details: data.details || {}
-    });
-
-    // Update data
-    Object.assign(this.data, data.data || {});
-
-    // Log transition
-    const duration = this.stateHistory.length > 1 
-      ? Date.now() - this.stateHistory[this.stateHistory.length - 2].timestamp
-      : 0;
-    
-    console.log(`[StateManager] ${this.sessionId} transitioned: ${this.previousState} → ${newState} (+${duration}ms) | ${data.reason || ''}`);
-
-    // Handle terminal states
-    if (newState === this.constructor.STATES.COMPLETED) {
-      this.completeSuccess(data.data);
-    } else if (newState === this.constructor.STATES.ERROR) {
-      this.completeError(data.data?.error, data.data?.stackTrace);
-    } else if (newState === this.constructor.STATES.TIMEOUT) {
-      this.completeError('Operation timeout', data.data?.stackTrace);
-    } else if (newState === this.constructor.STATES.CANCELLED) {
-      this.completeError('Operation cancelled', null);
-    }
-  }
-
-  /**
-   * Start timeout watchdog
-   */
-  startTimeout() {
-    this.timeoutHandle = setTimeout(() => {
-      if (![
-        this.constructor.STATES.COMPLETED,
-        this.constructor.STATES.ERROR,
-        this.constructor.STATES.CANCELLED,
-        this.constructor.STATES.TIMEOUT
-      ].includes(this.state)) {
-        console.error(`[StateManager] ${this.sessionId} TIMEOUT after ${this.timeout}ms in state: ${this.state}`);
-        this.transition(this.constructor.STATES.TIMEOUT, {
-          reason: 'timeout watchdog fired',
-          data: { error: 'Operation exceeded timeout', timeout: this.timeout }
-        });
-      }
-    }, this.timeout);
-  }
-
-  /**
-   * Cancel the timeout
-   */
-  cancelTimeout() {
-    if (this.timeoutHandle) {
-      clearTimeout(this.timeoutHandle);
-      this.timeoutHandle = null;
-    }
-  }
-
-  /**
-   * Mark as successfully completed
-   */
-  completeSuccess(data) {
-    this.cancelTimeout();
-    this.data = { ...this.data, ...data };
-    if (this.promiseResolve) {
-      this.promiseResolve({ state: this.state, data: this.data });
-    }
-  }
-
-  /**
-   * Mark as failed
-   */
-  completeError(error, stackTrace) {
-    this.cancelTimeout();
-    this.data.error = error;
-    this.data.stackTrace = stackTrace;
-    if (this.promiseReject) {
-      this.promiseReject(new Error(`Session failed: ${error}`));
-    }
-  }
-
-  /**
-   * Get current state
-   */
-  getState() {
-    return this.state;
-  }
-
-  /**
-   * Get full state history
-   */
-  getHistory() {
-    return this.stateHistory;
-  }
-
-  /**
-   * Get human-readable summary
-   */
-  getSummary() {
-    const duration = this.stateHistory[this.stateHistory.length - 1].timestamp - this.stateHistory[0].timestamp;
-    return {
-      sessionId: this.sessionId,
-      conversationId: this.conversationId,
-      messageId: this.messageId,
-      state: this.state,
-      previousState: this.previousState,
-      duration: `${duration}ms`,
-      historyLength: this.stateHistory.length,
-      history: this.stateHistory.map(h => `${h.timestamp - this.stateHistory[0].timestamp}ms: ${h.state} (${h.reason})`),
-      data: {
-        fullTextLength: this.data.fullText.length,
-        blocksCount: this.data.blocks.length,
-        error: this.data.error,
-        hasStackTrace: !!this.data.stackTrace
-      }
-    };
-  }
-
-  /**
-   * Wait for completion
-   */
-  async waitForCompletion() {
-    return this.completionPromise;
-  }
-
-  /**
-   * Check if session is in a terminal state
-   */
-  isTerminal() {
-    return [
-      this.constructor.STATES.COMPLETED,
-      this.constructor.STATES.ERROR,
-      this.constructor.STATES.TIMEOUT,
-      this.constructor.STATES.CANCELLED
-    ].includes(this.state);
-  }
-
-  /**
-   * Check if session is in a running state
-   */
-  isRunning() {
-    return !this.isTerminal();
-  }
-
-  /**
-   * Assert session is in specific state
-   */
-  assertState(expectedState) {
-    if (this.state !== expectedState) {
-      throw new Error(`Expected state ${expectedState}, got ${this.state}`);
-    }
-  }
-
-  /**
-   * Assert session can transition to state
-   */
-  assertCanTransition(targetState) {
-    const validTransitions = this.constructor.VALID_TRANSITIONS[this.state] || [];
-    if (!validTransitions.includes(targetState)) {
-      throw new Error(`Cannot transition from ${this.state} to ${targetState}`);
-    }
-  }
-}
-
-export class SessionStateStore {
-  constructor() {
-    this.sessions = new Map(); // sessionId -> StateManager
-  }
-
-  create(sessionId, conversationId, messageId, timeout) {
-    const stateManager = new StateManager(sessionId, conversationId, messageId, timeout);
-    this.sessions.set(sessionId, stateManager);
-    return stateManager;
-  }
-
-  get(sessionId) {
-    return this.sessions.get(sessionId);
-  }
-
-  getOrThrow(sessionId) {
-    const manager = this.sessions.get(sessionId);
-    if (!manager) {
-      throw new Error(`Session ${sessionId} not found in state store`);
-    }
-    return manager;
-  }
-
-  remove(sessionId) {
-    const manager = this.sessions.get(sessionId);
-    if (manager) {
-      manager.cancelTimeout();
-      this.sessions.delete(sessionId);
-    }
-  }
-
-  getAll() {
-    return Array.from(this.sessions.values());
-  }
-
-  getAllActive() {
-    return this.getAll().filter(m => m.isRunning());
-  }
-
-  getAllTerminal() {
-    return this.getAll().filter(m => m.isTerminal());
-  }
-
-  /**
-   * Get diagnostic summary of all sessions
-   */
-  getDiagnostics() {
-    const active = this.getAllActive();
-    const terminal = this.getAllTerminal();
-    return {
-      timestamp: new Date().toISOString(),
-      activeSessions: active.length,
-      terminalSessions: terminal.length,
-      totalSessions: this.sessions.size,
-      active: active.map(m => ({
-        sessionId: m.sessionId,
-        state: m.state,
-        uptime: Date.now() - m.stateHistory[0].timestamp
-      })),
-      recentTerminal: terminal.slice(-5).map(m => m.getSummary())
-    };
-  }
-
-  /**
-   * Cleanup old terminal sessions (older than ttl)
-   */
-  cleanup(ttl = 3600000) {
-    const now = Date.now();
-    const toDelete = [];
-
-    for (const [sessionId, manager] of this.sessions) {
-      if (manager.isTerminal()) {
-        const age = now - manager.stateHistory[manager.stateHistory.length - 1].timestamp;
-        if (age > ttl) {
-          toDelete.push(sessionId);
-        }
-      }
-    }
-
-    toDelete.forEach(sessionId => this.remove(sessionId));
-    if (toDelete.length > 0) {
-      console.log(`[SessionStateStore] Cleaned up ${toDelete.length} old sessions`);
-    }
-  }
-}