mcp-codex-worker 0.1.0

package/src/services/app-server-client.ts

@@ -0,0 +1,636 @@
+import { EventEmitter } from 'node:events';
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+
+import {
+  APP_NAME,
+  APP_TITLE,
+  OPERATION_BRIDGE_TIMEOUT_MS,
+  OPERATION_POLL_INTERVAL_MS,
+  REQUEST_TIMEOUT_MS,
+} from '../config/defaults.js';
+import type {
+  InitializeParams,
+  JsonLineMessage,
+  JsonLineNotification,
+  JsonLineRequest,
+  JsonLineResponse,
+  PendingServerRequest,
+  RequestId,
+  RuntimeOperation,
+} from '../types/codex.js';
+
+interface PendingRequestBinding {
+  resolve: (value: unknown) => void;
+  reject: (reason?: unknown) => void;
+  timeout: NodeJS.Timeout;
+}
+
+interface RequestOptions {
+  timeoutMs?: number | undefined;
+}
+
+interface RequestWithBridgeOptions extends RequestOptions {
+  threadId?: string | undefined;
+  bridgeTimeoutMs?: number | undefined;
+}
+
+interface WaitOptions {
+  timeoutMs?: number | undefined;
+  pollIntervalMs?: number | undefined;
+}
+
+export interface AppServerClientOptions {
+  command: string;
+  args: string[];
+  env: NodeJS.ProcessEnv;
+  codexHome: string;
+  appName?: string | undefined;
+  appVersion?: string | undefined;
+}
+
+export interface BridgedOperationResult {
+  status: 'completed' | 'pending_request' | 'running';
+  operationId: string;
+  requestId: RequestId;
+  pendingRequestIds: RequestId[];
+  result?: unknown;
+}
+
+const SERVER_REQUEST_METHODS = new Set([
+  'item/commandExecution/requestApproval',
+  'item/fileChange/requestApproval',
+  'item/tool/requestUserInput',
+  'mcpServer/elicitation/request',
+  'item/permissions/requestApproval',
+  'item/tool/call',
+  'account/chatgptAuthTokens/refresh',
+  'applyPatchApproval',
+  'execCommandApproval',
+]);
+
+const TURN_LIFECYCLE_METHODS = new Set([
+  'turn/start',
+  'turn/steer',
+  'review/start',
+]);
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  return value as Record<string, unknown>;
+}
+
+function requestIdKey(id: RequestId): string {
+  return typeof id === 'number' ? `n:${id}` : `s:${id}`;
+}
+
+export class AppServerClient extends EventEmitter {
+  private readonly options: AppServerClientOptions;
+  private readonly pendingRequests = new Map<string, PendingRequestBinding>();
+  private readonly serverRequests = new Map<string, PendingServerRequest>();
+  private readonly operations = new Map<string, RuntimeOperation>();
+  private readonly operationsByRequestId = new Map<string, string>();
+  private readonly threadEvents = new Map<string, unknown[]>();
+  private process?: ChildProcessWithoutNullStreams | undefined;
+  private nextRequestCounter = 1;
+  private nextOperationCounter = 1;
+  private buffer = '';
+  private started = false;
+
+  constructor(options: AppServerClientOptions) {
+    super();
+    this.options = options;
+  }
+
+  async start(): Promise<void> {
+    if (this.started) {
+      return;
+    }
+
+    const child = spawn(this.options.command, this.options.args, {
+      cwd: process.cwd(),
+      env: {
+        ...this.options.env,
+        CODEX_HOME: this.options.codexHome,
+      },
+      stdio: 'pipe',
+    });
+
+    this.process = child;
+    this.started = true;
+
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => this.consumeStdout(String(chunk)));
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+      this.emit('stderr', String(chunk));
+    });
+    child.on('exit', (code, signal) => {
+      const message = `Codex app-server exited (code=${String(code)}, signal=${String(signal)})`;
+      this.started = false;
+      this.process = undefined;
+      for (const binding of this.pendingRequests.values()) {
+        clearTimeout(binding.timeout);
+        binding.reject(new Error(message));
+      }
+      this.pendingRequests.clear();
+      this.emit('exit', { code, signal });
+    });
+
+    const initializeParams: InitializeParams = {
+      clientInfo: {
+        name: this.options.appName ?? APP_NAME,
+        title: APP_TITLE,
+        version: this.options.appVersion ?? '0.0.0',
+      },
+      capabilities: {
+        experimentalApi: false,
+        optOutNotificationMethods: null,
+      },
+    };
+
+    await this.request('initialize', initializeParams);
+  }
+
+  async stop(): Promise<void> {
+    if (!this.process) {
+      return;
+    }
+    this.process.kill('SIGTERM');
+    this.process = undefined;
+    this.started = false;
+  }
+
+  async request(method: string, params: unknown, options: RequestOptions = {}): Promise<unknown> {
+    const sent = this.sendRequest(method, params, options.timeoutMs);
+    return sent.promise;
+  }
+
+  async requestWithBridge(
+    method: string,
+    params: unknown,
+    options: RequestWithBridgeOptions = {},
+  ): Promise<BridgedOperationResult> {
+    const sent = this.sendRequest(method, params, options.timeoutMs);
+    const operationId = `op-${this.nextOperationCounter++}`;
+    const requestIdKeyValue = requestIdKey(sent.requestId);
+    const threadId = options.threadId ?? this.extractThreadIdFromParams(params);
+    const waitsForTurnCompletion = TURN_LIFECYCLE_METHODS.has(method);
+
+    const operation: RuntimeOperation = {
+      operationId,
+      requestId: sent.requestId,
+      method,
+      threadId,
+      startedAt: new Date().toISOString(),
+      status: 'running',
+      pendingRequestIds: [],
+    };
+    this.operations.set(operationId, operation);
+    this.operationsByRequestId.set(requestIdKeyValue, operationId);
+
+    sent.promise.then(
+      (result) => {
+        const current = this.operations.get(operationId);
+        if (!current) {
+          return;
+        }
+        current.result = result;
+        const turnId = this.extractTurnId(result);
+        if (turnId) {
+          current.turnId = turnId;
+        }
+        if (!waitsForTurnCompletion) {
+          current.status = 'completed';
+          current.completedAt = new Date().toISOString();
+        }
+      },
+      (error) => {
+        const current = this.operations.get(operationId);
+        if (!current) {
+          return;
+        }
+        current.status = 'failed';
+        current.completedAt = new Date().toISOString();
+        current.error = error instanceof Error ? error.message : String(error);
+      },
+    );
+
+    const bridgeTimeoutMs = options.bridgeTimeoutMs ?? OPERATION_BRIDGE_TIMEOUT_MS;
+    const result = await new Promise<BridgedOperationResult>((resolve, reject) => {
+      let settled = false;
+      const cleanup = () => {
+        this.off('server-request', onServerRequest);
+        this.off('notification', onNotification);
+        clearTimeout(timeout);
+      };
+      const resolveOnce = (value: BridgedOperationResult) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        resolve(value);
+      };
+      const rejectOnce = (error: unknown) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+      const snapshot = (): BridgedOperationResult => {
+        const current = this.operations.get(operationId);
+        return {
+          status: current?.status === 'completed' ? 'completed' : 'running',
+          operationId,
+          requestId: sent.requestId,
+          pendingRequestIds: [...(current?.pendingRequestIds ?? [])],
+          ...(current?.result !== undefined ? { result: current.result } : {}),
+        };
+      };
+
+      const onServerRequest = (pending: PendingServerRequest) => {
+        const current = this.operations.get(operationId);
+        if (!current || current.status !== 'running') {
+          return;
+        }
+        const pendingThreadId = this.extractThreadIdFromParams(pending.params);
+        if (threadId && pendingThreadId && pendingThreadId !== threadId) {
+          return;
+        }
+        if (!current.pendingRequestIds.some((id) => requestIdKey(id) === requestIdKey(pending.id))) {
+          current.pendingRequestIds.push(pending.id);
+        }
+        resolveOnce({
+          status: 'pending_request',
+          operationId,
+          requestId: sent.requestId,
+          pendingRequestIds: [...current.pendingRequestIds],
+        });
+      };
+      const onNotification = () => {
+        const current = this.operations.get(operationId);
+        if (!current || current.status === 'running') {
+          return;
+        }
+        if (current.status === 'failed') {
+          rejectOnce(new Error(current.error ?? `Operation ${operationId} failed.`));
+          return;
+        }
+        resolveOnce(snapshot());
+      };
+
+      this.on('server-request', onServerRequest);
+      this.on('notification', onNotification);
+
+      sent.promise.then((response) => {
+        const current = this.operations.get(operationId);
+        if (!waitsForTurnCompletion) {
+          resolveOnce({
+            status: 'completed',
+            operationId,
+            requestId: sent.requestId,
+            pendingRequestIds: [...(current?.pendingRequestIds ?? [])],
+            result: response,
+          });
+          return;
+        }
+        if (current?.status === 'completed') {
+          resolveOnce(snapshot());
+          return;
+        }
+        if (current?.status === 'failed') {
+          rejectOnce(new Error(current.error ?? `Operation ${operationId} failed.`));
+        }
+      }).catch((error) => {
+        rejectOnce(error);
+      });
+
+      const timeout = setTimeout(() => {
+        resolveOnce(snapshot());
+      }, bridgeTimeoutMs);
+      timeout.unref();
+    });
+
+    return result;
+  }
+
+  async waitForOperation(operationId: string, options: WaitOptions = {}): Promise<RuntimeOperation> {
+    const timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS;
+    const pollIntervalMs = options.pollIntervalMs ?? OPERATION_POLL_INTERVAL_MS;
+    const start = Date.now();
+
+    while (Date.now() - start <= timeoutMs) {
+      const operation = this.operations.get(operationId);
+      if (!operation) {
+        throw new Error(`Operation not found: ${operationId}`);
+      }
+      if (operation.status === 'completed' || operation.status === 'failed') {
+        return { ...operation, pendingRequestIds: [...operation.pendingRequestIds] };
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+
+    throw new Error(`Timed out waiting for operation ${operationId}`);
+  }
+
+  getOperation(operationId: string): RuntimeOperation | undefined {
+    const operation = this.operations.get(operationId);
+    if (!operation) {
+      return undefined;
+    }
+    return { ...operation, pendingRequestIds: [...operation.pendingRequestIds] };
+  }
+
+  listOperations(): RuntimeOperation[] {
+    return [...this.operations.values()].map((operation) => ({
+      ...operation,
+      pendingRequestIds: [...operation.pendingRequestIds],
+    }));
+  }
+
+  listServerRequests(includeResolved = false): PendingServerRequest[] {
+    return [...this.serverRequests.values()]
+      .filter((request) => includeResolved || request.status === 'pending')
+      .map((request) => ({ ...request }));
+  }
+
+  getServerRequest(id: RequestId): PendingServerRequest | undefined {
+    const request = this.serverRequests.get(requestIdKey(id));
+    return request ? { ...request } : undefined;
+  }
+
+  async respondToServerRequest(id: RequestId, payload: unknown): Promise<void> {
+    const requestKey = requestIdKey(id);
+    const request = this.serverRequests.get(requestKey);
+    if (!request) {
+      throw new Error(`Pending server request not found: ${String(id)}`);
+    }
+    if (!this.process || !this.started) {
+      throw new Error('Codex app-server is not running');
+    }
+
+    this.writeLine({
+      id,
+      result: payload,
+    });
+
+    request.response = payload;
+    request.status = 'resolved';
+    request.resolvedAt = new Date().toISOString();
+  }
+
+  getThreadEvents(threadId: string): unknown[] {
+    return [...(this.threadEvents.get(threadId) ?? [])];
+  }
+
+  private sendRequest(method: string, params: unknown, timeoutMs = REQUEST_TIMEOUT_MS): {
+    requestId: RequestId;
+    promise: Promise<unknown>;
+  } {
+    if (!this.process || !this.started) {
+      throw new Error('Codex app-server is not running');
+    }
+
+    const requestId: RequestId = `client-${this.nextRequestCounter++}`;
+    const key = requestIdKey(requestId);
+    const promise = new Promise<unknown>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(key);
+        reject(new Error(`Timed out waiting for ${method} response`));
+      }, timeoutMs);
+      timeout.unref();
+      this.pendingRequests.set(key, {
+        resolve,
+        reject,
+        timeout,
+      });
+    });
+
+    const message: JsonLineRequest = { method, id: requestId, params };
+    this.writeLine(message);
+    return { requestId, promise };
+  }
+
+  private consumeStdout(chunk: string): void {
+    this.buffer += chunk;
+    while (true) {
+      const lineBreak = this.buffer.indexOf('\n');
+      if (lineBreak === -1) {
+        return;
+      }
+
+      const line = this.buffer.slice(0, lineBreak).trim();
+      this.buffer = this.buffer.slice(lineBreak + 1);
+      if (!line) {
+        continue;
+      }
+
+      let message: JsonLineMessage;
+      try {
+        message = JSON.parse(line) as JsonLineMessage;
+      } catch (error) {
+        this.emit('parse-error', error);
+        continue;
+      }
+
+      this.handleMessage(message);
+    }
+  }
+
+  private handleMessage(message: JsonLineMessage): void {
+    const asResponse = asObject(message);
+    if (!asResponse) {
+      return;
+    }
+
+    const hasMethod = typeof asResponse.method === 'string';
+    const hasId = typeof asResponse.id === 'string' || typeof asResponse.id === 'number';
+
+    if (hasMethod && hasId) {
+      const request = message as JsonLineRequest;
+      const key = requestIdKey(request.id);
+      if (this.pendingRequests.has(key)) {
+        this.resolveClientRequest(request.id, request as unknown as JsonLineResponse);
+        return;
+      }
+      this.storeServerRequest(request);
+      return;
+    }
+
+    if (hasId) {
+      this.resolveClientRequest((message as JsonLineResponse).id, message as JsonLineResponse);
+      return;
+    }
+
+    if (hasMethod) {
+      this.handleNotification(message as JsonLineNotification);
+    }
+  }
+
+  private resolveClientRequest(id: RequestId, response: JsonLineResponse): void {
+    const key = requestIdKey(id);
+    const binding = this.pendingRequests.get(key);
+    if (!binding) {
+      return;
+    }
+
+    clearTimeout(binding.timeout);
+    this.pendingRequests.delete(key);
+    if ('error' in response && response.error !== undefined) {
+      binding.reject(
+        new Error(
+          typeof response.error === 'string'
+            ? response.error
+            : JSON.stringify(response.error),
+        ),
+      );
+      return;
+    }
+    binding.resolve(response.result);
+  }
+
+  private storeServerRequest(request: JsonLineRequest): void {
+    if (!SERVER_REQUEST_METHODS.has(request.method)) {
+      return;
+    }
+    const key = requestIdKey(request.id);
+    const pending: PendingServerRequest = {
+      id: request.id,
+      method: request.method,
+      params: request.params,
+      createdAt: new Date().toISOString(),
+      status: 'pending',
+    };
+    this.serverRequests.set(key, pending);
+    this.emit('server-request', pending);
+  }
+
+  private handleNotification(notification: JsonLineNotification): void {
+    if (notification.method === 'serverRequest/resolved') {
+      const params = asObject(notification.params);
+      const requestId = params?.requestId;
+      if (typeof requestId === 'string' || typeof requestId === 'number') {
+        const request = this.serverRequests.get(requestIdKey(requestId));
+        if (request) {
+          request.status = 'resolved';
+          request.resolvedAt = new Date().toISOString();
+        }
+      }
+    }
+
+    this.updateOperationsFromNotification(notification);
+
+    const threadId = this.extractThreadIdFromParams(notification.params);
+    if (threadId) {
+      const events = this.threadEvents.get(threadId) ?? [];
+      events.push({
+        receivedAt: new Date().toISOString(),
+        method: notification.method,
+        params: notification.params,
+      });
+      this.threadEvents.set(threadId, events.slice(-200));
+    }
+
+    this.emit('notification', notification);
+  }
+
+  private updateOperationsFromNotification(notification: JsonLineNotification): void {
+    const threadId = this.extractThreadIdFromParams(notification.params);
+    if (!threadId) {
+      return;
+    }
+
+    if (notification.method === 'turn/completed') {
+      const params = asObject(notification.params);
+      const turn = asObject(params?.turn);
+      const turnId = typeof turn?.id === 'string' ? turn.id : undefined;
+      const turnStatus = typeof turn?.status === 'string' ? turn.status : undefined;
+      for (const operation of this.operations.values()) {
+        if (operation.status !== 'running' || operation.threadId !== threadId || !TURN_LIFECYCLE_METHODS.has(operation.method)) {
+          continue;
+        }
+        if (turnId) {
+          operation.turnId = operation.turnId ?? turnId;
+          if (operation.turnId !== turnId) {
+            continue;
+          }
+        }
+        if (turnStatus === 'completed' || turnStatus === 'interrupted') {
+          operation.status = 'completed';
+          operation.completedAt = new Date().toISOString();
+          operation.result = { turn };
+        } else {
+          operation.status = 'failed';
+          operation.completedAt = new Date().toISOString();
+          operation.error = this.extractTurnError(turn) ?? `Turn finished with status ${turnStatus ?? 'unknown'}.`;
+          operation.result = { turn };
+        }
+      }
+      return;
+    }
+
+    if (notification.method === 'error') {
+      const params = asObject(notification.params);
+      const message = typeof params?.message === 'string' ? params.message : 'Codex reported an error.';
+      for (const operation of this.operations.values()) {
+        if (operation.status === 'running' && operation.threadId === threadId && TURN_LIFECYCLE_METHODS.has(operation.method)) {
+          operation.status = 'failed';
+          operation.completedAt = new Date().toISOString();
+          operation.error = message;
+        }
+      }
+    }
+  }
+
+  private extractThreadIdFromParams(params: unknown): string | undefined {
+    const object = asObject(params);
+    const threadId = object?.threadId;
+    if (typeof threadId === 'string') {
+      return threadId;
+    }
+    const thread = asObject(object?.thread);
+    const threadIdFromThread = thread?.id;
+    if (typeof threadIdFromThread === 'string') {
+      return threadIdFromThread;
+    }
+    return undefined;
+  }
+
+  private extractTurnId(payload: unknown): string | undefined {
+    const object = asObject(payload);
+    const turn = asObject(object?.turn);
+    if (typeof turn?.id === 'string') {
+      return turn.id;
+    }
+    if (typeof object?.turnId === 'string') {
+      return object.turnId;
+    }
+    return undefined;
+  }
+
+  private extractTurnError(turn: Record<string, unknown> | undefined): string | undefined {
+    if (!turn) {
+      return undefined;
+    }
+    const error = turn.error;
+    if (typeof error === 'string') {
+      return error;
+    }
+    const object = asObject(error);
+    if (typeof object?.message === 'string') {
+      return object.message;
+    }
+    return undefined;
+  }
+
+  private writeLine(message: JsonLineMessage | { id: RequestId; result: unknown }): void {
+    if (!this.process || !this.started) {
+      throw new Error('Codex app-server is not running');
+    }
+    this.process.stdin.write(`${JSON.stringify(message)}\n`);
+  }
+}