@nordbyte/nordrelay 0.2.1

package/dist/codex-session.js

@@ -0,0 +1,591 @@
+import { Codex, } from "@openai/codex-sdk";
+import { resolveCodexCli } from "./codex-cli.js";
+import { readCodexFastMode, writeCodexFastMode } from "./codex-config.js";
+import { getThread, getThreadUsage, listModels, listThreads, listWorkspaces, } from "./codex-state.js";
+import { createLaunchProfile, findLaunchProfile, formatLaunchProfileBehavior, } from "./codex-launch.js";
+import { CODEX_AGENT_CAPABILITIES, } from "./agent.js";
+export class CodexSessionService {
+    config;
+    codex = null;
+    thread = null;
+    currentWorkspace;
+    abortController = null;
+    currentThreadId = null;
+    currentModel;
+    currentReasoningEffort;
+    currentLaunchProfile;
+    activeThreadLaunchProfile = null;
+    sessionTokens = { input: 0, cached: 0, output: 0 };
+    lastObservedFastMode = null;
+    constructor(config) {
+        this.config = config;
+        this.currentWorkspace = config.workspace;
+        this.currentLaunchProfile = getLaunchProfile(config, config.defaultLaunchProfileId);
+    }
+    static async create(config, options) {
+        const service = new CodexSessionService(config);
+        service.currentWorkspace = options?.workspace ?? config.workspace;
+        service.currentModel = options?.model ?? config.codexModel;
+        service.currentReasoningEffort = options?.reasoningEffort;
+        service.currentLaunchProfile = getLaunchProfile(config, options?.launchProfileId ?? config.defaultLaunchProfileId);
+        service.resetCodexClient();
+        if (options?.resumeThreadId) {
+            await service.resumeThread(options.resumeThreadId);
+            return service;
+        }
+        if (options?.deferThreadStart) {
+            return service;
+        }
+        await service.newThread(service.currentWorkspace, service.currentModel);
+        return service;
+    }
+    getInfo() {
+        const activeThreadId = this.thread?.id ?? this.currentThreadId;
+        if (activeThreadId && !this.abortController) {
+            this.refreshActiveThreadMetadata(activeThreadId);
+        }
+        const effectiveLaunchProfile = this.activeThreadLaunchProfile ?? this.currentLaunchProfile;
+        const codexFastMode = readCodexFastMode();
+        this.lastObservedFastMode = codexFastMode;
+        const info = {
+            agentId: "codex",
+            agentLabel: "Codex",
+            threadId: activeThreadId,
+            workspace: this.currentWorkspace,
+            model: this.currentModel ?? this.config.codexModel,
+            launchProfileId: effectiveLaunchProfile.id,
+            launchProfileLabel: effectiveLaunchProfile.label,
+            launchProfileBehavior: formatLaunchProfileBehavior(effectiveLaunchProfile),
+            sandboxMode: effectiveLaunchProfile.sandboxMode,
+            approvalPolicy: effectiveLaunchProfile.approvalPolicy,
+            fastMode: codexFastMode ?? (effectiveLaunchProfile.approvalPolicy === "never"),
+            unsafeLaunch: effectiveLaunchProfile.unsafe,
+            capabilities: CODEX_AGENT_CAPABILITIES,
+        };
+        Object.defineProperties(info, {
+            agentId: { value: "codex", enumerable: false },
+            agentLabel: { value: "Codex", enumerable: false },
+            capabilities: { value: CODEX_AGENT_CAPABILITIES, enumerable: false },
+        });
+        if (this.currentReasoningEffort) {
+            info.reasoningEffort = this.currentReasoningEffort;
+        }
+        if (this.activeThreadLaunchProfile &&
+            this.activeThreadLaunchProfile.id !== this.currentLaunchProfile.id) {
+            info.nextLaunchProfileId = this.currentLaunchProfile.id;
+            info.nextLaunchProfileLabel = this.currentLaunchProfile.label;
+            info.nextLaunchProfileBehavior = formatLaunchProfileBehavior(this.currentLaunchProfile);
+            info.nextUnsafeLaunch = this.currentLaunchProfile.unsafe;
+        }
+        if (this.sessionTokens.input > 0 || this.sessionTokens.cached > 0 || this.sessionTokens.output > 0) {
+            info.sessionTokens = { ...this.sessionTokens };
+        }
+        const threadId = info.threadId;
+        if (threadId) {
+            const codexUsage = getThreadUsage(threadId);
+            if (codexUsage) {
+                info.codexUsage = codexUsage;
+            }
+        }
+        return info;
+    }
+    isProcessing() {
+        return this.abortController !== null;
+    }
+    getActiveThreadId() {
+        return this.thread?.id ?? this.currentThreadId;
+    }
+    hasActiveThread() {
+        return this.thread !== null;
+    }
+    getCurrentWorkspace() {
+        return this.currentWorkspace;
+    }
+    async prompt(input, callbacks) {
+        if (!this.thread) {
+            throw new Error("Codex thread is not initialized");
+        }
+        if (this.abortController) {
+            throw new Error("A Codex turn is already in progress");
+        }
+        const controller = new AbortController();
+        this.abortController = controller;
+        let lastAgentText = "";
+        // Track cumulative aggregated_output per command item to compute deltas.
+        const lastCommandOutput = new Map();
+        try {
+            const { events } = await this.thread.runStreamed(this.buildSdkInput(input), { signal: controller.signal });
+            for await (const event of events) {
+                this.handleThreadEvent(event);
+                switch (event.type) {
+                    case "item.started":
+                    case "item.updated": {
+                        const item = event.item;
+                        if (item.type === "agent_message") {
+                            const delta = computeTextDelta(lastAgentText, item.text);
+                            if (delta) {
+                                lastAgentText = item.text;
+                                callbacks.onTextDelta(delta);
+                            }
+                            else {
+                                lastAgentText = item.text;
+                            }
+                        }
+                        else if (item.type === "command_execution") {
+                            if (event.type === "item.started") {
+                                // Record baseline so the first item.updated delta is computed correctly.
+                                lastCommandOutput.set(item.id, item.aggregated_output);
+                                callbacks.onToolStart(item.command, item.id);
+                            }
+                            else {
+                                // aggregated_output grows monotonically; pass only the new portion.
+                                const prev = lastCommandOutput.get(item.id) ?? "";
+                                const delta = computeTextDelta(prev, item.aggregated_output);
+                                lastCommandOutput.set(item.id, item.aggregated_output);
+                                if (delta) {
+                                    callbacks.onToolUpdate(item.id, delta);
+                                }
+                            }
+                        }
+                        else if (item.type === "web_search") {
+                            if (event.type === "item.started") {
+                                const label = truncate(item.query, 60);
+                                callbacks.onToolStart(`🔍 ${label}`, item.id);
+                                callbacks.onToolUpdate(item.id, item.query);
+                            }
+                        }
+                        else if (item.type === "todo_list") {
+                            callbacks.onTodoUpdate?.(item.items);
+                        }
+                        break;
+                    }
+                    case "item.completed": {
+                        const item = event.item;
+                        if (item.type === "agent_message") {
+                            const delta = computeTextDelta(lastAgentText, item.text);
+                            if (delta) {
+                                callbacks.onTextDelta(delta);
+                            }
+                            lastAgentText = item.text;
+                        }
+                        else if (item.type === "command_execution") {
+                            // Pass any output that arrived only in the completion event (e.g. fast
+                            // commands that never fired item.updated).
+                            const prev = lastCommandOutput.get(item.id) ?? "";
+                            const delta = computeTextDelta(prev, item.aggregated_output);
+                            if (delta) {
+                                callbacks.onToolUpdate(item.id, delta);
+                            }
+                            callbacks.onToolEnd(item.id, item.status === "failed");
+                        }
+                        else if (item.type === "file_change") {
+                            const toolId = item.id;
+                            const summary = item.changes.map((change) => `${change.kind} ${change.path}`).join(", ");
+                            callbacks.onToolStart("file_change", toolId);
+                            callbacks.onToolUpdate(toolId, summary);
+                            callbacks.onToolEnd(toolId, item.status === "failed");
+                        }
+                        else if (item.type === "mcp_tool_call") {
+                            callbacks.onToolStart(`mcp:${item.server}/${item.tool}`, item.id);
+                            if (item.error) {
+                                callbacks.onToolUpdate(item.id, item.error.message);
+                            }
+                            callbacks.onToolEnd(item.id, item.status === "failed");
+                        }
+                        else if (item.type === "web_search") {
+                            callbacks.onToolEnd(item.id, false);
+                        }
+                        else if (item.type === "error") {
+                            callbacks.onToolStart("⚠️ error", item.id);
+                            callbacks.onToolUpdate(item.id, item.message);
+                            callbacks.onToolEnd(item.id, true);
+                        }
+                        else if (item.type === "todo_list") {
+                            callbacks.onTodoUpdate?.(item.items);
+                        }
+                        break;
+                    }
+                    case "turn.completed": {
+                        // Accumulate and deliver usage BEFORE onAgentEnd so that
+                        // finalizeResponse() can read lastTurnUsage when building the
+                        // final message text.
+                        const u = event.usage;
+                        this.sessionTokens.input += u.input_tokens;
+                        this.sessionTokens.cached += u.cached_input_tokens;
+                        this.sessionTokens.output += u.output_tokens;
+                        callbacks.onTurnComplete?.({
+                            inputTokens: u.input_tokens,
+                            cachedInputTokens: u.cached_input_tokens,
+                            outputTokens: u.output_tokens,
+                        });
+                        callbacks.onAgentEnd();
+                        break;
+                    }
+                    case "turn.failed":
+                        throw new Error(event.error.message);
+                    case "error":
+                        throw new Error(event.message);
+                    default:
+                        break;
+                }
+            }
+        }
+        finally {
+            if (this.abortController === controller) {
+                this.abortController = null;
+            }
+        }
+    }
+    async abort() {
+        this.abortController?.abort();
+    }
+    async newThread(workspace, model) {
+        this.ensureIdle("start a new thread");
+        const effectiveWorkspace = workspace ?? this.currentWorkspace;
+        const effectiveModel = model ?? this.currentModel;
+        this.thread = this.getCodex().startThread(this.buildThreadOptions(effectiveWorkspace, effectiveModel));
+        this.activeThreadLaunchProfile = this.currentLaunchProfile;
+        this.currentWorkspace = effectiveWorkspace;
+        this.currentThreadId = this.thread.id ?? null;
+        if (model) {
+            this.currentModel = model;
+        }
+        return this.getInfo();
+    }
+    async resumeThread(threadId) {
+        this.ensureIdle("resume a thread");
+        this.thread = this.getCodex().resumeThread(threadId, this.buildThreadOptions(this.currentWorkspace, this.currentModel));
+        this.activeThreadLaunchProfile = this.currentLaunchProfile;
+        this.currentThreadId = threadId;
+        return this.getInfo();
+    }
+    async switchSession(threadId) {
+        this.ensureIdle("switch session");
+        const record = getThread(threadId);
+        const workspace = record?.cwd ?? this.currentWorkspace;
+        const model = record?.model || undefined;
+        const reasoningEffort = record?.reasoningEffort || undefined;
+        const launchProfile = this.resolveThreadLaunchProfile(record);
+        this.currentReasoningEffort = reasoningEffort;
+        this.thread = this.getCodex().resumeThread(threadId, this.buildThreadOptions(workspace, model, launchProfile));
+        this.activeThreadLaunchProfile = launchProfile;
+        this.currentWorkspace = workspace;
+        this.currentThreadId = threadId;
+        if (model) {
+            this.currentModel = model;
+        }
+        return this.getInfo();
+    }
+    listAllSessions(limit) {
+        return listThreads(limit ?? 20).map(toAgentThreadRecord);
+    }
+    listWorkspaces() {
+        return listWorkspaces();
+    }
+    listModels() {
+        return listModels();
+    }
+    getSessionRecord(threadId) {
+        const record = getThread(threadId);
+        return record ? toAgentThreadRecord(record) : null;
+    }
+    setModel(slug) {
+        this.currentModel = slug;
+        return slug;
+    }
+    setModelForCurrentSession(slug) {
+        this.ensureIdle("change model");
+        this.currentModel = slug;
+        const appliedToActiveThread = this.reattachActiveThread();
+        return { value: slug, appliedToActiveThread };
+    }
+    setReasoningEffort(effort) {
+        this.currentReasoningEffort = effort;
+    }
+    setReasoningEffortForCurrentSession(effort) {
+        this.ensureIdle("change reasoning effort");
+        this.currentReasoningEffort = effort;
+        const appliedToActiveThread = this.reattachActiveThread();
+        return { value: effort, appliedToActiveThread };
+    }
+    setLaunchProfile(profileId) {
+        this.currentLaunchProfile = getLaunchProfile(this.config, profileId);
+        this.resetCodexClient();
+        return this.currentLaunchProfile;
+    }
+    setFastMode(enabled) {
+        this.ensureIdle("change fast mode");
+        const profile = this.findFastModeLaunchProfile(enabled);
+        writeCodexFastMode(enabled);
+        this.lastObservedFastMode = enabled;
+        this.currentLaunchProfile = profile;
+        this.resetCodexClient();
+        let appliedToActiveThread = false;
+        if (this.thread) {
+            if (this.currentThreadId) {
+                this.thread = this.getCodex().resumeThread(this.currentThreadId, this.buildThreadOptions(this.currentWorkspace, this.currentModel, profile));
+            }
+            else {
+                this.thread = this.getCodex().startThread(this.buildThreadOptions(this.currentWorkspace, this.currentModel, profile));
+            }
+            this.activeThreadLaunchProfile = profile;
+            appliedToActiveThread = true;
+        }
+        return { enabled, profile, appliedToActiveThread };
+    }
+    getSelectedLaunchProfile() {
+        return this.currentLaunchProfile;
+    }
+    syncFromCodexState(options = {}) {
+        const activeThreadId = this.thread?.id ?? this.currentThreadId;
+        const before = {
+            workspace: this.currentWorkspace,
+            model: this.currentModel,
+            reasoningEffort: this.currentReasoningEffort,
+            activeLaunchProfileId: this.activeThreadLaunchProfile?.id,
+            selectedLaunchProfileId: this.currentLaunchProfile.id,
+        };
+        const changedFields = new Set();
+        if (activeThreadId && !this.abortController) {
+            const record = getThread(activeThreadId);
+            if (record) {
+                if (record.cwd && record.cwd !== this.currentWorkspace)
+                    changedFields.add("workspace");
+                if ((record.model || undefined) !== this.currentModel)
+                    changedFields.add("model");
+                if ((record.reasoningEffort || undefined) !== this.currentReasoningEffort)
+                    changedFields.add("reasoning");
+                const resolvedLaunchProfile = this.resolveThreadLaunchProfile(record);
+                if (resolvedLaunchProfile.id !== this.activeThreadLaunchProfile?.id)
+                    changedFields.add("launch");
+                this.currentWorkspace = record.cwd || this.currentWorkspace;
+                this.currentModel = record.model || this.currentModel;
+                this.currentReasoningEffort = record.reasoningEffort
+                    ? record.reasoningEffort
+                    : undefined;
+                this.activeThreadLaunchProfile = resolvedLaunchProfile;
+            }
+        }
+        const codexFastMode = readCodexFastMode();
+        if (codexFastMode !== this.lastObservedFastMode) {
+            changedFields.add("fast");
+        }
+        this.lastObservedFastMode = codexFastMode;
+        if (codexFastMode !== null) {
+            try {
+                const fastProfile = this.findFastModeLaunchProfile(codexFastMode);
+                if (fastProfile.id !== this.currentLaunchProfile.id) {
+                    changedFields.add("next-launch");
+                }
+                this.currentLaunchProfile = fastProfile;
+            }
+            catch {
+                // Keep the existing profile if no configured profile maps to this value.
+            }
+        }
+        const changed = changedFields.size > 0 ||
+            before.workspace !== this.currentWorkspace ||
+            before.model !== this.currentModel ||
+            before.reasoningEffort !== this.currentReasoningEffort ||
+            before.activeLaunchProfileId !== this.activeThreadLaunchProfile?.id ||
+            before.selectedLaunchProfileId !== this.currentLaunchProfile.id;
+        let reattached = false;
+        if (changed && options.reattach && !this.abortController && this.thread) {
+            reattached = this.reattachActiveThread();
+        }
+        return {
+            threadId: activeThreadId,
+            changed,
+            reattached,
+            changedFields: [...changedFields],
+            info: this.getInfo(),
+        };
+    }
+    handback() {
+        const info = { threadId: this.currentThreadId, workspace: this.currentWorkspace };
+        this.abortController?.abort();
+        this.abortController = null;
+        this.thread = null;
+        this.currentThreadId = null;
+        this.activeThreadLaunchProfile = null;
+        return info;
+    }
+    dispose() {
+        this.abortController?.abort();
+        this.abortController = null;
+        this.thread = null;
+        this.currentThreadId = null;
+        this.activeThreadLaunchProfile = null;
+    }
+    buildSdkInput(input) {
+        if (typeof input === "string") {
+            return input;
+        }
+        const parts = [];
+        const textParts = [];
+        if (input.stagedFileInstructions) {
+            textParts.push(input.stagedFileInstructions);
+        }
+        if (input.text) {
+            textParts.push(input.text);
+        }
+        if (textParts.length > 0) {
+            parts.push({ type: "text", text: textParts.join("\n\n") });
+        }
+        for (const imagePath of input.imagePaths ?? []) {
+            parts.push({ type: "local_image", path: imagePath });
+        }
+        if (parts.length === 0) {
+            return "";
+        }
+        if (parts.length === 1 && parts[0]?.type === "text") {
+            return parts[0].text;
+        }
+        return parts;
+    }
+    buildThreadOptions(workspace, model, launchProfile = this.currentLaunchProfile) {
+        const effectiveModel = model ?? this.currentModel ?? this.config.codexModel;
+        const options = {
+            model: effectiveModel,
+            sandboxMode: launchProfile.sandboxMode,
+            workingDirectory: workspace,
+            approvalPolicy: launchProfile.approvalPolicy,
+            skipGitRepoCheck: true,
+        };
+        if (this.currentReasoningEffort) {
+            return {
+                ...options,
+                modelReasoningEffort: this.currentReasoningEffort,
+            };
+        }
+        return options;
+    }
+    ensureIdle(action) {
+        if (this.abortController) {
+            throw new Error(`Cannot ${action} while a turn is in progress`);
+        }
+    }
+    handleThreadEvent(event) {
+        if (event.type === "thread.started") {
+            this.currentThreadId = event.thread_id;
+        }
+    }
+    getCodex() {
+        if (!this.codex) {
+            this.resetCodexClient();
+        }
+        return this.codex;
+    }
+    resetCodexClient() {
+        const cli = resolveCodexCli();
+        const options = {
+            apiKey: this.config.codexApiKey,
+            config: {
+                approval_policy: this.currentLaunchProfile.approvalPolicy,
+            },
+            env: buildCodexEnv(this.config.codexApiKey),
+        };
+        if (cli.path) {
+            options.codexPathOverride = cli.path;
+        }
+        this.codex = new Codex(options);
+    }
+    resolveThreadLaunchProfile(record) {
+        if (!record?.sandboxMode || !record.approvalPolicy) {
+            return this.currentLaunchProfile;
+        }
+        const matchingProfile = this.config.launchProfiles.find((profile) => profile.sandboxMode === record.sandboxMode && profile.approvalPolicy === record.approvalPolicy);
+        if (matchingProfile) {
+            return matchingProfile;
+        }
+        return createLaunchProfile({
+            id: "attached-thread",
+            label: "Attached Thread",
+            sandboxMode: record.sandboxMode,
+            approvalPolicy: record.approvalPolicy,
+        });
+    }
+    refreshActiveThreadMetadata(threadId) {
+        const record = getThread(threadId);
+        if (!record) {
+            return;
+        }
+        this.currentWorkspace = record.cwd || this.currentWorkspace;
+        this.currentModel = record.model || this.currentModel;
+        this.currentReasoningEffort = record.reasoningEffort
+            ? record.reasoningEffort
+            : undefined;
+        this.activeThreadLaunchProfile = this.resolveThreadLaunchProfile(record);
+    }
+    reattachActiveThread() {
+        if (!this.thread) {
+            this.resetCodexClient();
+            return false;
+        }
+        const launchProfile = this.activeThreadLaunchProfile ?? this.currentLaunchProfile;
+        if (this.currentThreadId) {
+            this.thread = this.getCodex().resumeThread(this.currentThreadId, this.buildThreadOptions(this.currentWorkspace, this.currentModel, launchProfile));
+        }
+        else {
+            this.thread = this.getCodex().startThread(this.buildThreadOptions(this.currentWorkspace, this.currentModel, launchProfile));
+            this.currentThreadId = this.thread.id ?? null;
+        }
+        this.activeThreadLaunchProfile = launchProfile;
+        return true;
+    }
+    findFastModeLaunchProfile(enabled) {
+        const current = this.currentLaunchProfile;
+        const profiles = this.config.launchProfiles;
+        const candidates = enabled
+            ? [
+                current.approvalPolicy === "never" ? current : undefined,
+                profiles.find((profile) => profile.sandboxMode === current.sandboxMode && profile.approvalPolicy === "never"),
+                profiles.find((profile) => profile.id === this.config.defaultLaunchProfileId && profile.approvalPolicy === "never"),
+                profiles.find((profile) => !profile.unsafe && profile.approvalPolicy === "never"),
+                profiles.find((profile) => profile.approvalPolicy === "never"),
+            ]
+            : [
+                current.approvalPolicy !== "never" ? current : undefined,
+                profiles.find((profile) => profile.sandboxMode === current.sandboxMode && profile.approvalPolicy !== "never"),
+                profiles.find((profile) => profile.id === "review"),
+                profiles.find((profile) => !profile.unsafe && profile.approvalPolicy !== "never"),
+                profiles.find((profile) => profile.approvalPolicy !== "never"),
+            ];
+        const profile = candidates.find((candidate) => Boolean(candidate));
+        if (!profile) {
+            throw new Error(`No launch profile is configured for fast mode ${enabled ? "on" : "off"}`);
+        }
+        return profile;
+    }
+}
+function getLaunchProfile(config, profileId) {
+    const profile = findLaunchProfile(config.launchProfiles, profileId);
+    if (!profile) {
+        throw new Error(`Unknown launch profile: ${profileId}`);
+    }
+    return profile;
+}
+function toAgentThreadRecord(record) {
+    return {
+        ...record,
+        agentId: "codex",
+    };
+}
+function buildCodexEnv(apiKey) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+            env[key] = value;
+        }
+    }
+    if (apiKey) {
+        env.CODEX_API_KEY = apiKey;
+    }
+    return env;
+}
+function computeTextDelta(previousText, nextText) {
+    return nextText.startsWith(previousText) ? nextText.slice(previousText.length) : nextText;
+}
+function truncate(text, maxLength) {
+    return text.length <= maxLength ? text : `${text.slice(0, maxLength - 1)}…`;
+}