@northflare/runner 0.0.8 → 0.0.10

package/dist/components/codex-sdk-manager.js

@@ -0,0 +1,988 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexManager = void 0;
+const status_line_1 = require("../utils/status-line");
+const console_1 = require("../utils/console");
+const expand_env_1 = require("../utils/expand-env");
+const model_1 = require("../utils/model");
+const jwt = __importStar(require("jsonwebtoken"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const debug_1 = require("../utils/debug");
+let codexSdkPromise = null;
+// Use runtime dynamic import so the CommonJS build can load the ESM-only SDK.
+const dynamicImport = new Function("specifier", "return import(specifier);");
+async function loadCodexSdk() {
+    if (!codexSdkPromise) {
+        codexSdkPromise = dynamicImport("@northflare/codex-sdk");
+    }
+    return codexSdkPromise;
+}
+class CodexManager {
+    runner;
+    repositoryManager;
+    threadStates = new Map();
+    constructor(runner, repositoryManager) {
+        this.runner = runner;
+        this.repositoryManager = repositoryManager;
+    }
+    async startConversation(conversationObjectType, conversationObjectId, config, initialMessages, conversationData) {
+        if (!conversationData?.id) {
+            throw new Error("startConversation requires conversationData with a valid conversation.id");
+        }
+        const conversationId = conversationData.id;
+        const agentSessionId = this.resolveSessionId(config, conversationData);
+        const rawModel = conversationData?.model ||
+            config?.model ||
+            config?.defaultModel ||
+            "openai";
+        const { baseModel, reasoningEffort } = (0, model_1.parseModelValue)(rawModel);
+        const normalizedModel = baseModel || rawModel;
+        const metadata = {
+            instructionsInjected: false,
+            originalModelValue: rawModel,
+        };
+        if (reasoningEffort) {
+            metadata["modelReasoningEffort"] = reasoningEffort;
+        }
+        const context = {
+            conversationId,
+            agentSessionId,
+            conversationObjectType,
+            conversationObjectId,
+            taskId: conversationObjectType === "Task" ? conversationObjectId : undefined,
+            workspaceId: config.workspaceId,
+            status: "starting",
+            config,
+            startedAt: new Date(),
+            lastActivityAt: new Date(),
+            model: normalizedModel,
+            globalInstructions: conversationData.globalInstructions || "",
+            workspaceInstructions: conversationData.workspaceInstructions || "",
+            permissionsMode: conversationData.permissionsMode ||
+                config?.permissionsMode ||
+                "all",
+            provider: "openai",
+            metadata,
+        };
+        this.runner.activeConversations_.set(conversationId, context);
+        console_1.console.log(`[CodexManager] Stored conversation context`, {
+            conversationId,
+            agentSessionId,
+            model: context.model,
+            permissionsMode: context.permissionsMode,
+        });
+        const workspacePath = await this.resolveWorkspacePath(context, config);
+        context.metadata["workspacePath"] = workspacePath;
+        const githubToken = context.workspaceId
+            ? await this.fetchGithubTokens(context.workspaceId)
+            : undefined;
+        const toolToken = this.generateToolToken(context);
+        let mcpServers;
+        if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
+            const expandedServers = (0, expand_env_1.expandEnv)(config.mcpServers, {
+                TOOL_TOKEN: toolToken,
+            });
+            mcpServers = this.normalizeMcpServersForCodex(expandedServers);
+            console_1.console.log("[CodexManager] MCP servers configuration:", JSON.stringify(mcpServers, null, 2));
+            context.metadata["mcpServers"] = mcpServers;
+        }
+        const configOverrides = this.buildConfigOverridesFromMcp(mcpServers);
+        const envVars = await this.buildEnvVars(config, githubToken, toolToken);
+        const { Codex } = await loadCodexSdk();
+        const codex = new Codex({
+            baseUrl: config?.openaiBaseUrl ||
+                config?.codexBaseUrl ||
+                process.env["OPENAI_BASE_URL"],
+            apiKey: config?.openaiApiKey ||
+                config?.codexApiKey ||
+                process.env["CODEX_API_KEY"] ||
+                process.env["OPENAI_API_KEY"],
+            env: envVars,
+        });
+        const threadOptions = {
+            model: context.model,
+            workingDirectory: workspacePath,
+            sandboxMode: this.mapSandboxMode(context.permissionsMode),
+            networkAccessEnabled: this.shouldEnableNetwork(context.permissionsMode),
+            webSearchEnabled: true,
+            // additionalDirectories: this.getAdditionalDirectories(config),
+            configOverrides,
+            skipGitRepoCheck: true,
+            modelReasoningEffort: reasoningEffort,
+        };
+        console_1.console.log("[CodexManager] Thread options:", JSON.stringify(threadOptions, null, 2));
+        const thread = agentSessionId
+            ? codex.resumeThread(agentSessionId, threadOptions)
+            : codex.startThread(threadOptions);
+        this.threadStates.set(conversationId, {
+            thread,
+            abortController: null,
+            runPromise: null,
+        });
+        context.conversation = thread;
+        // Send initial messages sequentially without waiting for completion
+        if (initialMessages?.length) {
+            for (const message of initialMessages) {
+                const text = this.normalizeToText(message.content);
+                const prompt = this.buildPromptForMessage(context, text, true);
+                this.launchTurn(context, prompt);
+            }
+        }
+        return context;
+    }
+    async stopConversation(_agentSessionId, context, isRunnerShutdown = false, reason) {
+        context.status = "stopping";
+        await this.abortActiveRun(context.conversationId);
+        try {
+            await this._finalizeConversation(context, false, undefined, reason || (isRunnerShutdown ? "runner_shutdown" : undefined));
+        }
+        catch (error) {
+            console_1.console.error(`[CodexManager] Error finalizing conversation ${context.conversationId}:`, error);
+        }
+        finally {
+            this.threadStates.delete(context.conversationId);
+        }
+        context.status = "stopped";
+    }
+    async resumeConversation(conversationObjectType, conversationObjectId, agentSessionId, config, conversationData, resumeMessage) {
+        console_1.console.log(`[CodexManager] Resuming conversation ${agentSessionId}`);
+        const context = await this.startConversation(conversationObjectType, conversationObjectId, { ...config, sessionId: agentSessionId }, [], conversationData);
+        if (resumeMessage) {
+            const prompt = this.buildPromptForMessage(context, resumeMessage, false);
+            this.launchTurn(context, prompt);
+        }
+        return context.agentSessionId;
+    }
+    async sendUserMessage(conversationId, content, config, conversationObjectType, conversationObjectId, conversation, agentSessionIdOverride) {
+        console_1.console.log(`[CodexManager] sendUserMessage called`, {
+            conversationId,
+            hasConfig: !!config,
+        });
+        let context = this.runner.getConversationContext(conversationId);
+        if (!context && conversation) {
+            const conversationDetails = conversation;
+            const resumeSessionId = this.resolveSessionId(config, conversationDetails, agentSessionIdOverride);
+            const startConfig = {
+                ...(config || {}),
+                workspaceId: conversationDetails.workspaceId || config?.workspaceId || undefined,
+                ...(resumeSessionId ? { sessionId: resumeSessionId } : {}),
+            };
+            context = await this.startConversation(conversationObjectType ||
+                conversationDetails.objectType, conversationObjectId || conversationDetails.objectId, startConfig, [], conversationDetails);
+        }
+        if (!context) {
+            throw new Error(`No active or fetchable conversation found for ${conversationId}`);
+        }
+        await this.abortActiveRun(conversationId);
+        const messageText = this.normalizeToText(content);
+        const prompt = this.buildPromptForMessage(context, messageText, false);
+        this.launchTurn(context, prompt);
+        context.lastActivityAt = new Date();
+    }
+    async buildEnvVars(config, githubToken, toolToken) {
+        const envVars = {
+            ...Object.fromEntries(Object.entries(process.env).filter(([, value]) => value !== undefined)),
+        };
+        if (config.codexAuth?.accessToken) {
+            envVars["OPENAI_ACCESS_TOKEN"] = config.codexAuth.accessToken;
+        }
+        else if (config.accessToken) {
+            envVars["OPENAI_ACCESS_TOKEN"] = config.accessToken;
+        }
+        if (githubToken) {
+            envVars["GITHUB_TOKEN"] = githubToken;
+        }
+        if (toolToken) {
+            envVars["TOOL_TOKEN"] = toolToken;
+        }
+        if ((0, debug_1.isRunnerDebugEnabled)()) {
+            envVars["DEBUG"] = "1";
+        }
+        const codexHome = await this.ensureCodexAuthHome(config);
+        if (codexHome) {
+            envVars["CODEX_HOME"] = codexHome;
+        }
+        return envVars;
+    }
+    async ensureCodexAuthHome(config) {
+        if (!config.codexAuth) {
+            return null;
+        }
+        const runnerId = this.runner.getRunnerId();
+        const dataDir = this.runner.config_.dataDir;
+        if (!runnerId || !dataDir) {
+            console_1.console.warn("[CodexManager] Missing runnerId or dataDir; cannot prepare Codex auth directory");
+            return null;
+        }
+        const codexDir = path_1.default.join(dataDir, "codex", runnerId);
+        const authPayload = {
+            OPENAI_API_KEY: null,
+            tokens: {
+                id_token: config.codexAuth.idToken,
+                access_token: config.codexAuth.accessToken,
+                refresh_token: "",
+                account_id: config.codexAuth.accountId,
+            },
+            last_refresh: config.codexAuth.lastRefresh || new Date().toISOString(),
+        };
+        try {
+            await promises_1.default.mkdir(codexDir, { recursive: true });
+            await promises_1.default.writeFile(path_1.default.join(codexDir, "auth.json"), JSON.stringify(authPayload, null, 2), "utf-8");
+            return codexDir;
+        }
+        catch (error) {
+            console_1.console.error("[CodexManager] Failed to persist Codex auth configuration:", error);
+            throw new Error("Runner failed to persist Codex credentials. Check runner logs for details.");
+        }
+    }
+    buildPromptForMessage(context, text, forceInstructions) {
+        const trimmed = text ?? "";
+        const instructions = this.getInstructionPrefix(context);
+        const metadata = context.metadata || {};
+        const shouldInjectInstructions = forceInstructions || !metadata["instructionsInjected"];
+        if (instructions && shouldInjectInstructions) {
+            metadata["instructionsInjected"] = true;
+            context.metadata = metadata;
+            return `${instructions}\n\n${trimmed}`.trim();
+        }
+        return trimmed;
+    }
+    getInstructionPrefix(context) {
+        const parts = [];
+        if (context.globalInstructions) {
+            parts.push(`<global-instructions>\n${context.globalInstructions}\n</global-instructions>`);
+        }
+        if (context.workspaceInstructions) {
+            parts.push(`<workspace-instructions>\n${context.workspaceInstructions}\n</workspace-instructions>`);
+        }
+        return parts.join("\n\n");
+    }
+    launchTurn(context, prompt) {
+        const state = this.threadStates.get(context.conversationId);
+        if (!state || !state.thread) {
+            throw new Error(`Thread state missing for conversation ${context.conversationId}`);
+        }
+        const abortController = new AbortController();
+        state.abortController = abortController;
+        context.lastActivityAt = new Date();
+        const runPromise = this.streamThreadEvents(context, state.thread, prompt, abortController);
+        state.runPromise = runPromise;
+        runPromise
+            .catch((error) => {
+            if (!this.isAbortError(error)) {
+                console_1.console.error(`[CodexManager] Run failed for ${context.conversationId}:`, error);
+                this._handleConversationError(context, error);
+            }
+        })
+            .finally(() => {
+            if (state.runPromise === runPromise) {
+                state.runPromise = null;
+            }
+            if (state.abortController === abortController) {
+                state.abortController = null;
+            }
+        });
+    }
+    async streamThreadEvents(context, thread, prompt, abortController) {
+        try {
+            const { events } = await thread.runStreamed(prompt, {
+                signal: abortController.signal,
+            });
+            for await (const event of events) {
+                await this.handleThreadEvent(context, event);
+            }
+        }
+        catch (error) {
+            if (this.isAbortError(error)) {
+                console_1.console.log(`[CodexManager] Turn aborted for ${context.conversationId}`);
+                return;
+            }
+            throw error;
+        }
+    }
+    async abortActiveRun(conversationId) {
+        const state = this.threadStates.get(conversationId);
+        if (!state || !state.runPromise)
+            return;
+        if (state.abortController) {
+            state.abortController.abort();
+        }
+        try {
+            await state.runPromise;
+        }
+        catch (error) {
+            if (!this.isAbortError(error)) {
+                console_1.console.warn(`[CodexManager] Run aborted with error for ${conversationId}:`, error);
+            }
+        }
+    }
+    async handleThreadEvent(context, event) {
+        try {
+            this.logRawThreadEvent(event);
+            switch (event.type) {
+                case "thread.started": {
+                    await this.handleThreadStarted(context, event.thread_id);
+                    break;
+                }
+                case "turn.started": {
+                    context.status = "active";
+                    await this.sendAgentMessage(context, "system", {
+                        subtype: "turn.started",
+                        content: [
+                            {
+                                type: "text",
+                                text: `Turn started at ${new Date().toISOString()}`,
+                            },
+                        ],
+                    });
+                    break;
+                }
+                case "turn.completed": {
+                    await this.sendAgentMessage(context, "result", {
+                        subtype: "turn.completed",
+                        content: [
+                            {
+                                type: "usage",
+                                usage: event.usage,
+                            },
+                        ],
+                    });
+                    context.status = "stopped";
+                    await this._finalizeConversation(context, false);
+                    break;
+                }
+                case "turn.failed": {
+                    const error = new Error(event.error?.message || "Turn failed");
+                    await this.sendAgentMessage(context, "error", {
+                        subtype: "turn.failed",
+                        content: [
+                            {
+                                type: "text",
+                                text: error.message,
+                            },
+                        ],
+                        isError: true,
+                    });
+                    await this._handleConversationError(context, error);
+                    context.status = "stopped";
+                    await this._finalizeConversation(context, true, error, "turn_failed");
+                    break;
+                }
+                case "item.started":
+                case "item.updated":
+                case "item.completed": {
+                    await this.forwardItemEvent(context, event.item, event.type.split(".")[1]);
+                    break;
+                }
+                case "error": {
+                    const fatalError = new Error(event.message || "Unknown error");
+                    await this.sendAgentMessage(context, "error", {
+                        subtype: "thread.error",
+                        content: [{ type: "text", text: fatalError.message }],
+                        isError: true,
+                    });
+                    await this._handleConversationError(context, fatalError);
+                    context.status = "stopped";
+                    await this._finalizeConversation(context, true, fatalError, "thread_error");
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            console_1.console.error("[CodexManager] Failed to handle thread event", {
+                event,
+                error,
+            });
+        }
+    }
+    async forwardItemEvent(context, item, phase) {
+        const normalized = this.normalizeItemEvent(context, item, phase);
+        if (!normalized)
+            return;
+        const { subtype, content, isError, toolCalls, type } = normalized;
+        const payload = {
+            subtype,
+            content,
+            isError,
+        };
+        if (toolCalls) {
+            payload.toolCalls = toolCalls;
+        }
+        await this.sendAgentMessage(context, type, payload);
+    }
+    normalizeItemEvent(context, item, phase) {
+        switch (item.type) {
+            case "agent_message": {
+                if (phase !== "completed")
+                    return null;
+                return {
+                    type: "assistant",
+                    content: [
+                        {
+                            type: "text",
+                            text: item.text || "",
+                        },
+                    ],
+                };
+            }
+            case "reasoning": {
+                return {
+                    type: "thinking",
+                    content: [
+                        {
+                            type: "thinking",
+                            thinking: item.text,
+                            text: item.text,
+                            phase,
+                        },
+                    ],
+                };
+            }
+            case "command_execution": {
+                const toolUseId = this.buildToolUseId(context, item.id);
+                const timestamp = new Date().toISOString();
+                const isTerminal = phase === "completed" ||
+                    item.status === "completed" ||
+                    item.status === "failed";
+                if (!isTerminal) {
+                    if (phase !== "started") {
+                        return null;
+                    }
+                    return {
+                        type: "assistant",
+                        subtype: "tool_use",
+                        content: [
+                            {
+                                toolCalls: [
+                                    {
+                                        id: toolUseId,
+                                        name: "codex_command",
+                                        arguments: {
+                                            command: item.command,
+                                            status: item.status,
+                                        },
+                                        status: item.status,
+                                    },
+                                ],
+                                timestamp,
+                            },
+                        ],
+                    };
+                }
+                const exitCode = typeof item.exit_code === "number" ? item.exit_code : null;
+                const isError = item.status === "failed" || (exitCode ?? 0) !== 0;
+                return {
+                    type: "tool_result",
+                    subtype: "tool_result",
+                    content: [
+                        {
+                            type: "tool_result",
+                            tool_use_id: toolUseId,
+                            content: {
+                                kind: "codex_command_result",
+                                command: item.command,
+                                output: item.aggregated_output || "",
+                                exitCode,
+                                status: item.status,
+                            },
+                            timestamp,
+                        },
+                    ],
+                    isError,
+                };
+            }
+            case "file_change": {
+                if (phase === "updated")
+                    return null;
+                return {
+                    type: "system",
+                    subtype: "file_change",
+                    content: [
+                        {
+                            type: "file_change",
+                            changes: item.changes,
+                            status: item.status,
+                        },
+                    ],
+                };
+            }
+            case "mcp_tool_call": {
+                const toolName = this.buildMcpToolName(item.server, item.tool);
+                const toolUseId = this.buildToolUseId(context, item.id);
+                if (item.status === "in_progress" || phase !== "completed") {
+                    return {
+                        type: "assistant",
+                        subtype: "tool_use",
+                        content: [
+                            {
+                                toolCalls: [
+                                    {
+                                        id: toolUseId,
+                                        name: toolName,
+                                        arguments: item.arguments,
+                                        server: item.server,
+                                        tool: item.tool,
+                                        status: item.status,
+                                    },
+                                ],
+                                timestamp: new Date().toISOString(),
+                            },
+                        ],
+                    };
+                }
+                if (item.status === "failed") {
+                    return {
+                        type: "error",
+                        subtype: "tool_result",
+                        content: [
+                            {
+                                type: "text",
+                                text: item.error?.message || "Tool call failed",
+                                tool_use_id: toolUseId,
+                                tool_name: toolName,
+                                timestamp: new Date().toISOString(),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                return {
+                    type: "tool_result",
+                    subtype: "tool_result",
+                    content: [
+                        {
+                            type: "tool_result",
+                            subtype: "tool_result",
+                            tool_use_id: toolUseId,
+                            content: item.result?.content || [],
+                            structured_content: item.result?.structured_content,
+                            metadata: {
+                                server: item.server,
+                                tool: item.tool,
+                                name: toolName,
+                                original_tool_use_id: item.id,
+                            },
+                            timestamp: new Date().toISOString(),
+                        },
+                    ],
+                };
+            }
+            case "web_search": {
+                return {
+                    type: "system",
+                    subtype: `web_search.${phase}`,
+                    content: [
+                        {
+                            type: "web_search",
+                            query: item.query,
+                            status: phase,
+                        },
+                    ],
+                };
+            }
+            case "todo_list": {
+                return {
+                    type: "system",
+                    subtype: "todo_list",
+                    content: [
+                        {
+                            type: "todo_list",
+                            items: item.items,
+                            phase,
+                        },
+                    ],
+                };
+            }
+            case "error": {
+                return {
+                    type: "error",
+                    subtype: `item.${phase}`,
+                    content: [
+                        {
+                            type: "text",
+                            text: item.message,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            default:
+                return null;
+        }
+    }
+    async sendAgentMessage(context, type, { subtype, content, toolCalls, isError, }) {
+        const normalizedContent = Array.isArray(content)
+            ? content
+            : content
+                ? [content]
+                : [];
+        const payload = {
+            taskId: context.taskId,
+            conversationId: context.conversationId,
+            conversationObjectType: context.conversationObjectType,
+            conversationObjectId: context.conversationObjectId,
+            agentSessionId: context.agentSessionId,
+            type,
+            subtype,
+            content: normalizedContent,
+            toolCalls,
+            isError: Boolean(isError),
+            messageId: this.generateMessageId(context),
+            timestamp: new Date().toISOString(),
+        };
+        if ((0, debug_1.isRunnerDebugEnabled)()) {
+            console_1.console.log("[CodexManager] Sending message.agent", payload);
+        }
+        await this.runner.notify("message.agent", payload);
+    }
+    async handleThreadStarted(context, threadId) {
+        if (!threadId || threadId === context.agentSessionId) {
+            return;
+        }
+        const oldSessionId = context.agentSessionId;
+        context.agentSessionId = threadId;
+        await this.runner.notify("agentSessionId.changed", {
+            conversationId: context.conversationId,
+            conversationObjectType: context.conversationObjectType,
+            conversationObjectId: context.conversationObjectId,
+            oldAgentSessionId: oldSessionId,
+            newAgentSessionId: threadId,
+        });
+    }
+    mapSandboxMode(permissionsMode) {
+        const mode = (permissionsMode || "").toLowerCase();
+        if (mode === "read" || mode === "read_only") {
+            return "read-only";
+        }
+        if (mode === "workspace" || mode === "workspace-write") {
+            return "workspace-write";
+        }
+        return "danger-full-access";
+    }
+    shouldEnableNetwork(permissionsMode) {
+        const mode = (permissionsMode || "").toLowerCase();
+        return mode !== "read" && mode !== "read_only";
+    }
+    getAdditionalDirectories(config) {
+        const additionalDirs = [];
+        if (config.runnerRepoPath) {
+            additionalDirs.push(config.runnerRepoPath);
+        }
+        return additionalDirs.length ? additionalDirs : undefined;
+    }
+    buildConfigOverridesFromMcp(mcpServers) {
+        if (!mcpServers)
+            return undefined;
+        const overrides = {};
+        for (const [serverName, config] of Object.entries(mcpServers)) {
+            this.flattenOverrideObject(`mcp_servers.${serverName}`, config, overrides);
+        }
+        return Object.keys(overrides).length ? overrides : undefined;
+    }
+    normalizeMcpServersForCodex(mcpServers) {
+        const normalized = {};
+        for (const [serverName, config] of Object.entries(mcpServers)) {
+            normalized[serverName] = this.stripAuthorizationHeader(config);
+        }
+        return normalized;
+    }
+    buildMcpToolName(server, tool) {
+        const safeServer = (server || "unknown").trim() || "unknown";
+        const safeTool = (tool || "unknown").trim() || "unknown";
+        return `mcp__${safeServer}__${safeTool}`;
+    }
+    logRawThreadEvent(event) {
+        if (!(0, debug_1.isRunnerDebugEnabled)()) {
+            return;
+        }
+        try {
+            console_1.console.log("[CodexManager] RAW Codex event FULL:", this.safeStringify(event));
+            const summary = {
+                type: event?.type,
+                keys: Object.keys(event || {}),
+                hasItem: Boolean(event?.item),
+                itemType: event?.item?.type,
+                hasUsage: Boolean(event?.usage),
+                threadId: event?.thread_id,
+                turnId: event?.turn_id,
+            };
+            console_1.console.log("[CodexManager] RAW Codex event summary:", summary);
+            if (event?.item) {
+                console_1.console.log("[CodexManager] RAW Codex event item:", this.safeStringify(event.item));
+            }
+            if (event?.usage) {
+                console_1.console.log("[CodexManager] RAW Codex usage:", event.usage);
+            }
+        }
+        catch (error) {
+            console_1.console.warn("[CodexManager] Failed to log raw Codex event:", error);
+        }
+    }
+    safeStringify(value) {
+        const seen = new WeakSet();
+        return JSON.stringify(value, (key, nested) => {
+            if (typeof nested === "function")
+                return undefined;
+            if (typeof nested === "bigint")
+                return nested.toString();
+            if (typeof nested === "object" && nested !== null) {
+                if (seen.has(nested))
+                    return "[Circular]";
+                seen.add(nested);
+            }
+            return nested;
+        }, 2);
+    }
+    buildToolUseId(context, rawId) {
+        const scope = context.agentSessionId ||
+            context.conversationId ||
+            context.conversationObjectId ||
+            "codex";
+        return `${scope}:${rawId}`;
+    }
+    stripAuthorizationHeader(config) {
+        if (!config || typeof config !== "object" || Array.isArray(config)) {
+            return config;
+        }
+        const normalized = { ...config };
+        if (normalized.bearer_token_env_var &&
+            normalized.headers &&
+            typeof normalized.headers === "object" &&
+            !Array.isArray(normalized.headers)) {
+            const headers = { ...normalized.headers };
+            delete headers["Authorization"];
+            if (Object.keys(headers).length === 0) {
+                delete normalized.headers;
+            }
+            else {
+                normalized.headers = headers;
+            }
+        }
+        return normalized;
+    }
+    flattenOverrideObject(prefix, value, target) {
+        if (value === undefined) {
+            return;
+        }
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            target[prefix] = value;
+            return;
+        }
+        const entries = Object.entries(value);
+        if (!entries.length) {
+            target[prefix] = {};
+            return;
+        }
+        for (const [key, nested] of entries) {
+            this.flattenOverrideObject(`${prefix}.${key}`, nested, target);
+        }
+    }
+    async resolveWorkspacePath(context, config) {
+        let workspacePath;
+        const workspaceId = config.workspaceId;
+        if (config.runnerRepoPath) {
+            workspacePath = config.runnerRepoPath;
+            console_1.console.log(`[CodexManager] Using local workspace path ${workspacePath}`);
+            if (context.conversationObjectType === "Task") {
+                const taskHandle = await this.repositoryManager.createLocalTaskHandle(context.conversationObjectId, workspacePath);
+                context.taskHandle = taskHandle;
+            }
+            return workspacePath;
+        }
+        if (context.conversationObjectType === "Task" &&
+            config.repository &&
+            workspaceId) {
+            if (!config.repository.url) {
+                throw new Error("Repository URL is required for task conversations");
+            }
+            const taskHandle = await this.repositoryManager.createTaskWorktree(context.conversationObjectId, workspaceId, config.repository.url, config.repository.branch, config.githubToken);
+            context.taskHandle = taskHandle;
+            workspacePath = taskHandle.worktreePath;
+            return workspacePath;
+        }
+        if (config.repository && workspaceId) {
+            if (config.repository.type === "local" && config.repository.localPath) {
+                workspacePath = config.repository.localPath;
+                return workspacePath;
+            }
+            workspacePath = await this.repositoryManager.checkoutRepository(workspaceId, config.repository.url, config.repository.branch, config.githubToken);
+            return workspacePath;
+        }
+        if (workspaceId) {
+            workspacePath =
+                await this.repositoryManager.getWorkspacePath(workspaceId);
+            return workspacePath;
+        }
+        return process.cwd();
+    }
+    async fetchGithubTokens(workspaceId) {
+        try {
+            const response = await fetch(`${this.runner.config_.orchestratorUrl}/api/runner/tokens?workspaceId=${workspaceId}`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${process.env["NORTHFLARE_RUNNER_TOKEN"]}`,
+                },
+            });
+            if (!response.ok) {
+                console_1.console.error(`[CodexManager] Failed to fetch GitHub tokens: ${response.status}`);
+                return undefined;
+            }
+            const data = (await response.json());
+            return data.githubToken;
+        }
+        catch (error) {
+            console_1.console.error("[CodexManager] Error fetching GitHub tokens", error);
+            return undefined;
+        }
+    }
+    generateToolToken(context) {
+        if (!context.config.mcpServers)
+            return undefined;
+        const runnerToken = process.env["NORTHFLARE_RUNNER_TOKEN"];
+        const runnerUid = this.runner.getRunnerUid();
+        if (!runnerToken || !runnerUid)
+            return undefined;
+        return jwt.sign({
+            conversationId: context.conversationId,
+            runnerUid,
+        }, runnerToken, {
+            expiresIn: "60m",
+        });
+    }
+    normalizeToText(value) {
+        if (typeof value === "string")
+            return value;
+        if (value == null)
+            return "";
+        if (typeof value === "object") {
+            if (typeof value.text === "string") {
+                return value.text;
+            }
+            if (Array.isArray(value)) {
+                const texts = value
+                    .map((entry) => {
+                    if (entry &&
+                        typeof entry === "object" &&
+                        typeof entry.text === "string") {
+                        return entry.text;
+                    }
+                    return null;
+                })
+                    .filter((entry) => Boolean(entry));
+                if (texts.length) {
+                    return texts.join(" ");
+                }
+            }
+            if (typeof value.content === "string") {
+                return value.content;
+            }
+        }
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    normalizeSessionId(value) {
+        if (!value)
+            return undefined;
+        const trimmed = value.trim();
+        return trimmed.length ? trimmed : undefined;
+    }
+    resolveSessionId(config, conversationData, override) {
+        return (this.normalizeSessionId(override) ||
+            this.normalizeSessionId(config?.sessionId) ||
+            this.normalizeSessionId(conversationData?.agentSessionId) ||
+            this.normalizeSessionId(conversationData?.threadId) ||
+            this.normalizeSessionId(conversationData?.sessionId) ||
+            "");
+    }
+    isAbortError(error) {
+        if (!error)
+            return false;
+        return (error.name === "AbortError" ||
+            /aborted|abort/i.test(error.message || ""));
+    }
+    async _finalizeConversation(context, hadError, error, reason) {
+        if (context._finalized)
+            return;
+        context._finalized = true;
+        try {
+            await this.runner.notify("conversation.end", {
+                conversationId: context.conversationId,
+                conversationObjectType: context.conversationObjectType,
+                conversationObjectId: context.conversationObjectId,
+                agentSessionId: context.agentSessionId,
+                isError: hadError,
+                errorMessage: error?.message,
+                reason,
+            });
+        }
+        catch (notifyError) {
+            console_1.console.error("[CodexManager] Failed to send conversation.end notification", notifyError);
+        }
+        this.threadStates.delete(context.conversationId);
+        this.runner.activeConversations_.delete(context.conversationId);
+        status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
+    }
+    async _handleConversationError(context, error) {
+        console_1.console.error(`[CodexManager] Conversation error for ${context.conversationId}:`, error);
+        await this.runner.notify("error.report", {
+            conversationId: context.conversationId,
+            conversationObjectType: context.conversationObjectType,
+            conversationObjectId: context.conversationObjectId,
+            agentSessionId: context.agentSessionId,
+            errorType: "codex_error",
+            message: error.message,
+            details: {
+                stack: error.stack,
+                timestamp: new Date(),
+            },
+        });
+    }
+    generateMessageId(context) {
+        return `${context.agentSessionId}-${Date.now()}-${Math.random()
+            .toString(36)
+            .slice(2)}`;
+    }
+}
+exports.CodexManager = CodexManager;
+//# sourceMappingURL=codex-sdk-manager.js.map