@northflare/runner 0.0.19 → 0.0.20

package/dist/components/message-handler-sse.js

@@ -4,10 +4,14 @@
 import { SSEClient } from '../services/SSEClient.js';
 import { RunnerAPIClient } from '../services/RunnerAPIClient.js';
 import { statusLineManager } from '../utils/status-line.js';
-import { console } from '../utils/console.js';
 import { createLogger } from '../utils/logger.js';
-import { isRunnerDebugEnabled } from '../utils/debug.js';
-const logger = createLogger("MessageHandler");
+import { isDebugEnabledFor } from '../utils/debug.js';
+import { buildIncomingMessageLog, messageFlowLogger, messagesDebugEnabled, } from '../utils/message-log.js';
+const logger = createLogger("MessageHandler", "rpc");
+const sseLogger = createLogger("MessageHandler:SSE", "sse");
+// Use getters so debug state is checked at call time, not module load time
+const rpcDebugEnabled = () => isDebugEnabledFor("rpc");
+const sseDebugEnabled = () => isDebugEnabledFor("sse");
 export class MessageHandler {
     methodHandlers;
     runner;
@@ -22,7 +26,9 @@ export class MessageHandler {
         this.registerHandlers();
     }
     async startProcessing() {
-        console.log("MessageHandler: Starting message processing with SSE...");
+        logger.info("Starting message processing with SSE", {
+            runnerId: this.runner.getRunnerId(),
+        });
         if (this.isProcessing) {
             logger.warn("Message processing already started");
             return;
@@ -39,7 +45,7 @@ export class MessageHandler {
         await this.connectSSE();
     }
     async stopProcessing() {
-        console.log("MessageHandler: Stopping message processing...");
+        logger.info("Stopping message processing");
         this.isProcessing = false;
         // Stop SSE client
         if (this.sseClient) {
@@ -58,22 +64,21 @@ export class MessageHandler {
             logger.debug("No lastProcessedAt timestamp, skipping catch-up");
             return;
         }
-        console.log(`MessageHandler: Catching up on messages since ${lastProcessedAt.toISOString()}`);
+        logger.info("Catching up on messages", {
+            since: lastProcessedAt.toISOString(),
+        });
         try {
             const messages = await this.apiClient.fetchMissedMessages({
                 since: lastProcessedAt,
                 limit: 1000,
             });
             if (messages.length > 0) {
-                console.log(`MessageHandler: Processing ${messages.length} missed messages`);
+                logger.info("Processing missed messages", { count: messages.length });
                 // Process messages in order
                 for (const message of messages) {
                     await this.processMessage(message);
                 }
             }
-            else {
-                console.log("MessageHandler: No missed messages to process");
-            }
         }
         catch (error) {
             logger.error("Failed to catch up on missed messages:", error);
@@ -92,7 +97,7 @@ export class MessageHandler {
         if (!token) {
             throw new Error("Missing NORTHFLARE_RUNNER_TOKEN");
         }
-        console.log("MessageHandler: Connecting to SSE endpoint...");
+        logger.info("Connecting to SSE endpoint", { runnerId });
         this.sseClient = new SSEClient({
             url: `${this.runner.config_.orchestratorUrl}/api/runner-events`,
             runnerId,
@@ -102,10 +107,10 @@ export class MessageHandler {
                 logger.error("SSE connection error:", error);
             },
             onConnect: () => {
-                console.log("MessageHandler: SSE connection established");
+                sseLogger.info("SSE connection established", { runnerId });
             },
             onDisconnect: () => {
-                console.log("MessageHandler: SSE connection closed");
+                sseLogger.info("SSE connection closed", { runnerId });
             },
             reconnectInterval: 1000,
             maxReconnectInterval: 30000,
@@ -121,8 +126,8 @@ export class MessageHandler {
     async handleSSEEvent(event) {
         if (event.type === "runner.message") {
             const message = event.data;
-            if (isRunnerDebugEnabled()) {
-                logger.debug("Received SSE event", {
+            if (sseDebugEnabled()) {
+                sseLogger.debug("Received SSE event", {
                     eventId: event.id,
                     type: event.type,
                     messageId: message?.id,
@@ -142,14 +147,14 @@ export class MessageHandler {
             }
         }
         else if (event.type === "connection.established") {
-            logger.debug("SSE connection established", event.data);
+            sseLogger.debug("SSE connection established", event.data);
         }
         else {
-            logger.debug(`Received event type: ${event.type}`, event.data);
+            sseLogger.debug(`Received event type: ${event.type}`, event.data);
         }
     }
     async processMessage(message) {
-        if (isRunnerDebugEnabled()) {
+        if (rpcDebugEnabled()) {
             logger.debug("processMessage called", {
                 messageId: message.id,
                 method: message.payload?.method,
@@ -161,6 +166,9 @@ export class MessageHandler {
         if (this.processedMessages.has(message.id)) {
             return;
         }
+        if (messagesDebugEnabled()) {
+            messageFlowLogger.debug("[incoming] orchestrator -> runner", buildIncomingMessageLog(message));
+        }
         // Check if we should process this message based on ownership
         if (!this.shouldProcessMessage(message)) {
             return;
@@ -175,7 +183,7 @@ export class MessageHandler {
             await this.sendError(message, `Unknown method: ${method}`);
             return;
         }
-        if (isRunnerDebugEnabled()) {
+        if (rpcDebugEnabled()) {
             logger.debug("Processing message", {
                 messageId: message.id,
                 method: method,
@@ -188,7 +196,7 @@ export class MessageHandler {
             await this.markProcessed(message);
             // Acknowledge ALL messages to update lastProcessedAt
             await this.acknowledgeMessage(message);
-            if (isRunnerDebugEnabled()) {
+            if (rpcDebugEnabled()) {
                 logger.debug("Message acknowledged", {
                     messageId: message.id,
                     method: method,
@@ -198,7 +206,7 @@ export class MessageHandler {
             }
         }
         catch (error) {
-            if (isRunnerDebugEnabled()) {
+            if (rpcDebugEnabled()) {
                 logger.debug("Message processing error", {
                     messageId: message.id,
                     method: method,
@@ -248,7 +256,7 @@ export class MessageHandler {
                 reason: "active runner, message after watermark",
             };
         })();
-        if (isRunnerDebugEnabled()) {
+        if (rpcDebugEnabled()) {
             logger.debug("Message processing decision", {
                 messageId: message.id,
                 method: message.payload?.method,
@@ -274,17 +282,24 @@ export class MessageHandler {
     }
     async acknowledgeMessage(message) {
         const runnerId = this.runner.getRunnerId();
-        console.log(`[MessageHandler] Sending message.acknowledge:`, {
-            runnerId,
-            messageTimestamp: message.createdAt,
-            messageId: message.id,
-            method: message.payload?.method,
-        });
+        if (rpcDebugEnabled()) {
+            logger.debug("Sending message.acknowledge", {
+                runnerId,
+                messageTimestamp: message.createdAt,
+                messageId: message.id,
+                method: message.payload?.method,
+            });
+        }
         try {
             await this.apiClient.acknowledgeMessage(message.createdAt);
             // Update local lastProcessedAt
             await this.runner.updateLastProcessedAt(new Date(message.createdAt));
-            console.log(`[MessageHandler] ✅ message.acknowledge sent successfully`);
+            if (rpcDebugEnabled()) {
+                logger.debug("message.acknowledge sent", {
+                    runnerId,
+                    messageId: message.id,
+                });
+            }
         }
         catch (error) {
             logger.error("Failed to acknowledge message:", error);
@@ -300,15 +315,12 @@ export class MessageHandler {
         const conversationObjectType = message.conversationObjectType || (message.taskId ? "Task" : undefined);
         const conversationObjectId = message.conversationObjectId || message.taskId;
         if (!conversationObjectId) {
-            console.error(`[MessageHandler] Cannot send error report - no conversationObjectId available. Error: ${errorMessage}`);
-            if (isRunnerDebugEnabled()) {
-                logger.debug("Error without conversationObjectId", {
-                    messageId: message.id,
-                    method: message.payload?.method,
-                    error: errorMessage,
-                    runnerId: message.runnerId,
-                });
-            }
+            logger.warn("Cannot send error report - missing conversationObjectId", {
+                messageId: message.id,
+                method: message.payload?.method,
+                error: errorMessage,
+                runnerId: message.runnerId,
+            });
             return;
         }
         await this.runner.notify("error.report", {
@@ -330,16 +342,13 @@ export class MessageHandler {
         const conversationObjectType = message.conversationObjectType || (message.taskId ? "Task" : undefined);
         const conversationObjectId = message.conversationObjectId || message.taskId;
         if (!conversationObjectId) {
-            console.error(`[MessageHandler] Cannot send error report - no conversationObjectId available. Processing error: ${errorMessage}`);
-            if (isRunnerDebugEnabled()) {
-                logger.debug("Processing error without conversationObjectId", {
-                    messageId: message.id,
-                    method: message.payload?.method,
-                    error: errorMessage,
-                    stack: errorStack,
-                    runnerId: message.runnerId,
-                });
-            }
+            logger.warn("Cannot send processing error report - missing conversationObjectId", {
+                messageId: message.id,
+                method: message.payload?.method,
+                error: errorMessage,
+                stack: errorStack,
+                runnerId: message.runnerId,
+            });
             return;
         }
         await this.runner.notify("error.report", {
@@ -356,7 +365,7 @@ export class MessageHandler {
         });
     }
     registerHandlers() {
-        console.log("MessageHandler: Registering handlers...");
+        logger.info("Registering message handlers");
         this.methodHandlers = new Map([
             ["conversation.start", this.handleConversationStart.bind(this)],
             ["conversation.stop", this.handleConversationStop.bind(this)],
@@ -387,34 +396,37 @@ export class MessageHandler {
         if (!finalObjectId) {
             throw new Error("Missing conversationObjectId");
         }
-        // Debug log the config
-        console.log(`[MessageHandler] conversation.start config:`, {
-            conversationObjectId,
-            hasConfig: !!config,
-            hasRepository: !!config?.repository,
-            repositoryType: config?.repository?.type,
-            repositoryUrl: config?.repository?.url,
-            workspaceId: config?.workspaceId,
-            fullConfig: JSON.stringify(config, null, 2),
-        });
-        // Debug log workspace instructions received
-        console.log(`[MessageHandler] Received conversation with workspaceInstructions:`, {
-            conversationId: conversationData.id,
-            hasWorkspaceInstructions: !!conversationData.workspaceInstructions,
-            workspaceInstructionsLength: conversationData.workspaceInstructions?.length ?? 0,
-            workspaceInstructionsPreview: conversationData.workspaceInstructions?.slice(0, 100),
-            hasGlobalInstructions: !!conversationData.globalInstructions,
-            globalInstructionsLength: conversationData.globalInstructions?.length ?? 0,
-        });
+        if (rpcDebugEnabled()) {
+            // Debug log the config
+            logger.debug("conversation.start config", {
+                conversationObjectId,
+                hasConfig: !!config,
+                hasRepository: !!config?.repository,
+                repositoryType: config?.repository?.type,
+                repositoryUrl: config?.repository?.url,
+                workspaceId: config?.workspaceId,
+                fullConfig: JSON.stringify(config, null, 2),
+            });
+            logger.debug("Received conversation instructions", {
+                conversationId: conversationData.id,
+                hasWorkspaceInstructions: !!conversationData.workspaceInstructions,
+                workspaceInstructionsLength: conversationData.workspaceInstructions?.length ?? 0,
+                workspaceInstructionsPreview: conversationData.workspaceInstructions?.slice(0, 100),
+                hasGlobalInstructions: !!conversationData.globalInstructions,
+                globalInstructionsLength: conversationData.globalInstructions?.length ?? 0,
+            });
+        }
         // Check if conversation is already active (prevent duplicate starts on catch-up)
         const conversationId = conversationData.id;
         if (this.runner.activeConversations_.has(conversationId)) {
-            console.log(`[MessageHandler] Conversation ${conversationId} already active, skipping duplicate start`);
+            logger.info("Conversation already active, skipping duplicate start", {
+                conversationId,
+            });
             return;
         }
         // Check if this conversation was recently completed (prevent restart on catch-up)
         if (this.runner.wasConversationCompleted(conversationId)) {
-            console.log(`[MessageHandler] Conversation ${conversationId} was already completed, skipping restart`);
+            logger.info("Conversation already completed recently, skipping restart", { conversationId });
             return;
         }
         const provider = this.resolveAgentProvider(conversationData, config);
@@ -433,15 +445,17 @@ export class MessageHandler {
     async handleConversationStop(params, message) {
         // Require conversationId (present at message level); do not fall back to agentSessionId/taskId
         const { conversationId = message.conversationId, reason } = params;
-        console.log(`[MessageHandler] handleConversationStop called with:`, {
-            conversationId,
-            messageConversationId: message.conversationId,
-            agentSessionId: params?.agentSessionId,
-            taskId: params?.taskId,
-            params: JSON.stringify(params),
-            activeConversations: this.runner.activeConversations_.size,
-            conversationIds: Array.from(this.runner.activeConversations_.keys()),
-        });
+        if (rpcDebugEnabled()) {
+            logger.debug("handleConversationStop invoked", {
+                conversationId,
+                messageConversationId: message.conversationId,
+                agentSessionId: params?.agentSessionId,
+                taskId: params?.taskId,
+                params: JSON.stringify(params),
+                activeConversations: this.runner.activeConversations_.size,
+                conversationIds: Array.from(this.runner.activeConversations_.keys()),
+            });
+        }
         // Lookup strictly by conversationId
         let context;
         let targetConversationId;
@@ -449,12 +463,14 @@ export class MessageHandler {
             context = this.runner.getConversationContext(conversationId);
             targetConversationId = conversationId;
         }
-        console.log(`[MessageHandler] handleConversationStop lookup result:`, {
-            contextFound: !!context,
-            targetConversationId,
-            contextTaskId: context?.taskId,
-            contextAgentSessionId: context?.agentSessionId,
-        });
+        if (rpcDebugEnabled()) {
+            logger.debug("handleConversationStop lookup", {
+                contextFound: !!context,
+                targetConversationId,
+                contextTaskId: context?.taskId,
+                contextAgentSessionId: context?.agentSessionId,
+            });
+        }
         // Check if we have any identifier to work with
         if (!conversationId) {
             throw new Error("Missing required parameter: conversationId");
@@ -473,7 +489,9 @@ export class MessageHandler {
         else {
             // No conversation found - this is expected as conversations may have already ended
             // or been cleaned up. Just log it and update status line.
-            console.log(`Conversation stop requested for ${conversationId} - conversation not found or already cleaned up`);
+            logger.info("Conversation stop requested but not found", {
+                conversationId,
+            });
             // If we have a targetConversationId, ensure it's removed from tracking
             if (targetConversationId) {
                 this.runner.activeConversations_.delete(targetConversationId);
@@ -508,12 +526,14 @@ export class MessageHandler {
     }
     async handleConversationConfig(params, message) {
         const { conversationId, model, permissionsMode, config } = params;
-        console.log(`[MessageHandler] handleConversationConfig called with:`, {
-            conversationId,
-            model,
-            permissionsMode,
-            hasConfig: !!config,
-        });
+        if (rpcDebugEnabled()) {
+            logger.debug("handleConversationConfig invoked", {
+                conversationId,
+                model,
+                permissionsMode,
+                hasConfig: !!config,
+            });
+        }
         // Find the active conversation by conversationId only
         let context;
         if (conversationId) {
@@ -533,14 +553,18 @@ export class MessageHandler {
             ...(permissionsMode && { permissionsMode }),
             ...config, // Allow full config overrides if provided
         };
-        console.log(`[MessageHandler] Stopping conversation ${context.conversationId} to apply new config`);
+        logger.info("Stopping conversation to apply new config", {
+            conversationId: context.conversationId,
+        });
         // Stop the current conversation
         const manager = this.getManagerForConversationContext(context);
         await manager.stopConversation(context.agentSessionId, context, false // Not a runner shutdown, just updating config
         );
         // Remove from active conversations
         this.runner.activeConversations_.delete(context.conversationId);
-        console.log(`[MessageHandler] Resuming conversation ${context.conversationId} with new config`);
+        logger.info("Resuming conversation with updated config", {
+            conversationId: context.conversationId,
+        });
         // Resume with new config
         // For CodexManager (openai) we pass the provider to distinguish
         const contextProvider = context.provider?.toLowerCase();
@@ -570,7 +594,9 @@ export class MessageHandler {
         }
         // Update status line
         statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        console.log(`[MessageHandler] Conversation ${context.conversationId} config updated successfully`);
+        logger.info("Conversation config updated", {
+            conversationId: context.conversationId,
+        });
     }
     async handleUserMessage(params, message) {
         const { conversationId, content, config, conversationObjectType = message.conversationObjectType || "Task", conversationObjectId = message.conversationObjectId, conversation, agentSessionId, } = params;
@@ -596,8 +622,11 @@ export class MessageHandler {
     }
     async handleUidChanged(params, _message) {
         const { runnerUid, lastProcessedAt } = params;
-        console.log(`MessageHandler: Handling UID change notification - new UID: ${runnerUid}, lastProcessedAt: ${lastProcessedAt}`);
-        if (isRunnerDebugEnabled()) {
+        logger.info("Handling UID change notification", {
+            runnerUid,
+            lastProcessedAt,
+        });
+        if (rpcDebugEnabled()) {
             logger.debug("UID change notification received", {
                 newUid: runnerUid,
                 currentUid: this.runner.getRunnerUid(),
@@ -611,10 +640,12 @@ export class MessageHandler {
         // This ensures we activate even if we received the message during catch-up
         if (runnerUid === this.runner.getRunnerUid()) {
             // This is our UID - we're the active runner
-            console.log("MessageHandler: We are now the active runner");
+            logger.info("Runner activated as primary", {
+                runnerUid,
+            });
             this.runner.setIsActiveRunner(true);
             await this.runner.updateLastProcessedAt(lastProcessedAt ? new Date(lastProcessedAt) : null);
-            if (isRunnerDebugEnabled()) {
+            if (rpcDebugEnabled()) {
                 logger.debug("Runner activated as primary", {
                     runnerUid: runnerUid,
                     lastProcessedAt: lastProcessedAt,
@@ -629,15 +660,17 @@ export class MessageHandler {
                 });
             }
             catch (error) {
-                console.error("Failed to send activation notification:", error);
-                if (isRunnerDebugEnabled()) {
+                logger.error("Failed to send activation notification", error);
+                if (rpcDebugEnabled()) {
                     logger.debug("Activation notification failed", {
                         error: error instanceof Error ? error.message : String(error),
                     });
                 }
             }
             // Start processing messages from the lastProcessedAt point
-            console.log(`MessageHandler: Will process messages after ${lastProcessedAt || "beginning"}`);
+            logger.info("Activation complete; setting message watermark", {
+                after: lastProcessedAt || "beginning",
+            });
         }
         else {
             // Different UID - check if this is an old UID change that we should ignore
@@ -645,8 +678,11 @@ export class MessageHandler {
             if (currentLastProcessedAt && lastProcessedAt) {
                 const newTime = new Date(lastProcessedAt);
                 if (newTime < currentLastProcessedAt) {
-                    console.log(`MessageHandler: Ignoring old UID change (${lastProcessedAt} < ${currentLastProcessedAt.toISOString()})`);
-                    if (isRunnerDebugEnabled()) {
+                    logger.info("Ignoring old UID change", {
+                        lastProcessedAt,
+                        currentLastProcessedAt: currentLastProcessedAt.toISOString(),
+                    });
+                    if (rpcDebugEnabled()) {
                         logger.debug("Ignoring old UID change", {
                             newUid: runnerUid,
                             newLastProcessedAt: lastProcessedAt,
@@ -657,7 +693,7 @@ export class MessageHandler {
                 }
             }
             // Different UID - we're being replaced
-            console.log(`MessageHandler: We are being replaced by runner with UID ${runnerUid}`);
+            logger.info("Runner deactivated; replacement detected", { runnerUid });
             this.runner.setIsActiveRunner(false);
             // Remember which conversations were active before handoff (by conversationId)
             for (const [conversationId, context] of this.runner
@@ -666,7 +702,7 @@ export class MessageHandler {
                     this.runner.getPreHandoffConversations().add(conversationId);
                 }
             }
-            if (isRunnerDebugEnabled()) {
+            if (rpcDebugEnabled()) {
                 logger.debug("Runner deactivated - being replaced", {
                     newRunnerUid: runnerUid,
                     ourUid: this.runner.getRunnerUid(),
@@ -674,7 +710,9 @@ export class MessageHandler {
                     activeConversationsCount: this.runner.getPreHandoffConversations().size,
                 });
             }
-            console.log(`MessageHandler: Will complete ${this.runner.getPreHandoffConversations().size} active conversations`);
+            logger.info("Runner replacement: completing active conversations", {
+                activeConversationCount: this.runner.getPreHandoffConversations().size,
+            });
             // Emit deactivation notification - wrap in try/catch to handle failures gracefully
             try {
                 await this.runner.notify("runner.deactivate", {
@@ -684,8 +722,8 @@ export class MessageHandler {
                 });
             }
             catch (error) {
-                console.error("Failed to send deactivation notification:", error);
-                if (isRunnerDebugEnabled()) {
+                logger.error("Failed to send deactivation notification", error);
+                if (rpcDebugEnabled()) {
                     logger.debug("Deactivation notification failed", {
                         error: error instanceof Error ? error.message : String(error),
                     });
@@ -698,7 +736,7 @@ export class MessageHandler {
         if (!taskId || !operation) {
             throw new Error("Missing required parameters: taskId and operation");
         }
-        console.log(`MessageHandler: Handling Git operation ${operation} for task ${taskId}`);
+        logger.info("Handling Git operation", { operation, taskId });
         const repoManager = this.runner.repositoryManager_;
         try {
             switch (operation) {
@@ -718,7 +756,7 @@ export class MessageHandler {
                     break;
                 case "push":
                     // TODO: Implement push operation
-                    console.log("Push operation not yet implemented");
+                    logger.warn("Git push operation not yet implemented", { taskId });
                     break;
                 case "rebase":
                     if (!opParams?.targetBranch) {
@@ -741,7 +779,10 @@ export class MessageHandler {
             }
         }
         catch (error) {
-            console.error(`Git operation ${operation} failed for task ${taskId}:`, error);
+            logger.error(`Git operation ${operation} failed`, {
+                taskId,
+                error,
+            });
             await this.recordGitOperation(taskId, operation, "failed", {
                 error: error instanceof Error ? error.message : String(error),
             });
@@ -753,14 +794,14 @@ export class MessageHandler {
         if (!taskId) {
             throw new Error("Missing required parameter: taskId");
         }
-        console.log(`MessageHandler: Cleaning up Git worktree for task ${taskId}`);
+        logger.info("Cleaning up Git worktree", { taskId });
         const repoManager = this.runner.repositoryManager_;
         try {
             await repoManager.removeTaskWorktree(taskId, { preserveBranch });
-            console.log(`Successfully cleaned up worktree for task ${taskId}`);
+            logger.info("Git worktree cleaned up", { taskId, preserveBranch });
         }
         catch (error) {
-            console.error(`Failed to clean up worktree for task ${taskId}:`, error);
+            logger.error(`Failed to clean up worktree for task ${taskId}`, error);
             throw error;
         }
     }
@@ -768,7 +809,7 @@ export class MessageHandler {
         const repoManager = this.runner.repositoryManager_;
         const gitState = await repoManager.getTaskState(taskId);
         if (!gitState) {
-            console.error(`No Git state found for task ${taskId}`);
+            logger.warn(`No Git state found for task ${taskId}`);
             return;
         }
         // Send state update to orchestrator