onbuzz 3.3.0 → 3.6.1

package/scripts/bump-version.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+/**
+ * Version Bump Script
+ *
+ * Bumps version across ALL files that track it, commits, tags, and pushes.
+ *
+ * Usage:
+ *   node scripts/bump-version.js patch    → 3.6.0 → 3.6.1
+ *   node scripts/bump-version.js minor    → 3.6.0 → 3.7.0
+ *   node scripts/bump-version.js major    → 3.6.0 → 4.0.0
+ *   node scripts/bump-version.js 3.8.0    → explicit version
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+// ─── All files that contain a version to sync ──────────────────────────────
+
+const VERSION_FILES = [
+  { file: 'package.json', key: 'version' },
+  { file: 'package.autopilot.json', key: 'version' },
+  { file: 'web-ui/package.json', key: 'version', independent: true },
+];
+
+// ─── Parse current version ─────────────────────────────────────────────────
+
+function readVersion(relPath) {
+  const full = path.join(ROOT, relPath);
+  const pkg = JSON.parse(fs.readFileSync(full, 'utf8'));
+  return pkg.version;
+}
+
+function writeVersion(relPath, newVersion) {
+  const full = path.join(ROOT, relPath);
+  const pkg = JSON.parse(fs.readFileSync(full, 'utf8'));
+  const oldVersion = pkg.version;
+  pkg.version = newVersion;
+  fs.writeFileSync(full, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+  return oldVersion;
+}
+
+// ─── Bump logic ────────────────────────────────────────────────────────────
+
+function bumpVersion(current, type) {
+  const [major, minor, patch] = current.split('.').map(Number);
+  switch (type) {
+    case 'major': return `${major + 1}.0.0`;
+    case 'minor': return `${major}.${minor + 1}.0`;
+    case 'patch': return `${major}.${minor}.${patch + 1}`;
+    default:
+      // Explicit version string — validate format
+      if (/^\d+\.\d+\.\d+/.test(type)) return type;
+      throw new Error(`Invalid bump type: "${type}". Use: patch, minor, major, or explicit version (e.g. 3.7.0)`);
+  }
+}
+
+// ─── Main ──────────────────────────────────────────────────────────────────
+
+const arg = process.argv[2];
+if (!arg) {
+  console.log('Usage: node scripts/bump-version.js <patch|minor|major|x.y.z>');
+  process.exit(1);
+}
+
+const currentVersion = readVersion('package.json');
+const newVersion = bumpVersion(currentVersion, arg);
+
+console.log(`\n  Version bump: ${currentVersion} → ${newVersion}\n`);
+
+// Update all files
+for (const { file, independent } of VERSION_FILES) {
+  const fullPath = path.join(ROOT, file);
+  if (!fs.existsSync(fullPath)) {
+    console.log(`  ⚠ Skipped (not found): ${file}`);
+    continue;
+  }
+
+  let targetVersion = newVersion;
+
+  // web-ui has its own version scheme — bump its patch independently
+  if (independent) {
+    const webVersion = readVersion(file);
+    const webNew = bumpVersion(webVersion, arg.match(/^\d/) ? arg : arg); // same bump type
+    targetVersion = webNew;
+  }
+
+  const old = writeVersion(file, targetVersion);
+  console.log(`  ✓ ${file}: ${old} → ${targetVersion}`);
+}
+
+// Git: stage, commit, tag, push
+console.log('\n  Git operations:');
+
+const filesToStage = VERSION_FILES.map(v => v.file).filter(f => fs.existsSync(path.join(ROOT, f)));
+execSync(`git add ${filesToStage.join(' ')}`, { cwd: ROOT, stdio: 'pipe' });
+console.log(`  ✓ Staged ${filesToStage.length} files`);
+
+execSync(`git commit -m "v${newVersion}"`, { cwd: ROOT, stdio: 'pipe' });
+console.log(`  ✓ Committed: v${newVersion}`);
+
+try {
+  execSync(`git tag v${newVersion}`, { cwd: ROOT, stdio: 'pipe' });
+  console.log(`  ✓ Tagged: v${newVersion}`);
+} catch {
+  console.log(`  ⚠ Tag v${newVersion} already exists, skipping`);
+}
+
+execSync(`git push origin main --tags`, { cwd: ROOT, stdio: 'pipe' });
+console.log(`  ✓ Pushed to origin/main with tags`);
+
+console.log(`\n  ✅ Version ${newVersion} ready to publish.\n  Run: publish-both.bat\n`);

package/scripts/generate-readme.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * Generate branded README.md from README.template.md
+ *
+ * Usage:
+ *   node scripts/generate-readme.js autopilot
+ *   node scripts/generate-readme.js onbuzz
+ *   VITE_BRAND=onbuzz node scripts/generate-readme.js
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+
+const BRANDS = {
+  autopilot: {
+    FULL_PRODUCT_NAME: 'Loxia Autopilot',
+    PRODUCT_NAME: 'Autopilot',
+    TAGLINE: 'Break All Barriers',
+    NPM_PACKAGE: '@loxia-labs/loxia-autopilot-one',
+    INSTALL_COMMAND: 'npm install -g @loxia-labs/loxia-autopilot-one',
+    CLI_COMMAND: 'loxia',
+    DOMAIN: 'autopilot.loxia.ai',
+    WEBSITE: 'loxia.ai',
+    CONTACT_EMAIL: 'contact@loxia.ai',
+    LEGAL_COMPANY: 'Loxia Labs LLC',
+  },
+  onbuzz: {
+    FULL_PRODUCT_NAME: 'Loxia OnBuzz',
+    PRODUCT_NAME: 'OnBuzz',
+    TAGLINE: 'Your AI Fleet',
+    NPM_PACKAGE: 'onbuzz',
+    INSTALL_COMMAND: 'npm install -g onbuzz',
+    CLI_COMMAND: 'onbuzz',
+    DOMAIN: 'onbuzz.loxia.ai',
+    WEBSITE: 'loxia.ai',
+    CONTACT_EMAIL: 'contact@loxia.ai',
+    LEGAL_COMPANY: 'Loxia Labs LLC',
+  },
+};
+
+const brand = process.argv[2] || process.env.VITE_BRAND || 'autopilot';
+const vars = BRANDS[brand];
+
+if (!vars) {
+  console.error(`Unknown brand: ${brand}. Use: autopilot | onbuzz`);
+  process.exit(1);
+}
+
+let template = readFileSync(join(root, 'README.template.md'), 'utf8');
+
+for (const [key, value] of Object.entries(vars)) {
+  template = template.replaceAll(`{{${key}}}`, value);
+}
+
+writeFileSync(join(root, 'README.md'), template);
+console.log(`✅ README.md generated for ${brand}`);

package/src/core/agentPool.js

@@ -400,6 +400,10 @@ class AgentPool {
             newConversation.compactizationStrategy = oldConversation.compactizationStrategy;
             newConversation.originalTokenCount = oldConversation.originalTokenCount;
             newConversation.compactedTokenCount = oldConversation.compactedTokenCount;
+            // CRITICAL: Copy the sync watermark too — without this, getMessagesForAI
+            // cannot sync new messages to compactizedMessages after a model switch,
+            // causing the AI to only see the compacted summary and repeat itself endlessly.
+            newConversation.originalMessageCountAtCompaction = oldConversation.originalMessageCountAtCompaction;
           }
 
           newConversation.lastUpdated = new Date().toISOString();
@@ -1554,7 +1558,11 @@ class AgentPool {
     // vs which ones were already included in the compaction (sandwich strategy)
     const compactedLength = conversation.compactizedMessages.length;
     const originalLength = conversation.messages.length;
-    const originalCountAtCompaction = conversation.originalMessageCountAtCompaction || originalLength;
+    // SAFETY: If watermark is null/undefined (bug, migration, or cleared state),
+    // fall back to compactedLength — NOT originalLength. Using originalLength silently
+    // drops all unsynced messages because (originalLength > originalLength) is always false.
+    // Using compactedLength ensures any messages beyond what's in the compacted array get synced.
+    const originalCountAtCompaction = conversation.originalMessageCountAtCompaction ?? compactedLength;
 
     // Only sync if NEW messages were added after compaction
     // (i.e., current original length > original length when compaction happened)
@@ -1721,7 +1729,10 @@ class AgentPool {
     if (!conversation || !conversation.compactizedMessages) return { synced: 0 };
 
     const originalLength = conversation.messages.length;
-    const originalCountAtCompaction = conversation.originalMessageCountAtCompaction || originalLength;
+    const compactedLength = conversation.compactizedMessages.length;
+    // SAFETY: Use ?? compactedLength instead of || originalLength to prevent silent message loss
+    // when watermark is null (see getMessagesForAI for detailed explanation)
+    const originalCountAtCompaction = conversation.originalMessageCountAtCompaction ?? compactedLength;
 
     if (originalLength > originalCountAtCompaction) {
       const newCount = originalLength - originalCountAtCompaction;
@@ -1734,7 +1745,8 @@ class AgentPool {
         modelId,
         synced: newCount,
         newMessageRoles: newMessages.map(m => m.role),
-        compactizedMessagesLength: conversation.compactizedMessages.length
+        compactizedMessagesLength: conversation.compactizedMessages.length,
+        watermarkWasNull: conversation.originalMessageCountAtCompaction === null
       });
 
       return { synced: newCount };

package/src/core/agentScheduler.js

@@ -664,11 +664,11 @@ class AgentScheduler {
       });
     }
 
-    // Add tool results as context, grouped by the AI turn that triggered them
+    // Build tool results as a SEPARATE message (role: 'user' with tool-result type marker)
+    // so they are distinguishable from actual user messages in the conversation history.
     const toolResults = allMessages.filter(m => m.queueType === 'toolResults');
+    let toolResultContent = '';
     if (toolResults.length > 0) {
-      if (consolidatedContent) consolidatedContent += '\n\n';
-
       // Group results by responseTurnId (the AI message that triggered them)
       const turnGroups = new Map();
       for (const msg of toolResults) {
@@ -681,20 +681,20 @@ class AgentScheduler {
       const turnCount = turnGroups.size;
       const toolCount = toolResults.length;
       const toolIds = [...new Set(toolResults.map(m => m.toolId).filter(Boolean))];
-      consolidatedContent += `[Tool Results — ${toolCount} result${toolCount > 1 ? 's' : ''} from ${turnCount} tool batch${turnCount > 1 ? 'es' : ''}: ${toolIds.join(', ')}]\n`;
+      toolResultContent += `[Tool Results — ${toolCount} result${toolCount > 1 ? 's' : ''} from ${turnCount} tool batch${turnCount > 1 ? 'es' : ''}: ${toolIds.join(', ')}]\n`;
 
       if (turnCount === 1) {
         // Single batch — flat list (no sub-headers needed)
         toolResults.forEach(msg => {
-          consolidatedContent += `${this.formatToolResult(msg)}\n`;
+          toolResultContent += `${this.formatToolResult(msg)}\n`;
         });
       } else {
         // Multiple batches — group with labeled sub-headers
         let batchIndex = 1;
         for (const [, group] of turnGroups) {
-          consolidatedContent += `\n--- Batch ${batchIndex} of ${turnCount} ---\n`;
+          toolResultContent += `\n--- Batch ${batchIndex} of ${turnCount} ---\n`;
           group.forEach(msg => {
-            consolidatedContent += `${this.formatToolResult(msg)}\n`;
+            toolResultContent += `${this.formatToolResult(msg)}\n`;
           });
           batchIndex++;
         }
@@ -709,18 +709,49 @@ class AgentScheduler {
     // PHASE 2: Auto-create tasks for incoming messages
     await this.autoCreateTasksForMessages(agentId, userMessages, interAgentMessages);
 
-    // Create single consolidated user message for AI processing
-    const consolidatedMessage = {
-      id: `consolidated-${Date.now()}`,
-      role: MESSAGE_ROLES.USER,
-      content: consolidatedContent.trim(),
-      timestamp: new Date().toISOString(),
-      type: 'consolidated-input',
-      originalMessageCount: allMessages.length
-    };
+    // Decide message strategy based on what's queued:
+    // - Tool results only → single message with type: 'tool-result' (most common in agent loops)
+    // - User/inter-agent only → single message with type: 'consolidated-input'
+    // - Both → must merge into single user message (API requires alternating user/assistant)
+    const hasNonToolContent = consolidatedContent.trim().length > 0;
 
-    // Add to conversation history (don't broadcast - this is internal)
-    await this.addMessageToConversation(agentId, consolidatedMessage, false);
+    if (toolResultContent && !hasNonToolContent) {
+      // TOOL RESULTS ONLY — add as dedicated tool-result message
+      const toolMessage = {
+        id: `tool-result-${Date.now()}`,
+        role: MESSAGE_ROLES.USER,
+        content: toolResultContent.trim(),
+        timestamp: new Date().toISOString(),
+        type: 'tool-result',
+        originalMessageCount: toolResults.length
+      };
+      await this.addMessageToConversation(agentId, toolMessage, false);
+    } else if (!toolResultContent && hasNonToolContent) {
+      // USER/INTER-AGENT ONLY — add as user message
+      const userMessage = {
+        id: `consolidated-${Date.now()}`,
+        role: MESSAGE_ROLES.USER,
+        content: consolidatedContent.trim(),
+        timestamp: new Date().toISOString(),
+        type: 'consolidated-input',
+        originalMessageCount: userMessages.length + interAgentMessages.length
+      };
+      await this.addMessageToConversation(agentId, userMessage, false);
+    } else if (toolResultContent && hasNonToolContent) {
+      // BOTH — merge into single message to avoid consecutive user messages
+      // (API requires strict user/assistant alternation)
+      // Put tool results first, then user content (user content is higher priority context)
+      const mergedContent = toolResultContent.trim() + '\n\n' + consolidatedContent.trim();
+      const mergedMessage = {
+        id: `consolidated-${Date.now()}`,
+        role: MESSAGE_ROLES.USER,
+        content: mergedContent,
+        timestamp: new Date().toISOString(),
+        type: 'consolidated-input',
+        originalMessageCount: allMessages.length
+      };
+      await this.addMessageToConversation(agentId, mergedMessage, false);
+    }
 
     // CRITICAL: Update conversation tracking when inter-agent messages are processed
     if (agent && interAgentMessages.length > 0) {
@@ -1604,9 +1635,12 @@ class AgentScheduler {
           sessionId: sessionId,
           platformProvided: platformProvided,
           onChunk: (chunk) => {
+            // Normalize chunk to string — some providers (Ollama) send {content, type} objects
+            const chunkText = typeof chunk === 'string' ? chunk : (chunk?.content || chunk?.text || String(chunk));
+
             // Update flow progress if in flow execution
             if (flowProgress) {
-              flowProgress.charactersStreamed += chunk.length;
+              flowProgress.charactersStreamed += chunkText.length;
               flowProgress.chunkCount++;
 
               // Broadcast flow progress every 500ms or 50 chunks
@@ -1622,7 +1656,7 @@ class AgentScheduler {
               type: 'stream_chunk',
               agentId,
               messageId: streamMessageId,
-              content: chunk,
+              content: chunkText,
               timestamp: new Date().toISOString(),
               // Include flow context if present
               ...(flowContext && {
@@ -2089,7 +2123,10 @@ class AgentScheduler {
       // The scheduler's addMessageToConversation only pushes to conversation.messages.
       if (modelConversation.compactizedMessages) {
         const originalLength = modelConversation.messages.length;
-        const originalCount = modelConversation.originalMessageCountAtCompaction || originalLength;
+        const compactedLength = modelConversation.compactizedMessages.length;
+        // SAFETY: Use ?? compactedLength instead of || originalLength to prevent silent message loss
+        // when watermark is null (see agentPool.getMessagesForAI for detailed explanation)
+        const originalCount = modelConversation.originalMessageCountAtCompaction ?? compactedLength;
         if (originalLength > originalCount) {
           const newCount = originalLength - originalCount;
           const newMessages = modelConversation.messages.slice(-newCount);
@@ -2446,6 +2483,27 @@ class AgentScheduler {
         toolCount: toolExecutions.length,
         hasError: !!error
       });
+
+      // If any filesystem tool ran, broadcast updated artifacts to UI
+      const hasFilesystemOps = toolExecutions.some(t => t.toolId === 'filesystem');
+      if (hasFilesystemOps && !error) {
+        try {
+          const agent = this.agentPool.agents?.get(agentId);
+          if (agent?.artifacts && Object.keys(agent.artifacts).length > 0) {
+            this.webSocketManager.broadcastToSession(sessionId, {
+              type: 'artifacts_updated',
+              data: {
+                agentId,
+                artifacts: agent.artifacts,
+                workingDirectory: agent.directoryAccess?.workingDirectory || ''
+              }
+            });
+            console.log('[Artifacts] Broadcast to session:', sessionId, Object.keys(agent.artifacts).length, 'files');
+          }
+        } catch (e) {
+          // Non-fatal — UI can still fetch via API
+        }
+      }
     }
   }
 

package/src/core/messageProcessor.js

@@ -412,12 +412,12 @@ class MessageProcessor {
         });
         
         let result;
+        let toolInput = command.parameters; // Hoisted for artifact tracking access
         if (command.isAsync) {
           result = await this.executeAsyncTool(command, tool, context);
         } else {
           // Synchronous tool execution
           // If we have parameters object, use it. Otherwise parse the content.
-          let toolInput = command.parameters;
 
           if (!toolInput && command.content) {
             // Content is a string, need to parse it using tool's parseParameters method
@@ -475,7 +475,16 @@ class MessageProcessor {
         }
         
         results.push(result);
-        
+
+        // ── Artifact tracking (fire-and-forget) ─────────────────────
+        // After successful filesystem writes, persist artifact metadata
+        // on the agent object so the UI can display version history.
+        // Non-blocking: uses .catch() to avoid disrupting the tool pipeline.
+        if (result.status === 'completed' && command.toolId === TOOL_IDS.FILESYSTEM) {
+          this._trackArtifacts({ ...command, parameters: toolInput }, result, context)
+            .catch(e => this.logger?.warn?.('[Artifacts] tracking failed:', e.message));
+        }
+
         // Store in execution history
         const historyKey = `${context.agentId}-${Date.now()}`;
         this.executionHistory.set(historyKey, {
@@ -502,6 +511,105 @@ class MessageProcessor {
     return results;
   }
 
+  /**
+   * Track filesystem write/append operations as artifacts on the agent.
+   * Persists lightweight metadata (path, size, timestamp) and the content
+   * so the UI can show version history without re-parsing message content.
+   *
+   * The agent.artifacts map is persisted via the normal persistAgentState flow
+   * that already runs after tool execution in AgentScheduler.
+   *
+   * @param {Object} command - Tool command with parameters
+   * @param {Object} result - Execution result
+   * @param {Object} context - Execution context (agentId, projectDir)
+   * @private
+   */
+  async _trackArtifacts(command, result, context) {
+    try {
+      const agent = await this.agentPool?.getAgent?.(context.agentId);
+      if (!agent) {
+        console.log('[Artifacts] No agent found for', context.agentId);
+        return;
+      }
+
+      // Initialize artifacts map if needed: { [filePath]: { versions: [...] } }
+      if (!agent.artifacts) agent.artifacts = {};
+
+      const toolResult = result.result;
+      if (!toolResult?.success) {
+        console.log('[Artifacts] Tool result not successful:', { success: toolResult?.success, keys: Object.keys(toolResult || {}) });
+        return;
+      }
+
+      // Get the actions from the command parameters
+      // The AI may send actions at different levels depending on format:
+      //   { parameters: { actions: [...] } }  — parsed format
+      //   { actions: [...] }                   — top-level format (common)
+      //   { parameters: { type: 'write', ... } } — single action
+      const params = command.parameters || {};
+      const actions = params.actions || command.actions || (params.type ? [params] : []);
+      console.log('[Artifacts] Processing', actions.length, 'actions. Param keys:', Object.keys(params), 'cmd keys:', Object.keys(command));
+      const resultActions = toolResult.actions || [toolResult];
+
+      for (let i = 0; i < actions.length; i++) {
+        const action = actions[i];
+        const actionResult = resultActions[i] || {};
+        const type = action.type || action.action;
+
+        console.log(`[Artifacts] Action[${i}]:`, { type, filePath: action.filePath || action['file-path'], hasContent: !!action.content, contentLen: action.content?.length, actionKeys: Object.keys(action) });
+
+        if ((type === 'write' || type === 'append') && actionResult.success !== false) {
+          // AI uses various field names: filePath, file-path, outputPath, path
+          const rawPath = action.filePath || action['file-path'] || action.outputPath || action.path;
+          const content = action.content;
+          if (!rawPath || !content) {
+            console.log('[Artifacts] Skipped: missing filePath or content', { filePath: !!rawPath, content: !!content, actionKeys: Object.keys(action) });
+            continue;
+          }
+
+          // Use the resolved absolute path as key (prevents collisions for same-name files in different dirs)
+          // Fall back to raw path if fullPath not available
+          const absolutePath = actionResult.fullPath || rawPath;
+          const artifactKey = absolutePath.replace(/\\/g, '/');
+
+          // Relative display path (strip working directory prefix)
+          const wd = (context.projectDir || '').replace(/\\/g, '/');
+          const displayPath = wd && artifactKey.startsWith(wd + '/')
+            ? artifactKey.slice(wd.length + 1)
+            : artifactKey;
+
+          const version = {
+            id: `v-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+            content,
+            timestamp: result.timestamp || new Date().toISOString(),
+            action: type,
+            size: Buffer.byteLength(content, 'utf8'),
+            fullPath: absolutePath,
+          };
+
+          if (!agent.artifacts[artifactKey]) {
+            agent.artifacts[artifactKey] = { displayPath, versions: [] };
+          }
+
+          // Deduplicate: skip if content identical to latest
+          const versions = agent.artifacts[artifactKey].versions;
+          const latest = versions[versions.length - 1];
+          if (latest && latest.content === content) continue;
+
+          versions.push(version);
+          console.log('[Artifacts] Tracked:', displayPath, 'v' + versions.length, '(' + version.size + ' bytes)');
+
+          // Cap at 50 versions per file to keep state reasonable
+          if (versions.length > 50) {
+            versions.splice(0, versions.length - 50);
+          }
+        }
+      }
+    } catch (e) {
+      this.logger?.warn?.('Artifact tracking failed (non-fatal):', e.message);
+    }
+  }
+
   /**
    * Execute async tool
    * @param {Object} command - Tool command

package/src/index.js

@@ -611,8 +611,8 @@ class LoxiaApplication {
     if (interfaceConfig.web?.enabled !== false) {
       // Read port from environment variables (set by CLI) or use config defaults
       const webPort = parseInt(process.env.LOXIA_PORT || process.env.PORT, 10) || 8080;
-      // Use env var, then config, then 127.0.0.1 (avoid 'localhost' due to IPv6 issues)
-      const webHost = process.env.LOXIA_HOST || interfaceConfig.web?.host || '127.0.0.1';
+      // Use env var, then config, then 0.0.0.0 (accept connections from all interfaces)
+      const webHost = process.env.LOXIA_HOST || interfaceConfig.web?.host || '0.0.0.0';
 
       const webConfig = {
         ...interfaceConfig.web,