onbuzz 4.5.0 → 4.6.1

package/src/core/stateManager.js

@@ -589,14 +589,28 @@ class StateManager {
     const safeName = (flowData.name || 'flow').toLowerCase().replace(/[^a-z0-9]/g, '-').slice(0, 20);
     const flowId = `flow-${safeName}-${Date.now()}`;
 
+    // Stamp edge ids on save. Templates and marketplace-installed flows
+    // ship without edge ids; ReactFlow refuses to render edges that
+    // don't have a unique `id`, so unstamped edges show up as
+    // disconnected dots on the canvas. Doing this here rather than in
+    // the editor means the durable shape on disk is always renderable.
+    // Helper is shared with FlowEditor's defense-in-depth layer so the
+    // id format stays consistent across save + reload.
+    const { ensureEdgeIds } = await import('../utilities/flowEdgeIds.js');
+    const stampedEdges = ensureEdgeIds(flowData.edges);
+
     const flow = {
       name: flowData.name,
       description: flowData.description || '',
       nodes: flowData.nodes || [],
-      edges: flowData.edges || [],
+      edges: stampedEdges,
       variables: flowData.variables || {},
       createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString()
+      updatedAt: new Date().toISOString(),
+      // createdBy: only present when the caller stamps it (e.g.
+      // platformControlTool's create-flow path). Not required for the
+      // happy-path UI flow but durable when set.
+      ...(flowData.createdBy ? { createdBy: flowData.createdBy } : {})
     };
 
     flowIndex[flowId] = flow;
@@ -621,8 +635,10 @@ class StateManager {
       throw new Error(`Flow ${flowId} not found`);
     }
 
-    // Only allow updating specific fields
-    const allowedFields = ['name', 'description', 'nodes', 'edges', 'variables'];
+    // Only allow updating specific fields. `version` and `schemaVersion`
+    // are added so the Phase 6 version-stamp write-back persists, and
+    // so v2 flows can be marked when typed I/O is added.
+    const allowedFields = ['name', 'description', 'nodes', 'edges', 'variables', 'version', 'schemaVersion'];
     for (const field of allowedFields) {
       if (updates[field] !== undefined) {
         flowIndex[flowId][field] = updates[field];
@@ -786,25 +802,77 @@ class StateManager {
     const stateDir = this.getStateDir(projectDir);
     const stateFile = path.join(stateDir, agentInfo.stateFile);
     const conversationsFile = path.join(stateDir, agentInfo.conversationsFile);
-    
+
+    // Skeleton defaults the resilient loader falls back to when a state
+    // file is missing, empty, or unrepairable. The state skeleton derives
+    // the agent name from the index entry so even a total wipe leaves
+    // the agent identifiable in the UI rather than ending up nameless.
+    const stateDefault = () => ({
+      version: 2,
+      agentId,
+      state: {
+        id: agentId,
+        name: agentInfo.name || agentId,
+        type: agentInfo.type || 'user-created',
+        status: 'active',
+        mode: 'chat',
+        currentModel: agentInfo.preferredModel || agentInfo.model || null,
+        preferredModel: agentInfo.preferredModel || agentInfo.model || null,
+        systemPrompt: '',
+        capabilities: agentInfo.capabilities || [],
+        taskList: { tasks: [], lastUpdated: new Date().toISOString() },
+        messageQueues: { userMessages: [], interAgentMessages: [], toolResults: [] },
+        interAgentTracking: {},
+      },
+      lastPersisted: new Date().toISOString(),
+    });
+    const conversationsDefault = () => ({
+      version: 2,
+      agentId,
+      conversations: {
+        // Empty `full` conversation — required by validateModelConversations
+        // and the agent loop's history reader. New per-model entries are
+        // added on demand at first use.
+        full: { messages: [], lastUpdated: new Date().toISOString() },
+      },
+      lastPersisted: new Date().toISOString(),
+    });
+
+    // Recovery reports for any auto-fixed files. Attached to the
+    // returned agent so the caller (orchestrator → webServer) can
+    // broadcast each one as a toast in the UI. Empty array on the
+    // happy path; harmless presence otherwise.
+    const recoveries = [];
+
     try {
-      // Load agent state
-      const stateData = await this.loadJSON(stateFile);
-      const conversationsData = await this.loadJSON(conversationsFile);
-      
+      const stateRes = await this.loadJSONResilient(stateFile, stateDefault, {
+        label: `agent state (${agentInfo.name || agentId})`,
+      });
+      const conversationsRes = await this.loadJSONResilient(conversationsFile, conversationsDefault, {
+        label: `agent conversations (${agentInfo.name || agentId})`,
+      });
+      const stateData = stateRes.data;
+      const conversationsData = conversationsRes.data;
+      if (stateRes.recovery) recoveries.push(stateRes.recovery);
+      if (conversationsRes.recovery) recoveries.push(conversationsRes.recovery);
+
       // Validate model conversations integrity
       await this.validateModelConversations(conversationsData.conversations);
-      
+
       // Check if agent is paused
       const pauseStatus = await this.checkAgentPauseStatus(agentId, projectDir);
-      
+
       const restoredAgent = {
         ...stateData.state,
         conversations: conversationsData.conversations,
         isPaused: pauseStatus.isPaused,
         pausedUntil: pauseStatus.pausedUntil,
         isRestored: true,
-        restoredAt: new Date().toISOString()
+        restoredAt: new Date().toISOString(),
+        // Non-enumerable would be cleaner, but agentPool serializes the
+        // whole object — keeping it as a plain field. The orchestrator
+        // strips it before persisting (see import handler).
+        _restoreRecoveries: recoveries,
       };
 
       // CRITICAL: Restore interAgentTracking as a Map (it comes as plain object from JSON)
@@ -813,15 +881,16 @@ class StateManager {
       } else if (!(restoredAgent.interAgentTracking instanceof Map)) {
         restoredAgent.interAgentTracking = new Map(Object.entries(restoredAgent.interAgentTracking));
       }
-      
+
       this.logger.info(`Agent restored: ${agentId}`, {
         name: restoredAgent.name,
         status: restoredAgent.status,
-        messageCount: restoredAgent.conversations?.full?.messages?.length || 0
+        messageCount: restoredAgent.conversations?.full?.messages?.length || 0,
+        recoveryCount: recoveries.length,
       });
-      
+
       return restoredAgent;
-      
+
     } catch (error) {
       this.logger.error(`Agent restoration failed: ${agentId}`, error.message);
       throw error;
@@ -1074,7 +1143,7 @@ class StateManager {
   }
 
   /**
-   * Load JSON data from file
+   * Load JSON data from file (strict — throws on missing or corrupt).
    * @private
    */
   async loadJSON(filePath) {
@@ -1082,6 +1151,185 @@ class StateManager {
     return JSON.parse(data);
   }
 
+  /**
+   * Load JSON with best-effort recovery from common breakage modes.
+   * Designed so a single bad state file doesn't take down the entire
+   * agent-load flow — instead the caller gets back a usable object plus
+   * a `recovery` report that callers can surface as a toast.
+   *
+   * Recovery ladder (first match wins):
+   *   1. Missing file (ENOENT)             → recreate with `defaultValue`,
+   *                                          report `kind='not-found'`
+   *   2. Empty / whitespace-only file       → overwrite with `defaultValue`,
+   *                                          report `kind='empty-recreated'`
+   *   3. Common syntax issues               → repaired in memory and saved
+   *      (trailing comma, BOM, unclosed       back to disk; report
+   *      braces/brackets, stray garbage       `kind='repaired'`
+   *      after the JSON object)
+   *   4. Salvageable first JSON block       → use the salvaged object,
+   *      (anywhere in the buffer)             archive the original to
+   *                                          `<file>.corrupt-<ts>.json`,
+   *                                          report `kind='partial'`
+   *   5. Nothing usable                     → use `defaultValue`, archive
+   *                                          original (if any), report
+   *                                          `kind='unrepairable'`
+   *
+   * @param {string} filePath - Absolute path to the JSON file
+   * @param {Object|Array|null|Function} defaultValue - Value to use when
+   *   the file is missing/empty/unrepairable. If a function is provided
+   *   it's called with the file path and its return value is used.
+   * @param {Object} [options]
+   * @param {boolean} [options.persistRecreated=true] - Whether to write
+   *   the default back to disk on missing/empty/unrepairable cases.
+   * @param {string} [options.label] - Human-readable label used in toast
+   *   messages (e.g. 'agent state', 'agent conversations'). Falls back
+   *   to the file's basename.
+   * @returns {Promise<{data: any, recovery: ?Object}>}
+   */
+  async loadJSONResilient(filePath, defaultValue, options = {}) {
+    const { persistRecreated = true } = options;
+    const label = options.label || path.basename(filePath);
+    const defaultOf = () =>
+      typeof defaultValue === 'function' ? defaultValue(filePath) : defaultValue;
+
+    // 1. Missing file → recreate with default
+    let raw;
+    try {
+      raw = await fs.readFile(filePath, 'utf8');
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        const data = defaultOf();
+        if (persistRecreated && data !== undefined) {
+          try { await this.saveJSON(filePath, data); } catch { /* tolerate read-only mounts */ }
+        }
+        const recovery = {
+          kind: 'not-found', filePath, label,
+          message: `${label} file was missing — created an empty one.`,
+        };
+        this.logger?.info(`[stateManager] ${recovery.message}`, { filePath });
+        return { data, recovery };
+      }
+      throw err; // unexpected read error (permissions, etc) — let caller handle
+    }
+
+    // 2. Empty or whitespace-only → recreate
+    if (!raw || raw.trim().length === 0) {
+      const data = defaultOf();
+      if (persistRecreated && data !== undefined) {
+        try { await this.saveJSON(filePath, data); } catch { /* ok */ }
+      }
+      const recovery = {
+        kind: 'empty-recreated', filePath, label,
+        message: `${label} file was empty — recreated with a default skeleton.`,
+      };
+      this.logger?.warn(`[stateManager] ${recovery.message}`, { filePath });
+      return { data, recovery };
+    }
+
+    // 3. Strict parse — happy path
+    try {
+      return { data: JSON.parse(raw), recovery: null };
+    } catch (firstErr) {
+      // 3a. Quick repairs: BOM, trailing comma before close, junk after
+      // the closing brace, smart quotes that occasionally creep in via
+      // copy-paste. None of these is exotic — they're the top-3 reasons
+      // hand-edited or partially-flushed files break.
+      let repaired = raw;
+      if (repaired.charCodeAt(0) === 0xFEFF) repaired = repaired.slice(1);
+      // Strip ASCII control chars except tab/newline/CR
+      repaired = repaired.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '');
+      // Trim whitespace
+      repaired = repaired.trim();
+      // Drop trailing commas before a closing } or ]
+      repaired = repaired.replace(/,(\s*[}\]])/g, '$1');
+      // Cut anything after the last balanced } / ] (junk after JSON).
+      const lastClose = Math.max(repaired.lastIndexOf('}'), repaired.lastIndexOf(']'));
+      if (lastClose > 0 && lastClose < repaired.length - 1) {
+        repaired = repaired.slice(0, lastClose + 1);
+      }
+      try {
+        const data = JSON.parse(repaired);
+        if (persistRecreated && repaired !== raw) {
+          try { await this.saveJSON(filePath, data); } catch { /* ok */ }
+        }
+        const recovery = {
+          kind: 'repaired', filePath, label,
+          message: `${label} file had a minor syntax issue (${firstErr.message}) — auto-repaired.`,
+        };
+        this.logger?.warn(`[stateManager] ${recovery.message}`, { filePath });
+        return { data, recovery };
+      } catch { /* fall through */ }
+
+      // 3b. Salvage: walk the buffer for the first balanced { ... } block
+      // and try to parse just that. Catches truncated-mid-file cases.
+      const salvaged = this._extractFirstJsonBlock(raw);
+      if (salvaged) {
+        try {
+          const data = JSON.parse(salvaged);
+          const archivePath = `${filePath}.corrupt-${Date.now()}.json`;
+          try { await fs.writeFile(archivePath, raw, 'utf8'); } catch { /* ok */ }
+          if (persistRecreated) {
+            try { await this.saveJSON(filePath, data); } catch { /* ok */ }
+          }
+          const recovery = {
+            kind: 'partial', filePath, label,
+            message: `${label} file was partially corrupt — recovered the first valid section. Original archived to ${path.basename(archivePath)}.`,
+            archivePath,
+          };
+          this.logger?.warn(`[stateManager] ${recovery.message}`, { filePath, archivePath });
+          return { data, recovery };
+        } catch { /* fall through */ }
+      }
+
+      // 4. Nothing parseable — archive the corrupt file and use default
+      const data = defaultOf();
+      const archivePath = `${filePath}.corrupt-${Date.now()}.json`;
+      try { await fs.writeFile(archivePath, raw, 'utf8'); } catch { /* ok */ }
+      if (persistRecreated && data !== undefined) {
+        try { await this.saveJSON(filePath, data); } catch { /* ok */ }
+      }
+      const recovery = {
+        kind: 'unrepairable', filePath, label,
+        message: `${label} file is corrupt and could not be repaired — restored a default skeleton. Original archived to ${path.basename(archivePath)}.`,
+        archivePath,
+        originalError: firstErr.message,
+      };
+      this.logger?.error(`[stateManager] ${recovery.message}`, { filePath, archivePath, error: firstErr.message });
+      return { data, recovery };
+    }
+  }
+
+  /**
+   * Walk a string and return the substring of the first balanced
+   * `{ ... }` block, respecting string literals so braces inside strings
+   * don't confuse the count. Returns null if no complete block exists.
+   * @private
+   */
+  _extractFirstJsonBlock(s) {
+    if (typeof s !== 'string') return null;
+    const start = s.indexOf('{');
+    if (start < 0) return null;
+    let depth = 0;
+    let inStr = false;
+    let escape = false;
+    for (let i = start; i < s.length; i++) {
+      const ch = s[i];
+      if (inStr) {
+        if (escape) { escape = false; continue; }
+        if (ch === '\\') { escape = true; continue; }
+        if (ch === '"') { inStr = false; }
+        continue;
+      }
+      if (ch === '"') { inStr = true; continue; }
+      if (ch === '{') depth++;
+      else if (ch === '}') {
+        depth--;
+        if (depth === 0) return s.slice(start, i + 1);
+      }
+    }
+    return null;
+  }
+
   /**
    * Delete agent state from storage
    * @param {string} agentId - Agent identifier

package/src/index.js

@@ -384,6 +384,14 @@ class LoxiaApplication {
       this.stateManager
     );
 
+    // Expose toolsRegistry on the orchestrator so downstream wiring (e.g.
+    // webServer's flowExecutor init at webServer.js:574 → jobDoneTool
+    // setFlowExecutor) can reach it through the orchestrator handle. Without
+    // this, `this.orchestrator?.toolsRegistry` is undefined at wiring time
+    // and JobDoneTool's flow-contract validation (Phase 8) silently no-ops
+    // for the entire process lifetime.
+    this.orchestrator.toolsRegistry = this.toolsRegistry;
+
     // Set cross-references between components
     this.messageProcessor.orchestrator = this.orchestrator;
     this.messageProcessor.setScheduler(this.agentScheduler);
@@ -530,6 +538,15 @@ class LoxiaApplication {
         const { getMemoryService } = await import('./services/memoryService.js');
         platformControlTool.setMemoryService(getMemoryService(this.logger));
       }
+      // Flow CRUD + execution requires the FlowExecutor (created later in
+      // the boot sequence by the webServer). The webServer init also
+      // calls setFlowExecutor on this tool when it spins up — so this
+      // call is the one that fires when the executor is already alive
+      // (rare during startup), and the webServer call covers the normal
+      // path. Both are idempotent.
+      if (typeof platformControlTool.setFlowExecutor === 'function' && this.flowExecutor) {
+        platformControlTool.setFlowExecutor(this.flowExecutor);
+      }
     }
     
     // Set AgentPool dependency for JobDoneTool