@northflare/runner 0.0.30 → 0.0.32

package/dist/runner-sse.js

@@ -1,877 +0,0 @@
-/**
- * Main RunnerApp class - entry point and lifecycle manager for the runner app
- * Updated to use SSE for real-time messaging instead of ElectricSQL
- */
-import { MessageHandler } from './components/message-handler-sse.js';
-import { ClaudeManager } from './components/claude-sdk-manager.js';
-import { CodexManager } from './components/codex-sdk-manager.js';
-import { NorthflareAgentManager } from './components/northflare-agent-sdk-manager.js';
-import { EnhancedRepositoryManager } from './components/enhanced-repository-manager.js';
-import { StateManager } from './utils/StateManager.js';
-import { createLogger } from './utils/logger.js';
-import { statusLineManager } from './utils/status-line.js';
-import { isRunnerDebugEnabled } from './utils/debug.js';
-import fs from "fs/promises";
-import path from "path";
-import computerName from "computer-name";
-import { sanitizeToolResponsePayload, TOOL_RESPONSE_BYTE_LIMIT, } from './utils/tool-response-sanitizer.js';
-import { buildOutgoingMessageLog, messageFlowLogger, messagesDebugEnabled, } from './utils/message-log.js';
-import { RunnerAPIClient } from './services/RunnerAPIClient.js';
-import { UpdateCoordinator } from './utils/update-coordinator.js';
-import { RUNNER_VERSION } from './utils/version.js';
-function isSubPath(base, candidate) {
-    if (!base)
-        return false;
-    const normalizedBase = path.resolve(base);
-    const normalizedCandidate = path.resolve(candidate);
-    const baseWithSep = normalizedBase.endsWith(path.sep) ? normalizedBase : normalizedBase + path.sep;
-    return (normalizedCandidate === normalizedBase ||
-        normalizedCandidate.startsWith(baseWithSep));
-}
-const logger = createLogger("RunnerApp");
-function logToolResponseTruncation(toolUseId) {
-    const message = `Tool response exceeded ${TOOL_RESPONSE_BYTE_LIMIT} bytes and was truncated`;
-    if (toolUseId) {
-        logger.warn(message, { toolUseId });
-    }
-    else {
-        logger.warn(message);
-    }
-}
-export class RunnerApp {
-    messageHandler;
-    claudeManager;
-    codexManager;
-    northflareAgentManager;
-    repositoryManager;
-    stateManager;
-    updateCoordinator;
-    agentConversations; // Keyed by conversation.id
-    config;
-    configPath;
-    runnerReposCachePath;
-    heartbeatInterval;
-    heartbeatInFlight = false;
-    isRunning = false;
-    isRegistered = false;
-    delayFn = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-    // UID ownership fields
-    runnerUid = null;
-    lastProcessedAt = null;
-    isActiveRunner = false;
-    // Track conversations started before takeover
-    preHandoffConversations = new Set();
-    // Track recently completed conversation IDs to prevent restart on catch-up
-    // Uses a Map with completion timestamp to allow cleanup of old entries
-    completedConversations = new Map();
-    static COMPLETED_CONVERSATION_TTL_MS = 60 * 60 * 1000; // 1 hour
-    // Track summaries that arrive before a conversation starts.
-    pendingConversationSummaries = new Map();
-    constructor(config, configPath) {
-        this.config = config;
-        this.configPath = configPath;
-        this.agentConversations = new Map();
-        this.runnerReposCachePath = path.join(this.config.dataDir, "runner-repos-cache.json");
-        // Note: State manager will be initialized in start() after fetching runnerId
-    }
-    async fetchRunnerId() {
-        const token = process.env["NORTHFLARE_RUNNER_TOKEN"];
-        if (!token) {
-            throw new Error("NORTHFLARE_RUNNER_TOKEN environment variable is required");
-        }
-        try {
-            const response = await fetch(`${this.config.orchestratorUrl}/api/runner/id`, {
-                method: "GET",
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                },
-            });
-            if (!response.ok) {
-                const error = await response.json().catch(() => ({ error: response.statusText }));
-                throw new Error(`Failed to fetch runner ID: ${error.error || response.statusText}`);
-            }
-            const data = await response.json();
-            if (!data.runnerId) {
-                throw new Error("Server did not return runnerId");
-            }
-            logger.info(`Fetched runnerId: ${data.runnerId}`);
-            return data.runnerId;
-        }
-        catch (error) {
-            logger.error("Failed to fetch runner ID from orchestrator", error);
-            throw error;
-        }
-    }
-    initializeComponents() {
-        // Initialize repository manager first as it's used by Claude manager
-        this.repositoryManager = new EnhancedRepositoryManager(this);
-        // Initialize Claude manager with repository manager (using SDK-native manager)
-        this.claudeManager = new ClaudeManager(this, this.repositoryManager);
-        // Initialize Codex manager for OpenAI-based conversations
-        this.codexManager = new CodexManager(this, this.repositoryManager);
-        // Initialize Northflare Agent manager for OpenRouter-based conversations
-        this.northflareAgentManager = new NorthflareAgentManager(this, this.repositoryManager);
-        // Initialize message handler with SSE support
-        this.messageHandler = new MessageHandler(this);
-        // Initialize update coordinator for auto-updates
-        this.updateCoordinator = new UpdateCoordinator({
-            autoUpdateDisabled: process.env["NORTHFLARE_DISABLE_AUTO_UPDATE"] === 'true',
-            getActiveConversationCount: () => this.agentConversations.size,
-            saveState: async () => {
-                await this.stateManager.saveState({
-                    runnerId: this.config.runnerId,
-                    runnerUid: this.runnerUid,
-                    lastProcessedAt: this.lastProcessedAt?.toISOString() || null,
-                    isActiveRunner: this.isActiveRunner,
-                    updatedAt: new Date().toISOString(),
-                });
-            },
-            getConfigPath: () => this.configPath,
-        });
-    }
-    async start() {
-        if (this.isRunning) {
-            throw new Error("Runner is already running");
-        }
-        try {
-            // Fetch runnerId from orchestrator using token
-            const runnerId = await this.fetchRunnerId();
-            this.config.runnerId = runnerId;
-            // Initialize state manager with runnerId
-            this.stateManager = new StateManager(this.config.dataDir, runnerId);
-            // Initialize other components
-            this.initializeComponents();
-            // Load persisted state
-            const savedState = await this.stateManager.loadState();
-            if (savedState) {
-                // Restore state from previous run
-                this.config.runnerId = savedState.runnerId;
-                this.runnerUid = savedState.runnerUid;
-                this.lastProcessedAt = savedState.lastProcessedAt
-                    ? new Date(savedState.lastProcessedAt)
-                    : null;
-                this.isActiveRunner = savedState.isActiveRunner;
-                logger.info("Restored runner state from disk", {
-                    runnerId: savedState.runnerId,
-                    runnerUid: savedState.runnerUid,
-                    lastProcessedAt: savedState.lastProcessedAt,
-                    isActiveRunner: savedState.isActiveRunner,
-                });
-            }
-            // Bootstrap runner repos from server (with cache fallback)
-            await this.refreshRunnerReposFromServer(true);
-            // Register with retry strategy
-            await this.registerWithRetry();
-            // Log debug info after registration
-            if (isRunnerDebugEnabled()) {
-                logger.debug("Runner initialized with ownership details", {
-                    runnerId: this.config.runnerId,
-                    runnerUid: this.runnerUid,
-                    lastProcessedAt: this.lastProcessedAt?.toISOString() || "null",
-                    isActiveRunner: this.isActiveRunner,
-                    orchestratorUrl: this.config.orchestratorUrl,
-                });
-            }
-            // Start message processing with SSE
-            await this.messageHandler.startProcessing();
-            // Start heartbeat after successful registration
-            this.startHeartbeat();
-            this.isRunning = true;
-            logger.info(`Runner ${this.config.runnerId} started successfully`);
-        }
-        catch (error) {
-            logger.error("Failed to start runner:", error);
-            throw error;
-        }
-    }
-    async stop() {
-        if (!this.isRunning) {
-            return;
-        }
-        logger.info(`Stopping runner ${this.config.runnerId}...`);
-        // Stop heartbeat
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = undefined;
-        }
-        // Stop all conversations
-        await this.stopAllConversations();
-        // Stop message processing
-        await this.messageHandler.stopProcessing();
-        // Clean up status line
-        statusLineManager.dispose();
-        this.isRunning = false;
-        logger.info(`Runner ${this.config.runnerId} stopped`);
-    }
-    async notify(method, params) {
-        try {
-            const sanitization = sanitizeToolResponsePayload(method, params);
-            if (sanitization.truncated) {
-                logToolResponseTruncation(sanitization.toolUseId);
-            }
-            const safeParams = sanitization.truncated
-                ? sanitization.params
-                : params;
-            // Log RPC notification in debug mode
-            logger.debug(`[RPC] Sending notification: ${method}`, {
-                method,
-                params: JSON.stringify(safeParams, null, 2),
-            });
-            // Send notification with retry logic
-            await this.sendToOrchestratorWithRetry({
-                jsonrpc: "2.0",
-                method,
-                params: safeParams,
-            });
-        }
-        catch (error) {
-            // Special handling for heartbeat errors - just log a simple line
-            if (method === "runner.heartbeat") {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error(`Heartbeat failed: ${errorMessage}`);
-            }
-            else {
-                // For other RPC errors, log the method and error without stack
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error(`RPC Error: Failed to notify with method '${method}': ${errorMessage}`);
-            }
-            throw error;
-        }
-    }
-    async sendToOrchestrator(message) {
-        const sanitization = sanitizeToolResponsePayload(message.method, message.params);
-        if (sanitization.truncated) {
-            logToolResponseTruncation(sanitization.toolUseId);
-        }
-        const messageToSend = sanitization.truncated
-            ? {
-                ...message,
-                params: sanitization.params,
-            }
-            : message;
-        try {
-            if (messagesDebugEnabled()) {
-                messageFlowLogger.debug("[outgoing] runner -> orchestrator", {
-                    runnerId: this.config.runnerId,
-                    ...buildOutgoingMessageLog(messageToSend),
-                });
-            }
-            // Log RPC request in debug mode
-            logger.debug(`[RPC] Sending request:`, {
-                method: messageToSend.method,
-                id: messageToSend.id,
-                params: messageToSend.params
-                    ? JSON.stringify(messageToSend.params, null, 2)
-                    : undefined,
-            });
-            // Build headers - only include X-Runner-Id if we have one (not during registration)
-            const headers = {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${process.env["NORTHFLARE_RUNNER_TOKEN"]}`,
-            };
-            // Only add X-Runner-Id if we're registered (not during registration)
-            if (this.config.runnerId && message.method !== "runner.register") {
-                headers["X-Runner-Id"] = this.config.runnerId;
-            }
-            const response = await fetch(`${this.config.orchestratorUrl}/api/runner/messages`, {
-                method: "POST",
-                headers,
-                body: JSON.stringify(messageToSend),
-                signal: AbortSignal.timeout(30000), // 30 second timeout
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`HTTP ${response.status}: ${errorText}`);
-            }
-            const result = (await response.json());
-            // Log RPC response in debug mode
-            logger.debug(`[RPC] Received response:`, {
-                method: messageToSend.method,
-                id: messageToSend.id,
-                result: result?.result
-                    ? JSON.stringify(result.result, null, 2)
-                    : undefined,
-                error: result?.error
-                    ? JSON.stringify(result.error, null, 2)
-                    : undefined,
-            });
-            return result;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Don't log verbose errors for heartbeat failures
-            if (message.method === "runner.heartbeat") {
-                // Heartbeat errors are already logged in notify()
-            }
-            else if (message.method === "runner.register") {
-                // Special case for registration failures
-                logger.error(`Registration failed: ${errorMessage}`);
-            }
-            else {
-                // For other RPC messages, log the attempted message and error
-                logger.error(`RPC failed:`, {
-                    method: messageToSend.method,
-                    params: messageToSend.params,
-                    error: errorMessage,
-                });
-            }
-            throw error;
-        }
-    }
-    getConversationContext(conversationId) {
-        // Using conversation.id as primary key for conversation tracking
-        const context = this.agentConversations.get(conversationId);
-        logger.debug(`[Runner] getConversationContext lookup:`, {
-            conversationId,
-            found: !!context,
-            totalConversations: this.agentConversations.size,
-            allConversationIds: Array.from(this.agentConversations.keys()),
-        });
-        return context;
-    }
-    applyConversationSummary(conversationId, summary) {
-        const normalizedSummary = typeof summary === "string" ? summary.replace(/\s+/g, " ").trim() : "";
-        if (!normalizedSummary)
-            return;
-        const context = this.agentConversations.get(conversationId);
-        if (context) {
-            context.summary = normalizedSummary;
-            return;
-        }
-        this.pendingConversationSummaries.set(conversationId, normalizedSummary);
-    }
-    consumePendingConversationSummary(conversationId) {
-        const summary = this.pendingConversationSummaries.get(conversationId);
-        if (summary) {
-            this.pendingConversationSummaries.delete(conversationId);
-        }
-        return summary;
-    }
-    /**
-     * Check if a conversation was recently completed (to prevent restart on catch-up)
-     */
-    wasConversationCompleted(conversationId) {
-        const completedAt = this.completedConversations.get(conversationId);
-        if (!completedAt)
-            return false;
-        // Check if the completion is still within TTL
-        const now = Date.now();
-        if (now - completedAt > RunnerApp.COMPLETED_CONVERSATION_TTL_MS) {
-            // Expired, clean it up
-            this.completedConversations.delete(conversationId);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Mark a conversation as completed to prevent restart on catch-up
-     */
-    markConversationCompleted(conversationId) {
-        this.completedConversations.set(conversationId, Date.now());
-        // Opportunistically clean up old entries
-        this.cleanupCompletedConversations();
-    }
-    /**
-     * Clean up expired completed conversation entries
-     */
-    cleanupCompletedConversations() {
-        const now = Date.now();
-        for (const [id, completedAt] of this.completedConversations) {
-            if (now - completedAt > RunnerApp.COMPLETED_CONVERSATION_TTL_MS) {
-                this.completedConversations.delete(id);
-            }
-        }
-    }
-    async registerRunner() {
-        try {
-            if (!this.config.workspacePath || !path.isAbsolute(this.config.workspacePath)) {
-                throw new Error("workspacePath must be an absolute path");
-            }
-            const filteredRunnerRepos = Array.isArray(this.config.runnerRepos)
-                ? this.config.runnerRepos
-                : [];
-            // Get computer name for registration
-            let hostComputerName;
-            try {
-                hostComputerName = await computerName();
-            }
-            catch (error) {
-                logger.warn("Failed to get computer name, will use default", error);
-            }
-            const response = await this.sendToOrchestratorWithRetry({
-                jsonrpc: "2.0",
-                id: "register-" + Date.now(),
-                method: "runner.register",
-                params: {
-                    version: RUNNER_VERSION,
-                    runnerRepos: filteredRunnerRepos,
-                    computerName: hostComputerName,
-                    workspacePath: this.config.workspacePath,
-                },
-            });
-            // Debug log the full response
-            logger.info(`Registration response:`, JSON.stringify(response, null, 2));
-            // Log the runnerRepos being sent and received
-            if (isRunnerDebugEnabled()) {
-                logger.debug("Registration runnerRepos sent:", JSON.stringify(filteredRunnerRepos));
-                logger.debug("Registration runnerRepos received:", JSON.stringify(response?.result?.runnerRepos));
-            }
-            // Check for JSONRPC error response
-            if (response?.error) {
-                logger.error(`Registration error from server:`, response.error);
-                throw new Error(`Server error: ${response.error.message || "Unknown error"}`);
-            }
-            // Extract result from JSONRPC response structure
-            const result = response?.result;
-            if (result?.runnerId) {
-                this.config.runnerId = result.runnerId;
-                this.runnerUid = result.runnerUid;
-                this.lastProcessedAt = result.lastProcessedAt
-                    ? new Date(result.lastProcessedAt)
-                    : null;
-                this.isRegistered = true;
-                // If this is a fresh start (no previous lastProcessedAt), set as active runner immediately
-                // The server will also send a runner.uid.changed message, but we set it here to avoid
-                // any window where isActiveRunner is incorrectly false
-                if (!result.lastProcessedAt) {
-                    this.isActiveRunner = true;
-                    logger.info(`First-time registration - setting as active runner immediately`);
-                }
-                // Save registration state
-                await this.stateManager.updateRunnerRegistration(result.runnerId, result.runnerUid, this.lastProcessedAt);
-                // Persist the active status if we set it
-                if (this.isActiveRunner) {
-                    await this.stateManager.updateActiveStatus(true);
-                }
-                logger.info(`Runner registered successfully with ID: ${this.config.runnerId} and UID: ${this.runnerUid}`);
-                // Process runnerRepos from response
-                if (result.runnerRepos && Array.isArray(result.runnerRepos)) {
-                    const prepared = await this.prepareRunnerRepos(result.runnerRepos);
-                    await this.replaceRunnerRepos(prepared);
-                }
-                // Debug logging for registration details
-                if (isRunnerDebugEnabled()) {
-                    logger.debug("Registration complete with details", {
-                        runnerId: this.config.runnerId,
-                        runnerUid: this.runnerUid,
-                        lastProcessedAt: this.lastProcessedAt?.toISOString() || "null",
-                        orchestratorUrl: this.config.orchestratorUrl,
-                        dataDir: this.config.dataDir,
-                        runnerReposCount: result.runnerRepos?.length || 0,
-                    });
-                }
-            }
-            else {
-                logger.error(`Registration failed. Expected result.runnerId but got:`, {
-                    hasResult: !!result,
-                    resultKeys: result ? Object.keys(result) : [],
-                    fullResponse: JSON.stringify(response, null, 2),
-                });
-                throw new Error("Registration response did not include runnerId");
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error(`Failed to register runner: ${errorMessage}`);
-            throw error;
-        }
-    }
-    async registerWithRetry() {
-        const strategy = this.config.retryStrategy;
-        if (strategy === "none") {
-            // Single attempt, no retries
-            await this.registerRunner();
-            return;
-        }
-        if (strategy === "interval") {
-            // Retry at fixed intervals
-            const intervalMs = this.config.retryIntervalSecs * 1000;
-            let attempt = 0;
-            while (!this.isRegistered) {
-                attempt++;
-                try {
-                    logger.info(`Registration attempt ${attempt}...`);
-                    await this.registerRunner();
-                    return;
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    logger.error(`Registration attempt ${attempt} failed: ${errorMessage}`);
-                    logger.info(`Retrying in ${this.config.retryIntervalSecs} seconds...`);
-                    await this.delayFn(intervalMs);
-                }
-            }
-        }
-        if (strategy === "exponential") {
-            // Exponential backoff with max duration
-            const maxDurationMs = this.config.retryDurationSecs * 1000;
-            const startTime = Date.now();
-            let delayMs = 8000; // Start with 8 seconds
-            let attempt = 0;
-            while (!this.isRegistered) {
-                attempt++;
-                try {
-                    logger.info(`Registration attempt ${attempt}...`);
-                    await this.registerRunner();
-                    return;
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    logger.error(`Registration attempt ${attempt} failed: ${errorMessage}`);
-                    const elapsedMs = Date.now() - startTime;
-                    if (elapsedMs >= maxDurationMs) {
-                        // Final retry at max duration
-                        const remainingMs = maxDurationMs - elapsedMs;
-                        if (remainingMs > 0) {
-                            logger.info(`Final retry in ${Math.ceil(remainingMs / 1000)} seconds...`);
-                            await this.delayFn(remainingMs);
-                            try {
-                                logger.info("Final registration attempt...");
-                                await this.registerRunner();
-                                return;
-                            }
-                            catch (finalError) {
-                                const errorMessage = finalError instanceof Error
-                                    ? finalError.message
-                                    : String(finalError);
-                                logger.error(`Final registration attempt failed: ${errorMessage}`);
-                                throw new Error(`Failed to register after ${this.config.retryDurationSecs} seconds`);
-                            }
-                        }
-                        else {
-                            throw new Error(`Failed to register after ${this.config.retryDurationSecs} seconds`);
-                        }
-                    }
-                    // Calculate next delay with exponential backoff
-                    const nextDelayMs = Math.min(delayMs, maxDurationMs - elapsedMs);
-                    logger.info(`Retrying in ${Math.ceil(nextDelayMs / 1000)} seconds...`);
-                    await this.delayFn(nextDelayMs);
-                    // Double the delay for next attempt
-                    delayMs = Math.min(delayMs * 2, maxDurationMs);
-                }
-            }
-        }
-    }
-    async sendToOrchestratorWithRetry(message) {
-        const maxRetries = 5;
-        const initialDelayMs = 1000; // Start with 1 second
-        const maxDelayMs = 60000; // Max 60 seconds
-        const jitterMs = 500; // Add up to 500ms of random jitter
-        let lastError;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                return await this.sendToOrchestrator(message);
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                // Don't retry on certain errors
-                if (lastError.message.includes("HTTP 401") ||
-                    lastError.message.includes("HTTP 403") ||
-                    lastError.message.includes("HTTP 404")) {
-                    throw lastError;
-                }
-                if (attempt < maxRetries) {
-                    // Calculate exponential backoff with jitter
-                    const baseDelay = Math.min(initialDelayMs * Math.pow(2, attempt), maxDelayMs);
-                    const jitter = Math.random() * jitterMs;
-                    const delayMs = baseDelay + jitter;
-                    // Log retry attempt
-                    const errorMessage = lastError.message || String(lastError);
-                    if (message.method === "runner.heartbeat") {
-                        // Less verbose for heartbeat retries
-                        logger.debug(`Heartbeat retry ${attempt + 1}/${maxRetries + 1} in ${Math.round(delayMs)}ms`);
-                    }
-                    else {
-                        logger.warn(`RPC retry ${attempt + 1}/${maxRetries + 1} for '${message.method}' after error: ${errorMessage}. Retrying in ${Math.round(delayMs)}ms`);
-                    }
-                    await this.delayFn(delayMs);
-                }
-            }
-        }
-        // All retries exhausted
-        const finalError = lastError || new Error("Unknown error");
-        if (message.method !== "runner.heartbeat") {
-            logger.error(`RPC failed after ${maxRetries + 1} attempts:`, {
-                method: message.method,
-                error: finalError.message,
-            });
-        }
-        throw finalError;
-    }
-    startHeartbeat() {
-        if (!this.isRegistered || !this.config.runnerId) {
-            logger.warn("Cannot start heartbeat: runner not registered");
-            return;
-        }
-        this.heartbeatInterval = setInterval(async () => {
-            if (this.heartbeatInFlight) {
-                return;
-            }
-            this.heartbeatInFlight = true;
-            try {
-                const response = await this.sendToOrchestrator({
-                    jsonrpc: "2.0",
-                    id: `heartbeat-${Date.now()}`,
-                    method: "runner.heartbeat",
-                    params: {
-                        runnerId: this.config.runnerId,
-                        activeConversations: this.agentConversations.size,
-                        uptime: process.uptime(),
-                        memoryUsage: process.memoryUsage(),
-                    },
-                });
-                // Check for expectedRunnerVersion in heartbeat response
-                if (response?.result?.expectedRunnerVersion) {
-                    await this.checkForUpdate(response.result.expectedRunnerVersion);
-                }
-            }
-            catch (error) {
-                // Heartbeat errors are already logged in sendToOrchestrator
-            }
-            finally {
-                this.heartbeatInFlight = false;
-            }
-        }, this.config.heartbeatInterval);
-    }
-    async stopAllConversations(isRunnerShutdown = true) {
-        const stopPromises = [];
-        for (const [conversationId, context] of this.agentConversations) {
-            if (context.status === "active" || context.status === "starting") {
-                // Active/starting conversations: properly stop them via manager
-                const manager = this.getManagerForContext(context);
-                stopPromises.push(manager
-                    .stopConversation(context.agentSessionId, context, isRunnerShutdown)
-                    .catch((error) => {
-                    logger.error(`Failed to stop conversation ${context.agentSessionId}:`, error);
-                }));
-            }
-            else {
-                // Already stopped/errored conversations: ensure orchestrator is notified
-                // This prevents tasks from restarting on runner restart
-                stopPromises.push(this.notify("conversation.end", {
-                    conversationId: context.conversationId,
-                    conversationObjectType: context.conversationObjectType,
-                    conversationObjectId: context.conversationObjectId,
-                    agentSessionId: context.agentSessionId,
-                    isError: context.status === "error",
-                    reason: "runner_shutdown_cleanup",
-                }).catch((error) => {
-                    logger.error(`Failed to notify conversation.end for ${conversationId}:`, error);
-                }));
-            }
-        }
-        await Promise.all(stopPromises);
-        this.agentConversations.clear();
-    }
-    // Update lastProcessedAt and persist state
-    async updateLastProcessedAt(timestamp) {
-        this.lastProcessedAt = timestamp;
-        if (timestamp) {
-            await this.stateManager.updateLastProcessedAt(timestamp);
-        }
-    }
-    // Getters for components
-    get config_() {
-        return this.config;
-    }
-    get activeConversations_() {
-        return this.agentConversations;
-    }
-    get claudeManager_() {
-        return this.claudeManager;
-    }
-    get codexManager_() {
-        return this.codexManager;
-    }
-    get northflareAgentManager_() {
-        return this.northflareAgentManager;
-    }
-    get repositoryManager_() {
-        return this.repositoryManager;
-    }
-    getConfigPath() {
-        return this.configPath;
-    }
-    getRunnerId() {
-        return this.config.runnerId;
-    }
-    // UID ownership getters/setters
-    getRunnerUid() {
-        return this.runnerUid;
-    }
-    getLastProcessedAt() {
-        return this.lastProcessedAt;
-    }
-    getIsActiveRunner() {
-        return this.isActiveRunner;
-    }
-    setIsActiveRunner(active) {
-        const previousState = this.isActiveRunner;
-        this.isActiveRunner = active;
-        // Persist state change
-        this.stateManager.updateActiveStatus(active).catch((error) => {
-            logger.error("Failed to persist active status:", error);
-        });
-        if (isRunnerDebugEnabled()) {
-            logger.debug("Active runner status changed", {
-                previous: previousState,
-                new: active,
-                runnerUid: this.runnerUid,
-                lastProcessedAt: this.lastProcessedAt?.toISOString() || "null",
-            });
-        }
-    }
-    setLastProcessedAt(timestamp) {
-        const previousTimestamp = this.lastProcessedAt;
-        this.lastProcessedAt = timestamp;
-        if (isRunnerDebugEnabled()) {
-            logger.debug("LastProcessedAt updated", {
-                previous: previousTimestamp?.toISOString() || "null",
-                new: timestamp?.toISOString() || "null",
-                runnerUid: this.runnerUid,
-                isActiveRunner: this.isActiveRunner,
-            });
-        }
-    }
-    getPreHandoffConversations() {
-        return this.preHandoffConversations;
-    }
-    // For testing purposes - allows mocking delays
-    setDelayFunction(fn) {
-        this.delayFn = fn;
-    }
-    getWorkspacePath() {
-        return this.config.workspacePath;
-    }
-    /**
-     * Check if an update is available and trigger update process if needed.
-     * Called by message handler when a message includes expectedRunnerVersion.
-     */
-    async checkForUpdate(serverVersion) {
-        await this.updateCoordinator.checkVersion(serverVersion);
-    }
-    /**
-     * Notify the update coordinator that a conversation has ended.
-     * If there's a pending update and this was the last active conversation,
-     * the update will be triggered.
-     */
-    async onConversationEnd() {
-        await this.updateCoordinator.onConversationEnd();
-    }
-    /**
-     * Check if there's a pending update waiting for conversations to complete.
-     */
-    hasPendingUpdate() {
-        return this.updateCoordinator.hasPendingUpdate;
-    }
-    async replaceRunnerRepos(repos) {
-        this.config.runnerRepos = repos;
-        await this.saveRunnerRepoCache(repos);
-    }
-    async saveRunnerRepoCache(repos) {
-        if (!this.runnerReposCachePath)
-            return;
-        try {
-            await fs.mkdir(path.dirname(this.runnerReposCachePath), { recursive: true });
-            await fs.writeFile(this.runnerReposCachePath, JSON.stringify({ updatedAt: new Date().toISOString(), repos }, null, 2), "utf-8");
-        }
-        catch (err) {
-            logger.warn("Failed to persist runner repo cache", err);
-        }
-    }
-    async loadRunnerRepoCache() {
-        if (!this.runnerReposCachePath)
-            return null;
-        try {
-            const content = await fs.readFile(this.runnerReposCachePath, "utf-8");
-            const parsed = JSON.parse(content);
-            if (Array.isArray(parsed?.repos)) {
-                logger.info(`Loaded ${parsed.repos.length} runner repos from cache at ${this.runnerReposCachePath}`);
-                return parsed.repos;
-            }
-        }
-        catch (err) {
-            if (err?.code !== "ENOENT") {
-                logger.warn("Failed to load runner repo cache", err);
-            }
-        }
-        return null;
-    }
-    isRepoAllowed(repo, workspacePath) {
-        const base = workspacePath || this.config.workspacePath;
-        const resolvedPath = path.resolve(repo.path);
-        const external = repo.external === true || !isSubPath(base, resolvedPath);
-        if (!external && base && !isSubPath(base, resolvedPath)) {
-            return false;
-        }
-        return true;
-    }
-    async prepareRunnerRepos(repos, workspacePath) {
-        const prepared = [];
-        for (const repo of repos || []) {
-            if (!repo?.path || !repo?.name)
-                continue;
-            const resolvedPath = path.resolve(repo.path);
-            const external = repo.external === true || !isSubPath(workspacePath || this.config.workspacePath, resolvedPath);
-            if (!external && workspacePath && !isSubPath(workspacePath, resolvedPath)) {
-                logger.warn(`Ignoring runnerRepo ${repo.name} because path is outside workspace: ${resolvedPath}`);
-                continue;
-            }
-            if (!external && this.config.workspacePath && !isSubPath(this.config.workspacePath, resolvedPath)) {
-                logger.warn(`Ignoring runnerRepo ${repo.name} because path is outside configured workspace: ${resolvedPath}`);
-                continue;
-            }
-            try {
-                await fs.mkdir(resolvedPath, { recursive: true });
-                const stats = await fs.stat(resolvedPath);
-                if (!stats.isDirectory()) {
-                    logger.warn(`RunnerRepo path is not a directory: ${repo.name} at ${resolvedPath}`);
-                    continue;
-                }
-            }
-            catch (err) {
-                logger.warn(`RunnerRepo path could not be prepared: ${repo.name} at ${resolvedPath}`, err);
-                continue;
-            }
-            prepared.push({
-                ...repo,
-                path: resolvedPath,
-                external,
-            });
-        }
-        return prepared;
-    }
-    async refreshRunnerReposFromServer(useCacheOnFailure = true) {
-        const apiClient = new RunnerAPIClient(this.config);
-        if (this.config.runnerId) {
-            apiClient.setRunnerId(this.config.runnerId);
-        }
-        try {
-            const snapshot = await apiClient.listRunnerRepos();
-            const prepared = await this.prepareRunnerRepos(snapshot.repos || [], snapshot.workspacePath);
-            await this.replaceRunnerRepos(prepared);
-            logger.info(`Hydrated runner repos from server snapshot (${prepared.length})`);
-        }
-        catch (err) {
-            logger.error("Failed to fetch runner repo snapshot from server", err);
-            if (useCacheOnFailure) {
-                const cached = await this.loadRunnerRepoCache();
-                if (cached) {
-                    const prepared = await this.prepareRunnerRepos(cached);
-                    await this.replaceRunnerRepos(prepared);
-                    logger.info(`Hydrated runner repos from local cache (${prepared.length}) after snapshot failure`);
-                    return;
-                }
-            }
-            throw err;
-        }
-    }
-    getManagerForContext(context) {
-        const provider = context?.provider?.toLowerCase();
-        if (provider === "openai") {
-            return this.codexManager;
-        }
-        return this.claudeManager;
-    }
-}
-//# sourceMappingURL=runner-sse.js.map