@northflare/runner 0.0.1

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

@@ -0,0 +1,734 @@
+"use strict";
+/**
+ * MessageHandler - Processes incoming JSONRPC messages from SSE events
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageHandler = void 0;
+const SSEClient_1 = require("../services/SSEClient");
+const RunnerAPIClient_1 = require("../services/RunnerAPIClient");
+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 {
+    methodHandlers;
+    runner;
+    processedMessages = new Set();
+    sseClient = null;
+    apiClient;
+    isProcessing = false;
+    constructor(runner) {
+        this.runner = runner;
+        this.methodHandlers = new Map();
+        this.apiClient = new RunnerAPIClient_1.RunnerAPIClient(runner.config_);
+        this.registerHandlers();
+    }
+    async startProcessing() {
+        console_1.console.log("MessageHandler: Starting message processing with SSE...");
+        if (this.isProcessing) {
+            logger.warn("Message processing already started");
+            return;
+        }
+        this.isProcessing = true;
+        // Update API client with runner ID if available
+        const runnerId = this.runner.getRunnerId();
+        if (runnerId) {
+            this.apiClient.setRunnerId(runnerId);
+        }
+        // Catch up on missed messages first
+        await this.catchUpMissedMessages();
+        // Start SSE connection
+        await this.connectSSE();
+    }
+    async stopProcessing() {
+        console_1.console.log("MessageHandler: Stopping message processing...");
+        this.isProcessing = false;
+        // Stop SSE client
+        if (this.sseClient) {
+            this.sseClient.stop();
+            this.sseClient = null;
+        }
+        // Clear processed messages tracking
+        this.processedMessages.clear();
+    }
+    /**
+     * Catch up on missed messages since lastProcessedAt
+     */
+    async catchUpMissedMessages() {
+        const lastProcessedAt = this.runner.getLastProcessedAt();
+        if (!lastProcessedAt) {
+            logger.debug("No lastProcessedAt timestamp, skipping catch-up");
+            return;
+        }
+        console_1.console.log(`MessageHandler: Catching up on messages since ${lastProcessedAt.toISOString()}`);
+        try {
+            const messages = await this.apiClient.fetchMissedMessages({
+                since: lastProcessedAt,
+                limit: 1000,
+            });
+            if (messages.length > 0) {
+                console_1.console.log(`MessageHandler: Processing ${messages.length} missed messages`);
+                // Process messages in order
+                for (const message of messages) {
+                    await this.processMessage(message);
+                }
+            }
+            else {
+                console_1.console.log("MessageHandler: No missed messages to process");
+            }
+        }
+        catch (error) {
+            logger.error("Failed to catch up on missed messages:", error);
+            // Continue anyway - SSE connection might still work
+        }
+    }
+    /**
+     * Connect to SSE endpoint
+     */
+    async connectSSE() {
+        const runnerId = this.runner.getRunnerId();
+        if (!runnerId) {
+            throw new Error("Cannot connect to SSE without runner ID");
+        }
+        const token = process.env["NORTHFLARE_RUNNER_TOKEN"];
+        if (!token) {
+            throw new Error("Missing NORTHFLARE_RUNNER_TOKEN");
+        }
+        console_1.console.log("MessageHandler: Connecting to SSE endpoint...");
+        this.sseClient = new SSEClient_1.SSEClient({
+            url: `${this.runner.config_.orchestratorUrl}/api/runner-events`,
+            runnerId,
+            token,
+            onMessage: this.handleSSEEvent.bind(this),
+            onError: (error) => {
+                logger.error("SSE connection error:", error);
+            },
+            onConnect: () => {
+                console_1.console.log("MessageHandler: SSE connection established");
+            },
+            onDisconnect: () => {
+                console_1.console.log("MessageHandler: SSE connection closed");
+            },
+            reconnectInterval: 1000,
+            maxReconnectInterval: 30000,
+            reconnectMultiplier: 2,
+        });
+        // Connect with lastProcessedAt for server-side filtering
+        const lastProcessedAt = this.runner.getLastProcessedAt();
+        await this.sseClient.connect(lastProcessedAt?.toISOString());
+    }
+    /**
+     * Handle SSE event
+     */
+    async handleSSEEvent(event) {
+        if (event.type === "runner.message") {
+            const message = event.data;
+            if (process.env["DEBUG"] === "true") {
+                logger.debug("Received SSE event", {
+                    eventId: event.id,
+                    type: event.type,
+                    messageId: message?.id,
+                    method: message?.payload?.method,
+                    createdAt: message?.createdAt,
+                });
+            }
+            try {
+                // Process the message
+                await this.processMessage(message);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.error("Failed to process runner.message:", msg);
+                // Do not crash the runner on a single bad message
+                return;
+            }
+        }
+        else if (event.type === "connection.established") {
+            logger.debug("SSE connection established", event.data);
+        }
+        else {
+            logger.debug(`Received event type: ${event.type}`, event.data);
+        }
+    }
+    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,
+            });
+        }
+        // Skip if already processed
+        if (this.processedMessages.has(message.id)) {
+            return;
+        }
+        // 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);
+            // Acknowledge ALL messages to update lastProcessedAt
+            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,
+        });
+        try {
+            await this.apiClient.acknowledgeMessage(message.createdAt);
+            // Update local lastProcessedAt
+            await this.runner.updateLastProcessedAt(new Date(message.createdAt));
+            console_1.console.log(`[MessageHandler] ✅ message.acknowledge sent successfully`);
+        }
+        catch (error) {
+            logger.error("Failed to acknowledge message:", error);
+            // Continue processing even if acknowledgment fails
+        }
+    }
+    async markProcessed(message) {
+        // Track processed messages internally
+        this.processedMessages.add(message.id);
+    }
+    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)],
+        ]);
+    }
+    // All the handler methods remain the same as in the original file
+    // Just copy them from the original message-handler.ts starting from line 386
+    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
+        const conversationData = conversation;
+        if (!conversationData) {
+            throw new Error("Missing required parameter: conversation object must be provided");
+        }
+        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, reason } = 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, false, // Not a runner shutdown
+            reason // Pass the reason through
+            );
+            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");
+        }
+        // Require conversation details
+        const conversationData = resumeConversation;
+        if (!conversationData) {
+            throw new Error("Missing required parameter: conversation object must be provided");
+        }
+        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, permissionsMode, config } = params;
+        console_1.console.log(`[MessageHandler] handleConversationConfig called with:`, {
+            conversationId,
+            model,
+            permissionsMode,
+            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 && !permissionsMode) {
+            throw new Error("At least one of model or permissionsMode must be provided");
+        }
+        // Update the config with new values
+        const newConfig = {
+            ...context.config,
+            ...(model && { model }),
+            ...(permissionsMode && { permissionsMode }),
+            ...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, false // Not a runner shutdown, just updating config
+        );
+        // 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.permissionsMode,
+            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, conversation, } = 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, conversation);
+    }
+    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 the UID matches ours FIRST, before checking timestamps
+        // 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_1.console.log("MessageHandler: We are now the active runner");
+            this.runner.setIsActiveRunner(true);
+            await this.runner.updateLastProcessedAt(lastProcessedAt ? new Date(lastProcessedAt) : null);
+            if (process.env["DEBUG"] === "true") {
+                logger.debug("Runner activated as primary", {
+                    runnerUid: runnerUid,
+                    lastProcessedAt: lastProcessedAt,
+                    orchestratorUrl: this.runner.config_.orchestratorUrl,
+                });
+            }
+            // 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 - 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;
+                }
+            }
+            // 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-sse.js.map