evolclaw 3.2.0 → 3.3.0

package/dist/agents/codex-app-server-client.js

@@ -0,0 +1,364 @@
+import { spawn } from 'child_process';
+import readline from 'readline';
+import { logger } from '../utils/logger.js';
+export class CodexAppServerClient {
+    options;
+    proc = null;
+    pending = new Map();
+    notificationHandlers = new Set();
+    nextId = 1;
+    initialized = false;
+    stderrBuffer = [];
+    constructor(options) {
+        this.options = options;
+    }
+    onNotification(handler) {
+        this.notificationHandlers.add(handler);
+        return () => this.notificationHandlers.delete(handler);
+    }
+    async threadStart(projectPath, options) {
+        const effort = options?.effort ?? this.options.effort;
+        return this.request('thread/start', {
+            cwd: projectPath,
+            model: options?.model ?? this.options.model ?? null,
+            approvalPolicy: options?.approvalPolicy ?? null,
+            approvalsReviewer: options?.approvalsReviewer ?? this.options.approvalsReviewer ?? null,
+            sandbox: options?.sandbox ?? null,
+            config: this.buildThreadConfig(effort, options?.config),
+            ...(options?.baseInstructions ? { baseInstructions: options.baseInstructions } : {}),
+            ...(options?.developerInstructions ? { developerInstructions: options.developerInstructions } : {}),
+        });
+    }
+    async threadResume(threadId, projectPath, options) {
+        const effort = options?.effort ?? this.options.effort;
+        return this.request('thread/resume', {
+            threadId,
+            cwd: projectPath,
+            model: options?.model ?? this.options.model ?? null,
+            approvalPolicy: options?.approvalPolicy ?? null,
+            approvalsReviewer: options?.approvalsReviewer ?? this.options.approvalsReviewer ?? null,
+            sandbox: options?.sandbox ?? null,
+            config: this.buildThreadConfig(effort, options?.config),
+            ...(options?.baseInstructions ? { baseInstructions: options.baseInstructions } : {}),
+            ...(options?.developerInstructions ? { developerInstructions: options.developerInstructions } : {}),
+        });
+    }
+    async turnStart(threadId, input, options) {
+        const sandboxPolicy = this.toTurnSandboxPolicy(options?.sandbox);
+        return this.request('turn/start', {
+            threadId,
+            input,
+            ...(options?.cwd ? { cwd: options.cwd } : {}),
+            ...(options?.model ? { model: options.model } : {}),
+            ...(options?.approvalPolicy ? { approvalPolicy: options.approvalPolicy } : {}),
+            ...(sandboxPolicy ? { sandboxPolicy } : {}),
+            ...(options?.effort ? { effort: options.effort } : {}),
+        });
+    }
+    toTurnSandboxPolicy(sandbox) {
+        if (!sandbox)
+            return undefined;
+        if (sandbox === 'danger-full-access')
+            return { type: 'dangerFullAccess' };
+        if (sandbox === 'read-only')
+            return { type: 'readOnly', networkAccess: true };
+        if (sandbox === 'workspace-write') {
+            return {
+                type: 'workspaceWrite',
+                writableRoots: [],
+                networkAccess: true,
+                excludeTmpdirEnvVar: false,
+                excludeSlashTmp: false,
+            };
+        }
+        return undefined;
+    }
+    async threadRead(threadId, includeTurns = true) {
+        return this.request('thread/read', { threadId, includeTurns });
+    }
+    async threadRollback(threadId, numTurns) {
+        return this.request('thread/rollback', { threadId, numTurns });
+    }
+    async threadFork(threadId, projectPath, title, options) {
+        const effort = options?.effort ?? this.options.effort;
+        const response = await this.request('thread/fork', {
+            threadId,
+            cwd: projectPath,
+            model: options?.model ?? this.options.model ?? null,
+            approvalsReviewer: options?.approvalsReviewer ?? this.options.approvalsReviewer ?? null,
+            config: this.buildThreadConfig(effort, options?.config),
+            excludeTurns: false,
+            persistExtendedHistory: false,
+        });
+        const forkedThreadId = response.thread?.id;
+        if (title && forkedThreadId) {
+            await this.threadSetName(forkedThreadId, title).catch(error => {
+                logger.debug(`[CodexAppServer] thread/name/set failed after fork: ${error}`);
+            });
+        }
+        return response;
+    }
+    buildThreadConfig(effort, config) {
+        const merged = { ...(config ?? {}) };
+        if (effort)
+            merged.model_reasoning_effort = effort;
+        return Object.keys(merged).length > 0 ? merged : null;
+    }
+    async threadCompactStart(threadId) {
+        await this.request('thread/compact/start', { threadId });
+        return true;
+    }
+    async threadTurnsList(threadId, limit) {
+        return this.request('thread/turns/list', {
+            threadId,
+            ...(limit ? { limit } : {}),
+            sortDirection: 'asc',
+            itemsView: 'full',
+        });
+    }
+    async threadTurnsItemsList(threadId, turnId, limit) {
+        return this.request('thread/turns/items/list', {
+            threadId,
+            turnId,
+            ...(limit ? { limit } : {}),
+            sortDirection: 'asc',
+        });
+    }
+    async threadSetName(threadId, name) {
+        await this.request('thread/name/set', { threadId, name });
+        return true;
+    }
+    async threadMetadataUpdate(threadId, gitInfo) {
+        const params = { threadId };
+        if (gitInfo) {
+            params.gitInfo = Object.fromEntries(Object.entries(gitInfo).filter((entry) => entry[1] !== undefined));
+        }
+        await this.request('thread/metadata/update', params);
+        return true;
+    }
+    async turnInterrupt(threadId, turnId) {
+        await this.request('turn/interrupt', { threadId, turnId });
+        return true;
+    }
+    async modelList(includeHidden = false) {
+        return this.request('model/list', { includeHidden });
+    }
+    async modelProviderCapabilitiesRead() {
+        return this.request('modelProvider/capabilities/read', {});
+    }
+    async close() {
+        const proc = this.proc;
+        this.proc = null;
+        this.initialized = false;
+        for (const pending of this.pending.values()) {
+            pending.reject(new Error('Codex app-server closed'));
+        }
+        this.pending.clear();
+        if (!proc)
+            return;
+        proc.stdin.end();
+        proc.kill('SIGTERM');
+    }
+    async ensureStarted() {
+        if (this.initialized)
+            return;
+        if (!this.proc)
+            this.startProcess();
+        await this.request('initialize', {
+            clientInfo: {
+                name: 'evolclaw_codex_app_server',
+                title: 'EvolClaw Codex App Server Client',
+                version: '1.0.0',
+            },
+            capabilities: { experimentalApi: true },
+        });
+        this.notify('initialized');
+        this.initialized = true;
+    }
+    startProcess() {
+        const env = { ...process.env, ...this.options.env };
+        env.CODEX_API_KEY = this.options.apiKey;
+        if (this.options.baseUrl) {
+            env.OPENAI_BASE_URL = this.options.baseUrl;
+        }
+        const args = this.buildProcessArgs();
+        this.proc = spawn('codex', args, {
+            cwd: this.options.cwd,
+            env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.proc.once('error', error => this.failAll(error));
+        this.proc.once('exit', (code, signal) => {
+            this.failAll(new Error(`Codex app-server exited: code=${code ?? 'null'} signal=${signal ?? 'null'}`));
+        });
+        const rl = readline.createInterface({ input: this.proc.stdout, crlfDelay: Infinity });
+        rl.on('line', line => this.handleLine(line));
+        this.proc.stderr.on('data', chunk => {
+            const text = String(chunk).trim();
+            if (!text)
+                return;
+            this.stderrBuffer.push(text);
+            if (this.stderrBuffer.length > 20)
+                this.stderrBuffer.shift();
+            logger.debug(`[CodexAppServer] ${text}`);
+        });
+    }
+    buildProcessArgs() {
+        const args = ['app-server', '--listen', 'stdio://'];
+        if (this.options.enableRequestUserInput !== false) {
+            args.push('--enable', 'default_mode_request_user_input');
+        }
+        if (this.options.baseUrl) {
+            args.push('--config', `openai_base_url=${JSON.stringify(this.options.baseUrl)}`);
+        }
+        if (this.options.effort) {
+            args.push('--config', `model_reasoning_effort=${JSON.stringify(this.options.effort)}`);
+        }
+        return args;
+    }
+    async request(method, params) {
+        await this.ensureReadyFor(method);
+        const proc = this.proc;
+        if (!proc)
+            throw new Error('Codex app-server is not running');
+        const id = String(this.nextId++);
+        const payload = { id, method };
+        if (params !== undefined && params !== null)
+            payload.params = params;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject, method, params });
+            proc.stdin.write(`${JSON.stringify(payload)}\n`, error => {
+                if (!error)
+                    return;
+                this.pending.delete(id);
+                reject(error);
+            });
+        });
+    }
+    respond(id, result) {
+        if (!this.proc)
+            return;
+        const payload = JSON.stringify({ id, result }) + '\n';
+        this.proc.stdin.write(payload, error => {
+            if (error)
+                logger.warn(`[CodexAppServer] failed to write response id=${id}: ${error.message}`);
+        });
+    }
+    respondError(id, error) {
+        if (!this.proc)
+            return;
+        const payload = JSON.stringify({ id, error: { message: error.message } }) + '\n';
+        this.proc.stdin.write(payload, writeError => {
+            if (writeError)
+                logger.warn(`[CodexAppServer] failed to write error response id=${id}: ${writeError.message}`);
+        });
+    }
+    notify(method, params) {
+        if (!this.proc)
+            return;
+        const payload = { method };
+        if (params !== undefined && params !== null)
+            payload.params = params;
+        this.proc.stdin.write(`${JSON.stringify(payload)}\n`);
+    }
+    async ensureReadyFor(method) {
+        if (method === 'initialize') {
+            if (!this.proc)
+                this.startProcess();
+            return;
+        }
+        await this.ensureStarted();
+    }
+    handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            logger.debug(`[CodexAppServer] Ignoring non-JSON line: ${line}`);
+            return;
+        }
+        const rawId = message.id;
+        if (typeof message.method === 'string') {
+            if (rawId === undefined) {
+                this.emitNotification({ method: message.method, params: message.params });
+            }
+            else {
+                this.handleServerRequest({ id: rawId, method: message.method, params: message.params });
+            }
+            return;
+        }
+        if (rawId === undefined)
+            return;
+        const messageId = String(rawId);
+        const pending = this.pending.get(messageId);
+        if (!pending)
+            return;
+        this.pending.delete(messageId);
+        if (message.error) {
+            const detail = typeof message.error?.message === 'string' ? message.error.message : JSON.stringify(message.error);
+            const stderr = this.stderrBuffer.length ? `\n${this.stderrBuffer.join('\n')}` : '';
+            pending.reject(new Error(`${pending.method} failed: ${detail}${stderr}`));
+            return;
+        }
+        pending.resolve(message.result ?? null);
+    }
+    handleServerRequest(request) {
+        const handler = this.options.onServerRequest;
+        logger.info(`[CodexAppServer] server request id=${request.id} method=${request.method}`);
+        if (!handler) {
+            logger.warn(`[CodexAppServer] unsupported server request id=${request.id} method=${request.method}`);
+            this.respondError(request.id, new Error('Unsupported Codex app-server request: ' + request.method));
+            return;
+        }
+        Promise.resolve(handler(request))
+            .then(result => {
+            logger.info(`[CodexAppServer] server response id=${request.id} method=${request.method} result=${JSON.stringify(result ?? null)}`);
+            this.respond(request.id, result ?? null);
+        })
+            .catch(error => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            logger.warn(`[CodexAppServer] server request failed id=${request.id} method=${request.method}: ${err.message}`);
+            this.respondError(request.id, err);
+        });
+    }
+    emitNotification(notification) {
+        this.resolveSyntheticResponses(notification);
+        for (const handler of this.notificationHandlers) {
+            try {
+                handler(notification);
+            }
+            catch (error) {
+                logger.debug(`[CodexAppServer] notification handler failed: ${error}`);
+            }
+        }
+    }
+    resolveSyntheticResponses(notification) {
+        if (notification.method !== 'thread/compacted')
+            return;
+        const threadId = typeof notification.params?.threadId === 'string'
+            ? notification.params.threadId
+            : typeof notification.params?.thread_id === 'string'
+                ? notification.params.thread_id
+                : undefined;
+        if (!threadId)
+            return;
+        for (const [id, pending] of this.pending.entries()) {
+            const pendingThreadId = typeof pending.params?.threadId === 'string' ? pending.params.threadId : undefined;
+            if (pending.method !== 'thread/compact/start' || pendingThreadId !== threadId)
+                continue;
+            this.pending.delete(id);
+            logger.info(`[CodexAppServer] resolved pending thread/compact/start id=${id} from thread/compacted thread=${threadId}`);
+            pending.resolve({});
+        }
+    }
+    failAll(error) {
+        if (this.proc)
+            this.proc = null;
+        this.initialized = false;
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}