@northflare/runner 0.0.30 → 0.0.32

package/dist/index.d.ts

@@ -1,10 +1,769 @@
+import { Conversation } from '@botanicastudios/claude-code-sdk-ts';
+import { Thread } from '@northflare/codex-sdk';
+
+/**
+ * JSONRPC message types for communication between runner and orchestrator
+ */
+interface JsonRpcMessage {
+    jsonrpc: "2.0";
+    id?: string | number;
+    method?: string;
+    params?: any;
+    result?: any;
+    error?: JsonRpcError;
+}
+interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: any;
+}
+interface RunnerMessage {
+    id: string;
+    direction: "to_runner" | "to_orchestrator";
+    runnerId: string;
+    taskId: string | null;
+    workspaceId: string | null;
+    conversationObjectType?: "Task" | "TaskPlan";
+    conversationObjectId?: string;
+    conversationId?: string;
+    payload: JsonRpcMessage;
+    createdAt: string;
+    expiresAt: string;
+    /** Server's expected runner version. If newer than current, triggers auto-update. */
+    expectedRunnerVersion?: string;
+}
+type MethodHandler = (params: any, message: RunnerMessage) => Promise<void>;
+
+/**
+ * Types related to Claude SDK integration
+ */
+
+interface AgentConversation {
+    send: (payload: {
+        type: string;
+        text?: string;
+        content?: Array<{
+            type: string;
+            text?: string;
+            image?: string;
+        }>;
+    }) => void;
+    end: () => Promise<void> | void;
+}
+interface RepositoryInfo {
+    url: string;
+    branch: string;
+    commit?: string;
+    type?: "github" | "local";
+    localPath?: string;
+}
+interface ConversationConfig {
+    systemPrompt?: string;
+    northflareSystemPrompt?: string;
+    systemPromptMode?: "append" | "replace";
+    accessToken?: string;
+    accessKey?: string;
+    workspaceId?: string;
+    githubToken?: string;
+    taskConcurrent?: boolean;
+    useWorktrees?: boolean;
+    anthropicApiKey?: string;
+    apiKey?: string;
+    openRouterApiKey?: string;
+    groqApiKey?: string;
+    providerType?: string;
+    agentProviderType?: string;
+    mcpServers?: Record<string, any>;
+    repository?: RepositoryInfo;
+    sessionId?: string;
+    runnerRepoPath?: string;
+    codexAuth?: CodexAuthConfig;
+    agent?: string;
+    maxTurns?: number;
+    subAgentTypes?: Record<string, any>;
+}
+interface ConversationContext {
+    conversationId: string;
+    agentSessionId: string;
+    conversationObjectType: "Task" | "TaskPlan" | "ProjectStep";
+    conversationObjectId: string;
+    taskId?: string;
+    workspaceId?: string;
+    status: "starting" | "active" | "stopping" | "stopped" | "error";
+    config: ConversationConfig;
+    startedAt: Date;
+    lastActivityAt: Date;
+    conversation?: Conversation | Thread | AgentConversation;
+    provider?: "claude" | "openai" | "openrouter" | "groq" | string;
+    metadata?: Record<string, any>;
+    summary?: string | null;
+    model: string;
+    globalInstructions: string;
+    workspaceInstructions: string;
+    permissionsMode: string;
+}
+interface CodexAuthConfig {
+    accessToken: string;
+    idToken: string;
+    accountId: string;
+    lastRefresh?: string | null;
+}
+interface Message {
+    content: any;
+    role?: "user" | "assistant";
+}
+
+/**
+ * RepositoryManager - Manages Git repository checkouts and workspace isolation
+ *
+ * This component handles all Git operations for the runner, including:
+ * - Cloning repositories with authentication
+ * - Updating repositories to latest state
+ * - Workspace isolation via separate directories
+ * - Cleanup of old repositories
+ * - Error handling for Git operations
+ */
+
+declare class RepositoryManager {
+    private repositories;
+    protected repoBasePath: string;
+    private runner;
+    private git;
+    constructor(runner: IRunnerApp);
+    checkoutRepository(workspaceId: string, repoUrl: string, branch: string, githubToken?: string): Promise<string>;
+    /**
+     * Checkout a local repository (bypasses Git operations)
+     * Used for local workspaces that point to existing directories on the filesystem
+     */
+    checkoutLocalRepository(workspaceId: string, localRepoPath: string): Promise<string>;
+    getWorkspacePath(workspaceId: string): Promise<string>;
+    private updateRepository;
+    cleanupRepository(workspaceId: string): Promise<void>;
+    cleanupOldRepositories(maxAge?: number): Promise<void>;
+    protected executeGit(args: string[], cwd?: string): Promise<void>;
+    protected getAuthenticatedUrl(repoUrl: string, githubToken?: string): string;
+    protected ensureDirectory(dirPath: string): Promise<void>;
+    protected cleanupDirectory(dirPath: string): Promise<void>;
+    /**
+     * Get statistics about managed repositories
+     */
+    getRepositoryStats(): {
+        total: number;
+        workspaceIds: string[];
+        oldestAccess: Date | null;
+        newestAccess: Date | null;
+    };
+    /**
+     * Check if a workspace has an existing repository
+     */
+    hasRepository(workspaceId: string): boolean;
+    /**
+     * Get repository info for a workspace
+     */
+    getRepository(workspaceId: string): WorkspaceRepository | undefined;
+}
+
+/**
+ * EnhancedRepositoryManager - Advanced Git repository management with worktree support
+ *
+ * This enhanced version builds upon the original RepositoryManager to add:
+ * - Task-level Git isolation through worktrees
+ * - Git operations (stage, commit, push, merge, rebase)
+ * - State persistence and recovery
+ * - Backward compatibility with workspace-based operations
+ *
+ * Directory structure:
+ * /workspace/repos/<owner>__<repo>/
+ *   control/                  # Primary clone (.git directory owner)
+ *     .git/
+ *   worktrees/
+ *     workspace_<workspaceId>/ # Backward compatibility - workspace default branch
+ *     task_<taskId>/          # New - isolated task worktrees
+ *   state.json               # Persistent state mapping
+ */
+
+interface TaskHandle {
+    taskId: string;
+    worktreePath: string;
+    branch: string;
+    baseBranch: string;
+}
+interface RemoveOptions {
+    preserveBranch?: boolean;
+    force?: boolean;
+}
+interface GitAuthor {
+    name: string;
+    email: string;
+}
+interface RebaseResult {
+    success: boolean;
+    conflicts?: string[];
+    error?: string;
+}
+interface MergeResult {
+    success: boolean;
+    conflicts?: string[];
+    mergedCommit?: string;
+    error?: string;
+}
+type MergeMode = "ff-only" | "no-ff" | "squash";
+type TaskIntegrationResult = {
+    success: true;
+    mergedCommit?: string;
+} | {
+    success: false;
+    phase: "rebase" | "merge";
+    conflicts?: string[];
+    error?: string;
+    conflictWorkdir: string;
+};
+interface TaskGitState {
+    taskId: string;
+    workspaceId?: string;
+    branch: string;
+    baseBranch: string;
+    lastCommit?: string;
+    commitCount?: number;
+    worktreePath: string;
+    status: "active" | "conflicted" | "merged" | "abandoned";
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare class EnhancedRepositoryManager extends RepositoryManager {
+    private repoStates;
+    private stateFilePath;
+    private legacyStateFilePath;
+    private repoLocks;
+    private taskWorktreesBasePath;
+    constructor(runner: IRunnerApp);
+    /**
+     * Get repository key from owner and repo name
+     */
+    private getRepoKey;
+    private parseRepoKey;
+    private findTaskStateEntry;
+    private withRepoLock;
+    /**
+     * Ensure control repository exists
+     */
+    private ensureControlRepository;
+    /**
+     * Create a task-specific worktree for local workspaces
+     */
+    createLocalTaskHandle(taskId: string, localPath: string): Promise<TaskHandle>;
+    /**
+     * Create a task-specific worktree
+     */
+    createTaskWorktree(taskId: string, workspaceId: string, repoUrl: string, baseBranch?: string, githubToken?: string): Promise<TaskHandle>;
+    private ensureInitialCommitOnBranch;
+    /**
+     * Remove a task worktree
+     */
+    removeTaskWorktree(taskId: string, options?: RemoveOptions): Promise<void>;
+    /**
+     * Stage all changes in a task worktree
+     */
+    stageAll(taskId: string): Promise<void>;
+    /**
+     * Commit changes in a task worktree
+     */
+    commit(taskId: string, message: string, author?: GitAuthor): Promise<string>;
+    /**
+     * Create a new branch for a task
+     */
+    createBranch(taskId: string, branchName: string): Promise<void>;
+    /**
+     * Rebase a task branch onto target branch
+     */
+    rebaseTask(taskId: string, targetBranch: string): Promise<RebaseResult>;
+    /**
+     * Merge a task branch into target branch
+     */
+    mergeTask(taskId: string, targetBranch: string, mode?: MergeMode): Promise<MergeResult>;
+    private mergeTaskUnlocked;
+    getTaskRepoInfo(taskId: string): Promise<{
+        repoKey: string;
+        controlPath: string;
+        worktreePath: string;
+        branch: string;
+        baseBranch: string;
+    } | null>;
+    /**
+     * Fast-forward (or hard reset) the shared workspace worktree to a branch tip after a task merge.
+     * This keeps the "workspace" checkout in sync with concurrent task integrations.
+     *
+     * We only update existing workspace worktrees and only when they're clean to avoid
+     * clobbering any active non-concurrent task that might be using the workspace checkout.
+     */
+    syncWorkspaceWorktree(workspaceId: string, repoUrl: string, branch: string): Promise<void>;
+    isTaskBranchMerged(taskId: string, targetBranch: string): Promise<boolean>;
+    pushBranch(taskId: string, branch: string): Promise<void>;
+    integrateTask(taskId: string, targetBranch: string, mode?: MergeMode): Promise<TaskIntegrationResult>;
+    /**
+     * Get task Git state
+     */
+    getTaskState(taskId: string): Promise<TaskGitState | null>;
+    /**
+     * Update task state
+     */
+    private updateTaskState;
+    /**
+     * Update task state by task ID
+     */
+    private updateTaskStateByTaskId;
+    /**
+     * Persist state to disk
+     */
+    persistState(): Promise<void>;
+    /**
+     * Restore state from disk
+     */
+    restoreState(): Promise<void>;
+    private migrateLegacyStateFileIfNeeded;
+    /**
+     * Override parent's checkoutRepository to use worktrees for backward compatibility
+     */
+    checkoutRepository(workspaceId: string, repoUrl: string, branch: string, githubToken?: string): Promise<string>;
+}
+
+/**
+ * ClaudeManager - Manages Claude conversations using SDK-native patterns
+ *
+ * This component handles stateful conversation lifecycle management, maintaining
+ * persistent conversation instances indexed by taskId. Uses the SDK's native
+ * capabilities including the builder pattern, native session management, and
+ * built-in streaming instead of custom wrappers.
+ *
+ * Key improvements:
+ * - Uses claude() builder pattern for simplified configuration
+ * - Native session management with withSessionId()
+ * - Direct AsyncGenerator streaming without custom wrappers
+ * - SDK's onProcessComplete() for proper cleanup
+ * - Simplified error handling while maintaining compatibility
+ */
+
+declare class ClaudeManager {
+    private runner;
+    private repositoryManager;
+    constructor(runner: IRunnerApp, repositoryManager: EnhancedRepositoryManager);
+    private setupInternalMcpServer;
+    startConversation(conversationObjectType: "Task" | "TaskPlan" | "ProjectStep", conversationObjectId: string, config: ConversationConfig, initialMessages: Message[], conversationData?: {
+        id: string;
+        objectType: string;
+        objectId: string;
+        model: string;
+        summary?: string | null;
+        globalInstructions: string;
+        workspaceInstructions: string;
+        permissionsMode: string;
+        agentSessionId: string;
+        systemPrompt?: string;
+        northflareSystemPrompt?: string;
+        systemPromptMode?: "append" | "replace";
+    }): Promise<ConversationContext>;
+    private getInstructionPrefix;
+    private _handleRunCompletion;
+    private _resumeForGitConflictResolution;
+    stopConversation(agentSessionId: string, context: ConversationContext, isRunnerShutdown?: boolean, reason?: string): Promise<void>;
+    resumeConversation(conversationObjectType: "Task" | "TaskPlan" | "ProjectStep", conversationObjectId: string, agentSessionId: string, config: ConversationConfig, conversationData?: any, resumeMessage?: string): Promise<string>;
+    private _finalizeConversation;
+    sendUserMessage(conversationId: string, content: any, config?: ConversationConfig, conversationObjectType?: "Task" | "TaskPlan" | "ProjectStep", conversationObjectId?: string, conversation?: any, _agentSessionIdOverride?: string): Promise<void>;
+    private fetchGithubTokens;
+    private _handleConversationError;
+    private classifyError;
+    /**
+     * Normalize arbitrary content shapes into a plain string for the CLI
+     */
+    private normalizeToText;
+    /**
+     * Normalize arbitrary content shapes into content blocks array for multimodal support.
+     * Returns the array of content blocks if the content contains image or document blocks,
+     * otherwise returns null to indicate text-only content.
+     */
+    private normalizeToContentBlocks;
+    private handleStreamedMessage;
+}
+
+type ConversationDetails = {
+    id: string;
+    objectType: string;
+    objectId: string;
+    model: string;
+    summary?: string | null;
+    globalInstructions: string;
+    workspaceInstructions: string;
+    permissionsMode: string;
+    agentSessionId?: string;
+    workspaceId?: string;
+    threadId?: string;
+    systemPrompt?: string;
+    northflareSystemPrompt?: string;
+    systemPromptMode?: "append" | "replace";
+};
+declare class CodexManager {
+    private runner;
+    private repositoryManager;
+    private threadStates;
+    constructor(runner: IRunnerApp, repositoryManager: EnhancedRepositoryManager);
+    startConversation(conversationObjectType: "Task" | "TaskPlan" | "ProjectStep", conversationObjectId: string, config: ConversationConfig, initialMessages: Message[], conversationData?: ConversationDetails, provider?: "openai" | "openrouter" | "groq"): Promise<ConversationContext>;
+    stopConversation(_agentSessionId: string, context: ConversationContext, isRunnerShutdown?: boolean, reason?: string): Promise<void>;
+    resumeConversation(conversationObjectType: "Task" | "TaskPlan" | "ProjectStep", conversationObjectId: string, agentSessionId: string, config: ConversationConfig, conversationData?: ConversationDetails, resumeMessage?: string, provider?: "openai" | "openrouter" | "groq"): Promise<string>;
+    sendUserMessage(conversationId: string, content: any, config?: ConversationConfig, conversationObjectType?: "Task" | "TaskPlan" | "ProjectStep", conversationObjectId?: string, conversation?: any, agentSessionIdOverride?: string, provider?: "openai" | "openrouter" | "groq"): Promise<void>;
+    private _handleRunCompletion;
+    private _resumeForGitConflictResolution;
+    private buildEnvVars;
+    private ensureCodexAuthHome;
+    private buildPromptForMessage;
+    private getInstructionPrefix;
+    private formatInitialMessages;
+    private buildInitialInput;
+    private launchTurn;
+    private streamThreadEvents;
+    private abortActiveRun;
+    private handleThreadEvent;
+    private forwardItemEvent;
+    private normalizeItemEvent;
+    private sendAgentMessage;
+    private handleThreadStarted;
+    private mapSandboxMode;
+    private shouldEnableNetwork;
+    private getAdditionalDirectories;
+    private buildConfigOverridesFromMcp;
+    /**
+     * Build Codex config overrides for OpenRouter provider.
+     * These correspond to the Codex CLI flags:
+     *   -c model_provider=openrouter
+     *   -c model_providers.openrouter.name=openrouter
+     *   -c model_providers.openrouter.base_url=https://openrouter.ai/api/v1
+     *   -c model_providers.openrouter.env_key=OPENROUTER_API_KEY
+     */
+    private buildOpenRouterConfigOverrides;
+    private normalizeMcpServersForCodex;
+    private buildMcpToolName;
+    private logRawThreadEvent;
+    private safeStringify;
+    private buildToolUseId;
+    private stripAuthorizationHeader;
+    private flattenOverrideObject;
+    private resolveWorkspacePath;
+    private fetchGithubTokens;
+    private generateToolToken;
+    /**
+     * Detect whether incoming content contains multimodal blocks (image/document).
+     */
+    private hasMultimodalContent;
+    /**
+     * Normalize incoming content into the Codex SDK Input shape.
+     * - Text-only -> single string (lets SDK do fast path)
+     * - Multimodal -> [{ text }, ...{ local_image }]
+     */
+    private normalizeToInput;
+    /**
+     * Download an image (http(s) or data URL) to a temp file and return the path.
+     */
+    private downloadImageToTemp;
+    private writeBufferToTemp;
+    private inferExtensionFromUrl;
+    private mimeToExtension;
+    private normalizeToText;
+    private normalizeSessionId;
+    private resolveSessionId;
+    private isAbortError;
+    private _finalizeConversation;
+    private _handleConversationError;
+    private generateMessageId;
+}
+
+/**
+ * NorthflareAgentManager - Manages conversations using the @northflare/agent SDK
+ *
+ * Mirrors the existing Claude integration but targets OpenRouter-style models
+ * via the Northflare Agent SDK. Lifecycle, repository handling, and message
+ * normalization stay aligned with the existing managers so downstream
+ * interfaces remain compatible.
+ */
+
+declare class NorthflareAgentManager {
+    private runner;
+    private repositoryManager;
+    private submitToolUseIds;
+    constructor(runner: IRunnerApp, repositoryManager: EnhancedRepositoryManager);
+    private setupInternalMcpServer;
+    private buildSubAgentConfig;
+    startConversation(conversationObjectType: "Task" | "TaskPlan" | "ProjectStep", conversationObjectId: string, config: ConversationConfig, initialMessages: Message[], conversationData?: {
+        id: string;
+        objectType: string;
+        objectId: string;
+        model: string;
+        summary?: string | null;
+        globalInstructions: string;
+        workspaceInstructions: string;
+        permissionsMode: string;
+        agentSessionId: string;
+        systemPrompt?: string;
+        northflareSystemPrompt?: string;
+        systemPromptMode?: "append" | "replace";
+    }, provider?: "openrouter" | "groq"): Promise<ConversationContext>;
+    stopConversation(agentSessionId: string, context: ConversationContext, isRunnerShutdown?: boolean, reason?: string): Promise<void>;
+    resumeConversation(conversationObjectType: "Task" | "TaskPlan" | "ProjectStep", conversationObjectId: string, agentSessionId: string, config: ConversationConfig, conversationData?: any, resumeMessage?: string, provider?: "openrouter" | "groq"): Promise<string>;
+    private _handleRunCompletion;
+    private _resumeForGitConflictResolution;
+    private _finalizeConversation;
+    sendUserMessage(conversationId: string, content: any, config?: ConversationConfig, conversationObjectType?: "Task" | "TaskPlan" | "ProjectStep", conversationObjectId?: string, conversation?: any, _agentSessionIdOverride?: string): Promise<void>;
+    private fetchGithubTokens;
+    private _handleConversationError;
+    private classifyError;
+    private normalizeModel;
+    /**
+     * Check if content contains multimodal blocks (images or documents)
+     */
+    private hasMultimodalContent;
+    /**
+     * Normalize content for the SDK, preserving multimodal blocks when present.
+     * Returns either a string (text-only) or an array of content blocks (multimodal).
+     */
+    private normalizeContentForSDK;
+    /**
+     * Normalize arbitrary content shapes into a plain string for the CLI
+     */
+    private normalizeToText;
+    private handleStreamedMessage;
+}
+
+/**
+ * Interface for RunnerApp to ensure compatibility between different implementations
+ */
+
+interface IRunnerApp {
+    notify(method: string, params: any): Promise<void>;
+    sendToOrchestrator(message: JsonRpcMessage): Promise<any>;
+    getConversationContext(conversationId: string): ConversationContext | undefined;
+    applyConversationSummary(conversationId: string, summary: string | null): void;
+    consumePendingConversationSummary(conversationId: string): string | undefined;
+    wasConversationCompleted(conversationId: string): boolean;
+    markConversationCompleted(conversationId: string): void;
+    get config_(): RunnerConfig;
+    get activeConversations_(): Map<string, ConversationContext>;
+    get claudeManager_(): ClaudeManager;
+    get codexManager_(): CodexManager;
+    get northflareAgentManager_(): NorthflareAgentManager;
+    get repositoryManager_(): EnhancedRepositoryManager;
+    getConfigPath?(): string | undefined;
+    getWorkspacePath?(): string | undefined;
+    getRunnerId(): string | undefined;
+    getRunnerUid(): string | null;
+    getLastProcessedAt(): Date | null;
+    getIsActiveRunner(): boolean;
+    setIsActiveRunner(active: boolean): void;
+    setLastProcessedAt(timestamp: Date | null): void;
+    getPreHandoffConversations(): Set<string>;
+    updateLastProcessedAt?(timestamp: Date | null): Promise<void>;
+    replaceRunnerRepos?(repos: RunnerRepo[]): Promise<void>;
+    checkForUpdate(serverVersion: string): Promise<void>;
+    onConversationEnd(): Promise<void>;
+    hasPendingUpdate(): boolean;
+}
+
+/**
+ * Main type definitions for the runner app
+ */
+
+type RetryStrategy = "none" | "interval" | "exponential";
+interface RunnerRepo {
+    uuid?: string;
+    name: string;
+    path: string;
+    external?: boolean;
+}
+interface RunnerConfig {
+    runnerId?: string;
+    orchestratorUrl: string;
+    dataDir: string;
+    workspacePath?: string;
+    heartbeatInterval: number;
+    retryStrategy: RetryStrategy;
+    retryIntervalSecs: number;
+    retryDurationSecs: number;
+    runnerRepos?: RunnerRepo[];
+    inactivityTimeoutMs?: number;
+    inactivityTimeoutDisplay?: string;
+}
+interface RunnerConfigFile {
+    orchestratorUrl?: string;
+    dataDir?: string;
+    workspacePath?: string;
+    workspaceDir?: string;
+    heartbeatInterval?: number;
+    retryStrategy?: RetryStrategy;
+    retryIntervalSecs?: number;
+    retryDurationSecs?: number;
+    runnerRepos?: Record<string, RunnerRepo[]>;
+}
+interface WorkspaceRepository {
+    workspaceId: string;
+    repoUrl: string;
+    branch: string;
+    localPath: string;
+    lastAccessed: Date;
+}
+interface EnvironmentConfig {
+    NORTHFLARE_RUNNER_TOKEN: string;
+    NORTHFLARE_WORKSPACE_PATH?: string;
+    NORTHFLARE_ORCHESTRATOR_URL: string;
+    NORTHFLARE_RUNNER_DEBUG?: string;
+    DEBUG?: string;
+}
+
+/**
+ * Main RunnerApp class - entry point and lifecycle manager for the runner app
+ * Updated to use SSE for real-time messaging instead of ElectricSQL
+ */
+
+declare class RunnerApp implements IRunnerApp {
+    private messageHandler;
+    private claudeManager;
+    private codexManager;
+    private northflareAgentManager;
+    private repositoryManager;
+    private stateManager;
+    private updateCoordinator;
+    private agentConversations;
+    private config;
+    private configPath?;
+    private runnerReposCachePath?;
+    private heartbeatInterval?;
+    private heartbeatInFlight;
+    private isRunning;
+    private isRegistered;
+    private delayFn;
+    private runnerUid;
+    private lastProcessedAt;
+    private isActiveRunner;
+    private preHandoffConversations;
+    private completedConversations;
+    private static readonly COMPLETED_CONVERSATION_TTL_MS;
+    private pendingConversationSummaries;
+    constructor(config: RunnerConfig, configPath?: string);
+    private fetchRunnerId;
+    private initializeComponents;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    notify(method: string, params: any): Promise<void>;
+    sendToOrchestrator(message: JsonRpcMessage): Promise<any>;
+    getConversationContext(conversationId: string): ConversationContext | undefined;
+    applyConversationSummary(conversationId: string, summary: string | null): void;
+    consumePendingConversationSummary(conversationId: string): string | undefined;
+    /**
+     * Check if a conversation was recently completed (to prevent restart on catch-up)
+     */
+    wasConversationCompleted(conversationId: string): boolean;
+    /**
+     * Mark a conversation as completed to prevent restart on catch-up
+     */
+    markConversationCompleted(conversationId: string): void;
+    /**
+     * Clean up expired completed conversation entries
+     */
+    private cleanupCompletedConversations;
+    private registerRunner;
+    private registerWithRetry;
+    private sendToOrchestratorWithRetry;
+    private startHeartbeat;
+    private stopAllConversations;
+    updateLastProcessedAt(timestamp: Date | null): Promise<void>;
+    get config_(): RunnerConfig;
+    get activeConversations_(): Map<string, ConversationContext>;
+    get claudeManager_(): ClaudeManager;
+    get codexManager_(): CodexManager;
+    get northflareAgentManager_(): NorthflareAgentManager;
+    get repositoryManager_(): EnhancedRepositoryManager;
+    getConfigPath(): string | undefined;
+    getRunnerId(): string | undefined;
+    getRunnerUid(): string | null;
+    getLastProcessedAt(): Date | null;
+    getIsActiveRunner(): boolean;
+    setIsActiveRunner(active: boolean): void;
+    setLastProcessedAt(timestamp: Date | null): void;
+    getPreHandoffConversations(): Set<string>;
+    setDelayFunction(fn: (ms: number) => Promise<void>): void;
+    getWorkspacePath(): string | undefined;
+    /**
+     * Check if an update is available and trigger update process if needed.
+     * Called by message handler when a message includes expectedRunnerVersion.
+     */
+    checkForUpdate(serverVersion: string): Promise<void>;
+    /**
+     * 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.
+     */
+    onConversationEnd(): Promise<void>;
+    /**
+     * Check if there's a pending update waiting for conversations to complete.
+     */
+    hasPendingUpdate(): boolean;
+    replaceRunnerRepos(repos: RunnerRepo[]): Promise<void>;
+    private saveRunnerRepoCache;
+    private loadRunnerRepoCache;
+    private isRepoAllowed;
+    private prepareRunnerRepos;
+    private refreshRunnerReposFromServer;
+    private getManagerForContext;
+}
+
+/**
+ * Configuration management utilities
+ */
+
+declare class ConfigManager {
+    private static DEFAULT_CONFIG;
+    private static resolveDefaultDataDir;
+    private static getDefaultConfigPath;
+    /**
+     * Load configuration without parsing command line arguments
+     * Used when arguments have already been parsed by the CLI
+     */
+    static loadConfig(configPath?: string, options?: {
+        promptForWorkspacePath?: boolean;
+    }): Promise<RunnerConfig>;
+    /**
+     * Parse command line arguments and load configuration
+     */
+    static parseArgsAndLoadConfig(argv: string[]): Promise<RunnerConfig>;
+    /**
+     * Validate required environment variables
+     */
+    private static validateEnvironment;
+    /**
+     * Load configuration from environment variables
+     */
+    private static loadFromEnvironment;
+    /**
+     * Load configuration from file
+     */
+    private static loadConfigFile;
+    private static promptForWorkspacePath;
+    private static normalizeWorkspacePath;
+    private static persistConfigFile;
+    /**
+     * Validate final configuration
+     */
+    private static validateConfig;
+    /**
+     * Get all environment configuration
+     */
+    static getEnvironmentConfig(): EnvironmentConfig;
+    /**
+     * Save configuration file with updated data
+     */
+    static saveConfigFile(configPath: string, config: any): Promise<void>;
+}
+
 /**
  * Main entry point for the Northflare Runner App
  */
 declare let isShuttingDown: boolean;
 declare function main(): Promise<void>;
-export { RunnerApp } from './runner-sse.js';
-export { ConfigManager } from './utils/config.js';
-export * from './types/index.js';
-export { main, isShuttingDown };
-//# sourceMappingURL=index.d.ts.map
+
+export { type AgentConversation, type CodexAuthConfig, ConfigManager, type ConversationConfig, type ConversationContext, type EnvironmentConfig, type IRunnerApp, type JsonRpcError, type JsonRpcMessage, type Message, type MethodHandler, type RepositoryInfo, type RetryStrategy, RunnerApp, type RunnerConfig, type RunnerConfigFile, type RunnerMessage, type RunnerRepo, type WorkspaceRepository, isShuttingDown, main };