@northflare/runner 0.0.13 → 0.0.16

package/dist/components/message-handler.js

@@ -1,689 +0,0 @@
-"use strict";
-/**
- * MessageHandler - Processes incoming JSONRPC messages from the orchestrator via ElectricSQL collections
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageHandler = void 0;
-const runner_messages_1 = require("../collections/runner-messages");
-const status_line_1 = require("../utils/status-line");
-const console_1 = require("../utils/console");
-const logger_1 = require("../utils/logger");
-const logger = (0, logger_1.createLogger)("MessageHandler");
-class MessageHandler {
-    messagesCollection;
-    methodHandlers;
-    runner;
-    processingSubscription;
-    processedMessages = new Set();
-    constructor(runner) {
-        this.runner = runner;
-        this.methodHandlers = new Map();
-        // Don't initialize collection here - wait until after registration
-        this.registerHandlers();
-    }
-    // Initialize the message collection after registration
-    initializeCollection() {
-        console_1.console.log("MessageHandler: Initializing message collection");
-        if (process.env["DEBUG"] === "true") {
-            logger.debug("Initializing message collection", {
-                runnerId: this.runner.config_.runnerId,
-                runnerUid: this.runner.getRunnerUid(),
-                lastProcessedAt: this.runner.getLastProcessedAt()?.toISOString() || "null",
-                electricUrl: this.runner.config_.electricUrl
-            });
-        }
-        // Stop existing collection if one exists
-        if (this.messagesCollection) {
-            this.messagesCollection.stop();
-        }
-        // Create the collection with initial lastProcessedAt for ElectricSQL filtering
-        // We still filter in JavaScript too since lastProcessedAt changes during runtime
-        this.messagesCollection = (0, runner_messages_1.createRunnerMessagesCollection)(this.runner.config_, this.runner.getLastProcessedAt() // Initial filter + accurate logging
-        );
-    }
-    async startProcessing() {
-        console_1.console.log("MessageHandler: Starting message processing...");
-        if (!this.messagesCollection) {
-            // Initialize collection if not already done
-            this.initializeCollection();
-        }
-        if (process.env["DEBUG"] === "true") {
-            logger.debug("Starting message processing with reactive subscriptions", {
-                runnerUid: this.runner.getRunnerUid(),
-                isActiveRunner: this.runner.getIsActiveRunner(),
-                lastProcessedAt: this.runner.getLastProcessedAt()?.toISOString() || "null"
-            });
-        }
-        // Preload the collection to start sync immediately
-        if (this.messagesCollection?.preload) {
-            if (process.env["DEBUG"] === "true") {
-                logger.debug("Calling preload() to initiate collection sync");
-            }
-            await this.messagesCollection.preload();
-        }
-        // Process any existing messages immediately
-        this.processUnprocessedMessages();
-        // Subscribe to collection changes for reactive updates
-        if (this.messagesCollection) {
-            this.processingSubscription = this.messagesCollection.subscribe(() => {
-                if (process.env["DEBUG"] === "true") {
-                    logger.debug("Collection subscription fired - new data available");
-                }
-                this.processUnprocessedMessages();
-            });
-        }
-    }
-    processUnprocessedMessages() {
-        if (!this.messagesCollection) {
-            return;
-        }
-        const messages = Array.from(this.messagesCollection.state?.values() || []);
-        // Always log collection state in debug mode
-        if (process.env["DEBUG"] === "true") {
-            logger.debug("Collection state check", {
-                hasState: !!this.messagesCollection.state,
-                totalMessages: messages.length,
-                collectionSize: this.messagesCollection.state?.size || 0,
-                runnerId: this.runner.config_.runnerId,
-                isActiveRunner: this.runner.getIsActiveRunner()
-            });
-            // Log ALL messages in the collection
-            if (messages.length > 0) {
-                messages.forEach((msg, index) => {
-                    logger.debug(`Message ${index + 1}/${messages.length} in collection`, {
-                        id: msg.id,
-                        method: msg.payload?.method,
-                        direction: msg.direction,
-                        createdAt: msg.createdAt,
-                        taskId: msg.taskId,
-                        workspaceId: msg.workspaceId,
-                        params: msg.payload?.params
-                    });
-                });
-            }
-        }
-        const unprocessed = messages
-            .filter((msg) => msg.direction === "to_runner" && !this.processedMessages.has(msg.id))
-            .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-        if (process.env["DEBUG"] === "true" && unprocessed.length > 0) {
-            logger.debug("Processing unprocessed messages", {
-                totalMessages: messages.length,
-                unprocessedCount: unprocessed.length,
-                messageIds: unprocessed.map(m => m.id)
-            });
-        }
-        unprocessed.forEach((msg) => this.processMessage(msg));
-    }
-    async stopProcessing() {
-        console_1.console.log("MessageHandler: Stopping message processing...");
-        // Unsubscribe from collection updates
-        if (this.processingSubscription) {
-            this.processingSubscription();
-            this.processingSubscription = undefined;
-        }
-        // Clear processed messages tracking
-        this.processedMessages.clear();
-    }
-    async processMessage(message) {
-        if (process.env["DEBUG"] === "true") {
-            logger.debug("processMessage called", {
-                messageId: message.id,
-                method: message.payload?.method,
-                direction: message.direction,
-                createdAt: message.createdAt
-            });
-        }
-        // Check if we should process this message based on ownership
-        if (!this.shouldProcessMessage(message)) {
-            return;
-        }
-        const { method, params } = message.payload;
-        if (!method) {
-            await this.sendError(message, "Missing method in message payload");
-            return;
-        }
-        const handler = this.methodHandlers.get(method);
-        if (!handler) {
-            await this.sendError(message, `Unknown method: ${method}`);
-            return;
-        }
-        if (process.env["DEBUG"] === "true") {
-            logger.debug("Processing message", {
-                messageId: message.id,
-                method: method,
-                taskId: message.taskId,
-                isActionMessage: this.isActionMessage(message)
-            });
-        }
-        try {
-            await handler(params, message);
-            await this.markProcessed(message.id);
-            // Acknowledge ALL messages to update lastProcessedAt
-            // This ensures the server knows which messages have been processed
-            await this.acknowledgeMessage(message);
-            if (process.env["DEBUG"] === "true") {
-                logger.debug("Message acknowledged", {
-                    messageId: message.id,
-                    method: method,
-                    timestamp: message.createdAt,
-                    wasActionMessage: this.isActionMessage(message)
-                });
-            }
-        }
-        catch (error) {
-            if (process.env["DEBUG"] === "true") {
-                logger.debug("Message processing error", {
-                    messageId: message.id,
-                    method: method,
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-            await this.handleError(message, error);
-        }
-    }
-    shouldProcessMessage(message) {
-        const decision = (() => {
-            // Always process our own responses going to orchestrator
-            if (message.direction === 'to_orchestrator') {
-                return { shouldProcess: true, reason: "own response to orchestrator" };
-            }
-            // Filter by lastProcessedAt first (before checking active status)
-            const lastProcessedAt = this.runner.getLastProcessedAt();
-            if (lastProcessedAt && message.createdAt) {
-                const messageTime = new Date(message.createdAt);
-                if (messageTime <= lastProcessedAt) {
-                    return { shouldProcess: false, reason: "message before lastProcessedAt" };
-                }
-            }
-            // Always process UID change messages (after time check)
-            if (message.payload?.method === 'runner.uid.changed') {
-                return { shouldProcess: true, reason: "UID change message" };
-            }
-            // If we're not the active runner
-            if (!this.runner.getIsActiveRunner()) {
-                // Only process if it's for a pre-handoff conversation by conversationId
-                const cid = message.conversationId || message.payload?.params?.conversationId;
-                if (cid && this.runner.getPreHandoffConversations().has(cid)) {
-                    return { shouldProcess: true, reason: "pre-handoff conversation (by conversationId)" };
-                }
-                return { shouldProcess: false, reason: "not active runner" };
-            }
-            // We're active and message is after lastProcessedAt
-            return { shouldProcess: true, reason: "active runner, message after watermark" };
-        })();
-        if (process.env["DEBUG"] === "true") {
-            logger.debug("Message processing decision", {
-                messageId: message.id,
-                method: message.payload?.method,
-                shouldProcess: decision.shouldProcess,
-                reason: decision.reason,
-                runnerUid: this.runner.getRunnerUid(),
-                isActiveRunner: this.runner.getIsActiveRunner(),
-                lastProcessedAt: this.runner.getLastProcessedAt()?.toISOString() || "null",
-                messageCreatedAt: message.createdAt
-            });
-        }
-        return decision.shouldProcess;
-    }
-    isActionMessage(message) {
-        const actionMethods = [
-            'conversation.start',
-            'conversation.stop',
-            'conversation.resume',
-            'conversation.config',
-            'message.user'
-        ];
-        return actionMethods.includes(message.payload?.method || '');
-    }
-    async acknowledgeMessage(message) {
-        const runnerId = this.runner.getRunnerId();
-        console_1.console.log(`[MessageHandler] Sending message.acknowledge:`, {
-            runnerId,
-            messageTimestamp: message.createdAt,
-            messageId: message.id,
-            method: message.payload?.method
-        });
-        await this.runner.notify('message.acknowledge', {
-            runnerId,
-            messageTimestamp: message.createdAt
-        });
-        console_1.console.log(`[MessageHandler] ✅ message.acknowledge sent successfully`);
-    }
-    async markProcessed(messageId) {
-        // Track processed messages internally
-        this.processedMessages.add(messageId);
-        // Note: We no longer update a processedAt field in the database
-        // Messages are tracked as processed only in memory during the runner session
-    }
-    async sendError(message, errorMessage) {
-        // Send error report with conversation object info if available
-        const conversationObjectType = message.conversationObjectType || (message.taskId ? "task" : undefined);
-        const conversationObjectId = message.conversationObjectId || message.taskId;
-        if (!conversationObjectId) {
-            console_1.console.error(`[MessageHandler] Cannot send error report - no conversationObjectId available. Error: ${errorMessage}`);
-            if (process.env["DEBUG"] === "true") {
-                logger.debug("Error without conversationObjectId", {
-                    messageId: message.id,
-                    method: message.payload?.method,
-                    error: errorMessage,
-                    runnerId: message.runnerId
-                });
-            }
-            return;
-        }
-        await this.runner.notify("error.report", {
-            conversationObjectType,
-            conversationObjectId,
-            messageId: message.id,
-            errorType: "method_error",
-            message: errorMessage,
-            details: {
-                originalMessage: message,
-                timestamp: new Date(),
-            },
-        });
-    }
-    async handleError(message, error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const errorStack = error instanceof Error ? error.stack : undefined;
-        // Send error report with conversation object info if available
-        const conversationObjectType = message.conversationObjectType || (message.taskId ? "task" : undefined);
-        const conversationObjectId = message.conversationObjectId || message.taskId;
-        if (!conversationObjectId) {
-            console_1.console.error(`[MessageHandler] Cannot send error report - no conversationObjectId available. Processing error: ${errorMessage}`);
-            if (process.env["DEBUG"] === "true") {
-                logger.debug("Processing error without conversationObjectId", {
-                    messageId: message.id,
-                    method: message.payload?.method,
-                    error: errorMessage,
-                    stack: errorStack,
-                    runnerId: message.runnerId
-                });
-            }
-            return;
-        }
-        await this.runner.notify("error.report", {
-            conversationObjectType,
-            conversationObjectId,
-            messageId: message.id,
-            errorType: "processing_error",
-            message: errorMessage,
-            details: {
-                stack: errorStack,
-                originalMessage: message,
-                timestamp: new Date(),
-            },
-        });
-    }
-    registerHandlers() {
-        console_1.console.log("MessageHandler: Registering handlers...");
-        this.methodHandlers = new Map([
-            ["conversation.start", this.handleConversationStart.bind(this)],
-            ["conversation.stop", this.handleConversationStop.bind(this)],
-            ["conversation.resume", this.handleConversationResume.bind(this)],
-            ["conversation.config", this.handleConversationConfig.bind(this)],
-            ["message.user", this.handleUserMessage.bind(this)],
-            ["runner.uid.changed", this.handleUidChanged.bind(this)],
-            ["git.operation", this.handleGitOperation.bind(this)],
-            ["git.cleanup", this.handleGitCleanup.bind(this)],
-        ]);
-    }
-    async handleConversationStart(params, message) {
-        const { conversationObjectType = message.conversationObjectType || "task", conversationObjectId = message.conversationObjectId || params.conversation?.objectId, config, initialMessages, conversation } = params;
-        // Validate required parameters
-        if (!config) {
-            throw new Error("Missing required parameter: config");
-        }
-        // Require a conversation object; if missing, try to fetch via conversationId on the message
-        let conversationData = conversation;
-        if (!conversationData) {
-            const cid = params.conversationId || message.conversationId;
-            if (!cid) {
-                throw new Error("Missing required conversation information: conversation object or conversationId");
-            }
-            conversationData = await this.runner.fetchConversationDetails(cid);
-            if (!conversationData) {
-                throw new Error(`Conversation ${cid} not found`);
-            }
-        }
-        const finalObjectType = conversationObjectType || conversationData.objectType;
-        const finalObjectId = conversationObjectId || conversationData.objectId;
-        if (!finalObjectId) {
-            throw new Error("Missing conversationObjectId");
-        }
-        // Debug log the config
-        console_1.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)
-        });
-        // Start the conversation with the provided/loaded conversation details
-        await this.runner.claudeManager_.startConversation(finalObjectType, finalObjectId, config, initialMessages || [], conversationData);
-        // Update status line
-        status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-    }
-    async handleConversationStop(params, message) {
-        // Require conversationId (present at message level); do not fall back to agentSessionId/taskId
-        const { conversationId = message.conversationId } = params;
-        console_1.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())
-        });
-        // Lookup strictly by conversationId
-        let context;
-        let targetConversationId;
-        if (conversationId) {
-            context = this.runner.getConversationContext(conversationId);
-            targetConversationId = conversationId;
-        }
-        console_1.console.log(`[MessageHandler] handleConversationStop lookup result:`, {
-            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");
-        }
-        if (context && targetConversationId) {
-            context.status = "stopping";
-            await this.runner.claudeManager_.stopConversation(context.agentSessionId, context);
-            context.status = "stopped";
-            this.runner.activeConversations_.delete(targetConversationId);
-            // Update status line
-            status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        }
-        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_1.console.log(`Conversation stop requested for ${conversationId} - conversation not found or already cleaned up`);
-            // If we have a targetConversationId, ensure it's removed from tracking
-            if (targetConversationId) {
-                this.runner.activeConversations_.delete(targetConversationId);
-            }
-            status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        }
-    }
-    async handleConversationResume(params, message) {
-        const { conversationId = message.conversationId, conversation: resumeConversation, config, message: resumeMessage } = params;
-        const cid = params.conversationId || conversationId;
-        if (!cid) {
-            throw new Error("Missing required parameter: conversationId");
-        }
-        // Load conversation details if not provided
-        const conversationData = resumeConversation || (await this.runner.fetchConversationDetails(cid));
-        if (!conversationData) {
-            throw new Error(`Conversation ${cid} not found`);
-        }
-        const agentSessionId = conversationData.agentSessionId;
-        if (!agentSessionId) {
-            throw new Error("Cannot resume conversation without agentSessionId");
-        }
-        await this.runner.claudeManager_.resumeConversation(conversationData.objectType, conversationData.objectId, agentSessionId, config, conversationData, resumeMessage);
-    }
-    async handleConversationConfig(params, message) {
-        const { conversationId, model, permissionMode, config } = params;
-        console_1.console.log(`[MessageHandler] handleConversationConfig called with:`, {
-            conversationId,
-            model,
-            permissionMode,
-            hasConfig: !!config
-        });
-        // Find the active conversation by conversationId only
-        let context;
-        if (conversationId) {
-            context = this.runner.getConversationContext(conversationId);
-        }
-        if (!context) {
-            throw new Error(`No active conversation found for conversationId: ${conversationId}`);
-        }
-        // Validate required parameters
-        if (!model && !permissionMode) {
-            throw new Error("At least one of model or permissionMode must be provided");
-        }
-        // Update the config with new values
-        const newConfig = {
-            ...context.config,
-            ...(model && { model }),
-            ...(permissionMode && { permissionMode }),
-            ...config // Allow full config overrides if provided
-        };
-        console_1.console.log(`[MessageHandler] Stopping conversation ${context.conversationId} to apply new config`);
-        // Stop the current conversation
-        await this.runner.claudeManager_.stopConversation(context.agentSessionId, context);
-        // Remove from active conversations
-        this.runner.activeConversations_.delete(context.conversationId);
-        console_1.console.log(`[MessageHandler] Resuming conversation ${context.conversationId} with new config`);
-        // Resume with new config
-        await this.runner.claudeManager_.resumeConversation(context.conversationObjectType, context.conversationObjectId, context.agentSessionId, newConfig, {
-            id: context.conversationId,
-            objectType: context.conversationObjectType,
-            objectId: context.conversationObjectId,
-            model: newConfig.model,
-            globalInstructions: context.globalInstructions,
-            workspaceInstructions: context.workspaceInstructions,
-            permissionsMode: newConfig.permissionMode,
-            agentSessionId: context.agentSessionId
-        }, "<system-instructions>Configuration updated. Please continue with the new settings.</system-instructions>");
-        // Update status line
-        status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        console_1.console.log(`[MessageHandler] Conversation ${context.conversationId} config updated successfully`);
-    }
-    async handleUserMessage(params, message) {
-        const { conversationId, content, config, conversationObjectType = message.conversationObjectType || "task", conversationObjectId = message.conversationObjectId } = params;
-        // Validate required parameters
-        if (!conversationId) {
-            throw new Error("Missing required parameter: conversationId");
-        }
-        if (!content) {
-            throw new Error("Missing required parameter: content");
-        }
-        await this.runner.claudeManager_.sendUserMessage(conversationId, content, config, conversationObjectType, conversationObjectId);
-    }
-    async handleUidChanged(params, _message) {
-        const { runnerUid, lastProcessedAt } = params;
-        console_1.console.log(`MessageHandler: Handling UID change notification - new UID: ${runnerUid}, lastProcessedAt: ${lastProcessedAt}`);
-        if (process.env["DEBUG"] === "true") {
-            logger.debug("UID change notification received", {
-                newUid: runnerUid,
-                currentUid: this.runner.getRunnerUid(),
-                newLastProcessedAt: lastProcessedAt,
-                currentLastProcessedAt: this.runner.getLastProcessedAt()?.toISOString() || "null",
-                wasActiveRunner: this.runner.getIsActiveRunner(),
-                activeConversations: this.runner.activeConversations_.size
-            });
-        }
-        // Check if this is an old UID change that we should ignore
-        const currentLastProcessedAt = this.runner.getLastProcessedAt();
-        if (currentLastProcessedAt && lastProcessedAt) {
-            const newTime = new Date(lastProcessedAt);
-            if (newTime < currentLastProcessedAt) {
-                console_1.console.log(`MessageHandler: Ignoring old UID change (${lastProcessedAt} < ${currentLastProcessedAt.toISOString()})`);
-                if (process.env["DEBUG"] === "true") {
-                    logger.debug("Ignoring old UID change", {
-                        newUid: runnerUid,
-                        newLastProcessedAt: lastProcessedAt,
-                        currentLastProcessedAt: currentLastProcessedAt.toISOString()
-                    });
-                }
-                return;
-            }
-        }
-        if (runnerUid === this.runner.getRunnerUid()) {
-            // This is our UID - we're the active runner
-            console_1.console.log("MessageHandler: We are now the active runner");
-            this.runner.setIsActiveRunner(true);
-            this.runner.setLastProcessedAt(lastProcessedAt ? new Date(lastProcessedAt) : null);
-            if (process.env["DEBUG"] === "true") {
-                logger.debug("Runner activated as primary", {
-                    runnerUid: runnerUid,
-                    lastProcessedAt: lastProcessedAt,
-                    electricUrl: this.runner.config_.electricUrl
-                });
-            }
-            // No need to reinitialize collection - just continue processing
-            // The collection is already initialized and will receive new messages
-            // Emit activation notification - wrap in try/catch to handle failures gracefully
-            try {
-                await this.runner.notify("runner.activate", {
-                    runnerId: this.runner.getRunnerId(),
-                    runnerUid: runnerUid
-                });
-            }
-            catch (error) {
-                console_1.console.error("Failed to send activation notification:", error);
-                if (process.env["DEBUG"] === "true") {
-                    logger.debug("Activation notification failed", {
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            // Start processing messages from the lastProcessedAt point
-            console_1.console.log(`MessageHandler: Will process messages after ${lastProcessedAt || 'beginning'}`);
-        }
-        else {
-            // Different UID - we're being replaced
-            console_1.console.log(`MessageHandler: We are being replaced by runner with UID ${runnerUid}`);
-            this.runner.setIsActiveRunner(false);
-            // Remember which conversations were active before handoff (by conversationId)
-            for (const [conversationId, context] of this.runner.activeConversations_) {
-                if (context.status === 'active') {
-                    this.runner.getPreHandoffConversations().add(conversationId);
-                }
-            }
-            if (process.env["DEBUG"] === "true") {
-                logger.debug("Runner deactivated - being replaced", {
-                    newRunnerUid: runnerUid,
-                    ourUid: this.runner.getRunnerUid(),
-                    preHandoffConversations: Array.from(this.runner.getPreHandoffConversations()),
-                    activeConversationsCount: this.runner.getPreHandoffConversations().size
-                });
-            }
-            console_1.console.log(`MessageHandler: Will complete ${this.runner.getPreHandoffConversations().size} active conversations`);
-            // Emit deactivation notification - wrap in try/catch to handle failures gracefully
-            try {
-                await this.runner.notify("runner.deactivate", {
-                    runnerId: this.runner.getRunnerId(),
-                    runnerUid: this.runner.getRunnerUid(),
-                    activeConversations: this.runner.getPreHandoffConversations().size
-                });
-            }
-            catch (error) {
-                console_1.console.error("Failed to send deactivation notification:", error);
-                if (process.env["DEBUG"] === "true") {
-                    logger.debug("Deactivation notification failed", {
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-        }
-    }
-    async handleGitOperation(params, message) {
-        const { taskId, operation, params: opParams } = params;
-        if (!taskId || !operation) {
-            throw new Error("Missing required parameters: taskId and operation");
-        }
-        console_1.console.log(`MessageHandler: Handling Git operation ${operation} for task ${taskId}`);
-        const repoManager = this.runner.repositoryManager_;
-        try {
-            switch (operation) {
-                case "stage":
-                    await repoManager.stageAll(taskId);
-                    await this.sendGitStateUpdate(taskId);
-                    break;
-                case "commit":
-                    if (!opParams?.message) {
-                        throw new Error("Commit message is required");
-                    }
-                    const commitHash = await repoManager.commit(taskId, opParams.message, opParams.author);
-                    await this.recordGitOperation(taskId, "commit", "succeeded", { commitHash });
-                    await this.sendGitStateUpdate(taskId);
-                    break;
-                case "push":
-                    // TODO: Implement push operation
-                    console_1.console.log("Push operation not yet implemented");
-                    break;
-                case "rebase":
-                    if (!opParams?.targetBranch) {
-                        throw new Error("Target branch is required for rebase");
-                    }
-                    const rebaseResult = await repoManager.rebaseTask(taskId, opParams.targetBranch);
-                    await this.recordGitOperation(taskId, "rebase", rebaseResult.success ? "succeeded" : "failed", rebaseResult);
-                    await this.sendGitStateUpdate(taskId);
-                    break;
-                case "merge":
-                    if (!opParams?.targetBranch) {
-                        throw new Error("Target branch is required for merge");
-                    }
-                    const mergeResult = await repoManager.mergeTask(taskId, opParams.targetBranch, opParams.mode);
-                    await this.recordGitOperation(taskId, "merge", mergeResult.success ? "succeeded" : "failed", mergeResult);
-                    await this.sendGitStateUpdate(taskId);
-                    break;
-                default:
-                    throw new Error(`Unknown Git operation: ${operation}`);
-            }
-        }
-        catch (error) {
-            console_1.console.error(`Git operation ${operation} failed for task ${taskId}:`, error);
-            await this.recordGitOperation(taskId, operation, "failed", { error: error instanceof Error ? error.message : String(error) });
-            throw error;
-        }
-    }
-    async handleGitCleanup(params, message) {
-        const { taskId, preserveBranch = false } = params;
-        if (!taskId) {
-            throw new Error("Missing required parameter: taskId");
-        }
-        console_1.console.log(`MessageHandler: Cleaning up Git worktree for task ${taskId}`);
-        const repoManager = this.runner.repositoryManager_;
-        try {
-            await repoManager.removeTaskWorktree(taskId, { preserveBranch });
-            console_1.console.log(`Successfully cleaned up worktree for task ${taskId}`);
-        }
-        catch (error) {
-            console_1.console.error(`Failed to clean up worktree for task ${taskId}:`, error);
-            throw error;
-        }
-    }
-    async sendGitStateUpdate(taskId) {
-        const repoManager = this.runner.repositoryManager_;
-        const gitState = await repoManager.getTaskState(taskId);
-        if (!gitState) {
-            console_1.console.error(`No Git state found for task ${taskId}`);
-            return;
-        }
-        // Send state update to orchestrator
-        await this.runner.notify("git.state.update", {
-            taskId,
-            state: {
-                branch: gitState.branch,
-                commit: gitState.lastCommit || "",
-                isDirty: false, // TODO: Check actual dirty state
-                ahead: 0, // TODO: Calculate ahead/behind
-                behind: 0,
-            },
-        });
-    }
-    async recordGitOperation(taskId, operation, status, details) {
-        // Send operation record to orchestrator
-        await this.runner.notify("git.operation.record", {
-            taskId,
-            operation,
-            status,
-            details,
-            timestamp: new Date(),
-        });
-    }
-}
-exports.MessageHandler = MessageHandler;
-//# sourceMappingURL=message-handler.js.map