feat(ai): Implement Neural Link Log & Error Streaming (#8192)

- App Worker: Implement interceptConsole to forward logs/errors to Neural Link.
- ConnectionService: Implement log ring buffer and getConsoleLogs tool.
- OpenAPI: Add /console/logs/get endpoint.

Author: tobiu

ai/mcp/server/neural-link/openapi.yaml

@@ -732,6 +732,53 @@ paths:
               schema:
                 $ref: '#/components/schemas/ErrorResponse'
 
+  /console/logs/get:
+    post:
+      summary: Get Console Logs
+      operationId: get_console_logs
+      x-pass-as-object: true
+      description: |
+        Retrieves the console logs from the App Worker.
+
+        **When to Use:**
+        To see the App Worker's console output (log, warn, error) and exceptions.
+      tags: [Inspection]
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/GetConsoleLogsRequest'
+      responses:
+        '200':
+          description: List of logs
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: object
+                  properties:
+                    type:
+                      type: string
+                    message:
+                      type: string
+                    timestamp:
+                      type: number
+                    stack:
+                      type: string
+        '400':
+          description: Invalid request body
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ErrorResponse'
+        '500':
+          description: Internal server error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ErrorResponse'
+
   /worker/topology:
     post:
       summary: Get Worker Topology
@@ -1080,6 +1127,20 @@ components:
           type: string
           description: The target App Worker Session ID
 
+    GetConsoleLogsRequest:
+      type: object
+      properties:
+        sessionId:
+          type: string
+          description: The target App Worker Session ID
+        filter:
+          type: string
+          description: Optional string to filter logs by message content.
+        type:
+          type: string
+          enum: [log, warn, error, info]
+          description: Optional filter by log type.
+
     ReloadPageRequest:
       type: object
       properties:

ai/mcp/server/neural-link/services/ConnectionService.mjs

@@ -189,6 +189,42 @@ class ConnectionService extends Base {
         }
     }
 
+    /**
+     * @param {Object} params
+     * @param {String} params.sessionId
+     * @param {String} [params.filter]
+     * @param {String} [params.type]
+     */
+    getConsoleLogs({sessionId, filter, type}) {
+        // If no sessionId, pick the most recent one (Auto-Targeting)
+        if (!sessionId) {
+            if (this.sessionData.size > 0) {
+                sessionId = Array.from(this.sessionData.keys()).pop();
+                logger.warn(`No sessionId provided. Defaulting to ${sessionId}`);
+            } else {
+                throw new Error('No active App Worker sessions found.');
+            }
+        }
+
+        const meta = this.sessionData.get(sessionId);
+        if (!meta || !meta.logs) {
+            return [];
+        }
+
+        let logs = meta.logs;
+
+        if (type) {
+            logs = logs.filter(log => log.type === type);
+        }
+
+        if (filter) {
+            const lowerFilter = filter.toLowerCase();
+            logs = logs.filter(log => log.message && log.message.toLowerCase().includes(lowerFilter));
+        }
+
+        return logs
+    }
+
     /**
      * Returns the current status.
      * @returns {Object}
@@ -241,6 +277,7 @@ class ConnectionService extends Base {
         logger.info(`App Worker connected: ${appWorkerId}`);
         this.sessionData.set(appWorkerId, {
             connectedAt: Date.now(),
+            logs       : [],
             sessionId  : appWorkerId
         });
     }
@@ -310,6 +347,19 @@ class ConnectionService extends Base {
      * @param {Object} message
      */
     handleNotification(sessionId, message) {
+        if (message.method === 'console_log') {
+            const meta = this.sessionData.get(sessionId);
+            if (meta) {
+                meta.logs = meta.logs || [];
+                meta.logs.push(message.params);
+                // Keep last 1000 logs
+                if (meta.logs.length > 1000) {
+                    meta.logs.shift();
+                }
+            }
+            return;
+        }
+
         if (message.method === 'register') {
             const meta = this.sessionData.get(sessionId);
             if (meta) {

ai/mcp/server/neural-link/services/toolService.mjs

@@ -16,6 +16,7 @@ const serviceMapping = {
     get_component_property: ComponentService  .getComponentProperty.bind(ComponentService),
     get_component_tree    : ComponentService  .getComponentTree    .bind(ComponentService),
     get_computed_styles   : ComponentService  .getComputedStyles   .bind(ComponentService),
+    get_console_logs      : ConnectionService .getConsoleLogs      .bind(ConnectionService),
     get_dom_rect          : ComponentService  .getDomRect          .bind(ComponentService),
     get_drag_state        : InteractionService.getDragState        .bind(InteractionService),
     get_record            : DataService       .getRecord           .bind(DataService),

src/worker/App.mjs

@@ -80,7 +80,9 @@ class App extends Base {
 
         // convenience shortcuts
         Neo.applyDeltas    = me.applyDeltas   .bind(me);
-        Neo.setCssVariable = me.setCssVariable.bind(me)
+        Neo.setCssVariable = me.setCssVariable.bind(me);
+
+        me.interceptConsole()
     }
 
     /**
@@ -277,12 +279,12 @@ class App extends Base {
     async getAddon(name, windowId) {
         let addon = Neo.main?.addon?.[name];
 
-        if (!addon) {
-            await Neo.Main.importAddon({name, windowId});
-            addon = Neo.main.addon[name]
+        if (addon) {
+            return addon
         }
 
-        return addon
+        await Neo.Main.importAddon({name, windowId});
+        return Neo.main.addon[name]
     }
 
     /**
@@ -332,6 +334,70 @@ class App extends Base {
         )
     }
 
+    /**
+     * Intercepts console logs and errors to forward them to the Neural Link
+     */
+    interceptConsole() {
+        const
+            me    = this,
+            types = ['log', 'warn', 'error', 'info'];
+
+        types.forEach(type => {
+            const original = console[type];
+
+            console[type] = (...args) => {
+                original.apply(console, args);
+
+                if (Neo.ai?.Client?.isConnected) {
+                    try {
+                        const message = args.map(arg => {
+                            if (arg instanceof Error) {
+                                return arg.message + '\n' + arg.stack;
+                            }
+                            if (typeof arg === 'object') {
+                                try {
+                                    return JSON.stringify(arg);
+                                } catch (e) {
+                                    return String(arg);
+                                }
+                            }
+                            return String(arg);
+                        }).join(' ');
+
+                        Neo.ai.Client.sendNotification('console_log', {
+                            type,
+                            message,
+                            timestamp: Date.now(),
+                            stack    : type === 'error' ? new Error().stack : undefined
+                        });
+                    } catch (err) {
+                        // Prevent infinite loop if logging fails
+                    }
+                }
+            };
+        });
+
+        // Intercept unhandled errors
+        const originalOnError = globalThis.onerror;
+
+        globalThis.onerror = (msg, url, lineNo, columnNo, error) => {
+            if (Neo.ai?.Client?.isConnected) {
+                Neo.ai.Client.sendNotification('console_log', {
+                    type     : 'error',
+                    message  : msg,
+                    timestamp: Date.now(),
+                    stack    : error?.stack
+                });
+            }
+
+            if (originalOnError) {
+                return originalOnError(msg, url, lineNo, columnNo, error);
+            }
+
+            return false;
+        };
+    }
+
     /**
      * In case you don't want to include prototype based CSS files, use the className param instead
      * @param {String} windowId