@kin-tio/cli 0.6.0

package/dist/src/services/codex-app-server.js

@@ -0,0 +1,436 @@
+import readline from 'node:readline';
+import crossSpawn from 'cross-spawn';
+import { KINTIO_VERSION } from '../version.js';
+const REQUEST_TIMEOUT_MS = 30_000;
+const THREAD_LIST_PAGE_SIZE = 100;
+const MAX_THREAD_LIST_PAGES = 100;
+const THREAD_SOURCE_KINDS = [
+    'cli', 'vscode', 'exec', 'appServer', 'subAgent', 'subAgentReview',
+    'subAgentCompact', 'subAgentThreadSpawn', 'subAgentOther', 'unknown',
+];
+const CODEX_ERROR_CATEGORIES = new Set([
+    'contextWindowExceeded', 'sessionBudgetExceeded', 'usageLimitExceeded',
+    'rateLimitExceeded', 'serverOverloaded', 'cyberPolicy', 'misalignmentPolicyViolation',
+    'internalServerError', 'unauthorized', 'badRequest', 'threadRollbackFailed',
+    'sandboxError', 'other',
+]);
+const CODEX_OBJECT_ERROR_CATEGORIES = new Set([
+    'httpConnectionFailed', 'responseStreamConnectionFailed',
+    'responseStreamDisconnected', 'responseTooManyFailedAttempts',
+    'activeTurnNotSteerable',
+]);
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    return { promise, resolve, reject };
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function codexFailureLabel(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === 'string') {
+        return CODEX_ERROR_CATEGORIES.has(value) ? value : 'other';
+    }
+    const record = asRecord(value);
+    const keys = record ? Object.keys(record) : [];
+    const category = keys.length === 1 ? keys[0] || '' : '';
+    if (!CODEX_OBJECT_ERROR_CATEGORIES.has(category))
+        return 'other';
+    const detail = asRecord(record?.[category]);
+    const status = detail?.httpStatusCode;
+    return category + (typeof status === 'number' && Number.isInteger(status) &&
+        status >= 100 && status <= 599
+        ? ` (HTTP ${status})`
+        : '');
+}
+function normalizeInput(input) {
+    const values = typeof input === 'string' ? [{ type: 'text', text: input }] : input;
+    return values.map((item) => item.type === 'text'
+        ? { type: 'text', text: item.text, text_elements: [] }
+        : { type: 'localImage', path: item.path });
+}
+const defaultSpawn = crossSpawn;
+export class CodexAppServer {
+    #options;
+    #process = null;
+    #reader = null;
+    #requestId = 1;
+    #pending = new Map();
+    #turns = new Map();
+    #initializing = null;
+    #terminating = null;
+    #closed = false;
+    eventSequence = 0;
+    constructor(options = {}) {
+        this.#options = {
+            ...options,
+            requestTimeoutMs: options.requestTimeoutMs || REQUEST_TIMEOUT_MS,
+            spawnProcess: options.spawnProcess || defaultSpawn,
+            logger: options.logger || console,
+        };
+    }
+    startThread(options) {
+        return new CodexAppServerThread(this, null, options);
+    }
+    resumeThread(threadId, options) {
+        return new CodexAppServerThread(this, threadId, options);
+    }
+    async getThreadState(threadId) {
+        await this.initialize();
+        const listed = async (archived) => {
+            let cursor = null;
+            for (let page = 0; page < MAX_THREAD_LIST_PAGES; page += 1) {
+                const result = await this.request('thread/list', {
+                    archived,
+                    useStateDbOnly: true,
+                    limit: THREAD_LIST_PAGE_SIZE,
+                    sourceKinds: THREAD_SOURCE_KINDS,
+                    ...(cursor ? { cursor } : {}),
+                });
+                if ((result.data || []).some((thread) => thread.id === threadId)) {
+                    return true;
+                }
+                cursor = result.nextCursor || null;
+                if (!cursor)
+                    return false;
+            }
+            throw new Error('Codex thread listing exceeded the pagination limit');
+        };
+        if (await listed(false))
+            return 'active';
+        return await listed(true) ? 'archived' : 'missing';
+    }
+    async readThread(threadId, { includeTurns = true } = {}) {
+        await this.initialize();
+        return this.request('thread/read', { threadId, includeTurns });
+    }
+    async deleteThread(threadId) {
+        await this.initialize();
+        await this.request('thread/delete', { threadId });
+    }
+    initialize() {
+        this.#initializing ||= this.#initialize();
+        return this.#initializing;
+    }
+    async #initialize() {
+        const configArguments = (this.#options.configOverrides || [])
+            .flatMap((value) => ['--config', value]);
+        const command = 'codex';
+        const argumentsList = ['app-server', '--stdio', ...configArguments];
+        const child = this.#options.spawnProcess(command, argumentsList, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.#process = child;
+        child.once('error', (error) => {
+            this.#fail(new Error(`Codex app-server process error: ${error.message}`, { cause: error }));
+        });
+        child.once('exit', (code, signal) => {
+            if (this.#process === child)
+                this.#process = null;
+            if (this.#closed)
+                return;
+            const detail = signal ? `signal ${signal}` : `code ${code ?? 1}`;
+            this.#fail(new Error(`Codex app-server exited with ${detail}`));
+        });
+        child.stderr?.resume();
+        this.#reader = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+        this.#reader.on('line', (line) => this.#handleLine(line));
+        await this.request('initialize', {
+            clientInfo: {
+                name: 'kintio_codex',
+                title: 'Kintio Codex Adapter',
+                version: KINTIO_VERSION,
+            },
+            capabilities: null,
+        });
+        this.#write({ method: 'initialized', params: {} });
+    }
+    request(method, params, timeoutMs = this.#options.requestTimeoutMs) {
+        if (this.#closed)
+            return Promise.reject(new Error('Codex app-server is closed'));
+        const id = this.#requestId++;
+        const result = deferred();
+        const timer = setTimeout(() => {
+            this.#pending.delete(id);
+            result.reject(new Error(`Codex app-server request timed out: ${method}`));
+        }, timeoutMs);
+        timer.unref();
+        this.#pending.set(id, { ...result, timer, method });
+        try {
+            this.#write({ method, id, params });
+        }
+        catch (error) {
+            clearTimeout(timer);
+            this.#pending.delete(id);
+            result.reject(error);
+        }
+        return result.promise;
+    }
+    waitForTurn(turnId) {
+        return this.#turnState(turnId).waiter.promise.finally(() => {
+            this.#turns.delete(turnId);
+        });
+    }
+    #write(message) {
+        if (!this.#process?.stdin.writable) {
+            throw new Error('Codex app-server stdin is not writable');
+        }
+        this.#process.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    #handleLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.#fail(new Error('Invalid JSON from Codex app-server'));
+            return;
+        }
+        const message = asRecord(parsed);
+        if (!message) {
+            this.#fail(new Error('Codex app-server emitted a non-object message'));
+            return;
+        }
+        if (typeof message.id === 'number' && typeof message.method !== 'string') {
+            const pending = this.#pending.get(message.id);
+            if (!pending)
+                return;
+            clearTimeout(pending.timer);
+            this.#pending.delete(message.id);
+            const rpcError = asRecord(message.error);
+            if (rpcError) {
+                const error = new Error(`Codex app-server request failed: ${pending.method}`);
+                if (typeof rpcError.code === 'number' && Number.isSafeInteger(rpcError.code)) {
+                    error.code = rpcError.code;
+                }
+                pending.reject(error);
+            }
+            else {
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if (typeof message.id === 'number' && typeof message.method === 'string') {
+            this.#write({
+                id: message.id,
+                error: { code: -32601, message: `Unsupported server request: ${message.method}` },
+            });
+            return;
+        }
+        this.#handleNotification(message);
+    }
+    #turnState(turnId) {
+        const existing = this.#turns.get(turnId);
+        if (existing)
+            return existing;
+        const created = {
+            items: [],
+            itemStarts: new Map(),
+            waiter: deferred(),
+        };
+        this.#turns.set(turnId, created);
+        return created;
+    }
+    #handleNotification(message) {
+        const sequence = ++this.eventSequence;
+        const params = asRecord(message.params);
+        if (message.method === 'item/started') {
+            const item = asRecord(params?.item);
+            if (typeof params?.turnId === 'string' && typeof item?.id === 'string') {
+                this.#turnState(params.turnId).itemStarts.set(item.id, sequence);
+            }
+            return;
+        }
+        if (message.method === 'item/completed') {
+            const item = asRecord(params?.item);
+            if (typeof params?.turnId === 'string' &&
+                item &&
+                typeof item.type === 'string') {
+                const state = this.#turnState(params.turnId);
+                const id = typeof item.id === 'string' ? item.id : '';
+                state.items.push({
+                    ...item,
+                    type: item.type,
+                    startedSequence: state.itemStarts.get(id) || sequence,
+                    completedSequence: sequence,
+                });
+                if (id)
+                    state.itemStarts.delete(id);
+            }
+            return;
+        }
+        if (message.method === 'turn/completed') {
+            const turn = asRecord(params?.turn);
+            if (typeof turn?.id !== 'string')
+                return;
+            const state = this.#turnState(turn.id);
+            if (turn.status === 'completed') {
+                state.waiter.resolve({ items: state.items });
+            }
+            else {
+                const status = turn.status === 'failed' || turn.status === 'interrupted'
+                    ? turn.status
+                    : 'unknown';
+                const failure = status === 'failed'
+                    ? codexFailureLabel(asRecord(turn.error)?.codexErrorInfo) ?? state.failure
+                    : undefined;
+                state.waiter.reject(new Error(`Codex turn ended with status ${status}` +
+                    `${failure ? `: ${failure}` : ''}`));
+            }
+            return;
+        }
+        if (message.method === 'error') {
+            const error = asRecord(params?.error);
+            const failure = codexFailureLabel(error?.codexErrorInfo);
+            if (typeof params?.turnId === 'string' && failure !== undefined) {
+                this.#turnState(params.turnId).failure = failure;
+            }
+            this.#options.logger.warn?.(failure !== undefined
+                ? `[codex] app-server error category=${failure}; content suppressed`
+                : '[codex] app-server emitted an error notification; content suppressed');
+        }
+    }
+    #rejectAll(error) {
+        for (const pending of this.#pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.#pending.clear();
+        for (const state of this.#turns.values())
+            state.waiter.reject(error);
+        this.#turns.clear();
+    }
+    #fail(error) {
+        void this.#shutdown(error);
+    }
+    #shutdown(error) {
+        if (!this.#closed) {
+            this.#closed = true;
+            this.#reader?.close();
+            this.#rejectAll(error);
+        }
+        return this.#terminate();
+    }
+    #terminate() {
+        if (this.#terminating)
+            return this.#terminating;
+        const child = this.#process;
+        if (!child || child.exitCode !== null)
+            return Promise.resolve();
+        this.#terminating = new Promise((resolve) => {
+            child.once('exit', () => resolve());
+            child.kill('SIGTERM');
+            const timer = setTimeout(() => child.kill('SIGKILL'), 2_000);
+            timer.unref();
+        }).finally(() => {
+            this.#terminating = null;
+        });
+        return this.#terminating;
+    }
+    async close() {
+        await this.#shutdown(new Error('Codex app-server closed'));
+    }
+}
+class CodexAppServerThread {
+    #server;
+    #options;
+    #ready = null;
+    #activeTurnId = '';
+    #lastSteerSequence = 0;
+    #lastSteerClientId = '';
+    id;
+    constructor(server, threadId, options) {
+        this.#server = server;
+        this.#options = options;
+        this.id = threadId;
+    }
+    #params() {
+        return {
+            cwd: this.#options.workingDirectory,
+            approvalPolicy: this.#options.approvalPolicy,
+            sandbox: 'read-only',
+            ...(this.#options.developerInstructions
+                ? { developerInstructions: this.#options.developerInstructions }
+                : {}),
+        };
+    }
+    #ensureThread() {
+        this.#ready ||= (async () => {
+            await this.#server.initialize();
+            const result = this.id
+                ? await this.#server.request('thread/resume', {
+                    threadId: this.id,
+                    ...this.#params(),
+                })
+                : await this.#server.request('thread/start', this.#params());
+            this.id = result.thread.id;
+        })();
+        return this.#ready;
+    }
+    async ensure() {
+        await this.#ensureThread();
+        if (!this.id)
+            throw new Error('Codex thread has no ID');
+        return this.id;
+    }
+    async startRun(input, { clientUserMessageId } = {}) {
+        await this.#ensureThread();
+        if (!this.id)
+            throw new Error('Codex thread has no ID');
+        if (this.#activeTurnId)
+            throw new Error('Codex thread already has an active turn');
+        this.#lastSteerSequence = 0;
+        this.#lastSteerClientId = '';
+        const result = await this.#server.request('turn/start', {
+            threadId: this.id,
+            input: normalizeInput(input),
+            ...this.#params(),
+            ...(clientUserMessageId ? { clientUserMessageId } : {}),
+        });
+        const turnId = result.turn.id;
+        this.#activeTurnId = turnId;
+        const completion = this.#server.waitForTurn(turnId).then((completed) => {
+            const boundaryItem = [...completed.items].reverse().find((item) => item.type === 'userMessage' && item.clientId === this.#lastSteerClientId);
+            return {
+                ...completed,
+                lastSteerSequence: boundaryItem?.completedSequence || this.#lastSteerSequence,
+            };
+        }).finally(() => {
+            if (this.#activeTurnId === turnId)
+                this.#activeTurnId = '';
+        });
+        return { turnId, completion };
+    }
+    async steer(input, { clientUserMessageId } = {}) {
+        await this.#ensureThread();
+        if (!this.id || !this.#activeTurnId) {
+            throw new Error('Codex thread has no active turn to steer');
+        }
+        const result = await this.#server.request('turn/steer', {
+            threadId: this.id,
+            input: normalizeInput(input),
+            expectedTurnId: this.#activeTurnId,
+            ...(clientUserMessageId ? { clientUserMessageId } : {}),
+        });
+        this.#lastSteerSequence = this.#server.eventSequence;
+        this.#lastSteerClientId = clientUserMessageId || '';
+        return result.turnId;
+    }
+    async interrupt() {
+        if (!this.id || !this.#activeTurnId)
+            return false;
+        await this.#server.request('turn/interrupt', {
+            threadId: this.id,
+            turnId: this.#activeTurnId,
+        });
+        return true;
+    }
+}