@walkhi/code-relax 0.1.0-beta.1

package/dist/src/app-server-client.mjs

@@ -0,0 +1,468 @@
+import { execFileSync, spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+
+const DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_CLOSE_TIMEOUT_MS = 3_000;
+const DEFAULT_STDERR_LIMIT = 16_000;
+const DEFAULT_NOTIFICATION_LIMIT = 1_000;
+export const APP_SERVER_SCHEMA_VERSION = '0.154.0';
+
+export const APP_SERVER_REQUIRED_METHODS = Object.freeze([
+  'initialize',
+  'model/list',
+  'thread/start',
+  'thread/list',
+  'thread/read',
+  'thread/name/set',
+  'thread/delete',
+  'thread/turns/list',
+  'thread/items/list',
+  'turn/start',
+  'turn/steer',
+  'turn/interrupt',
+  'account/rateLimits/read',
+]);
+
+export function locateCodexCliJs(environment = process.env) {
+  if (environment.CODEX_CLI_JS) {
+    const explicit = path.resolve(environment.CODEX_CLI_JS);
+    if (!fs.existsSync(explicit)) throw new Error(`CODEX_CLI_JS 指向的文件不存在：${explicit}`);
+    return explicit;
+  }
+
+  const candidates = [];
+  if (environment.APPDATA) {
+    candidates.push(path.join(environment.APPDATA, 'npm', 'node_modules', '@openai', 'codex', 'bin', 'codex.js'));
+  }
+  if (process.platform === 'win32') {
+    try {
+      const launchers = execFileSync('where.exe', ['codex.cmd'], { encoding: 'utf8' })
+        .split(/\r?\n/)
+        .map(value => value.trim())
+        .filter(Boolean);
+      for (const launcher of launchers) {
+        candidates.push(path.join(path.dirname(launcher), 'node_modules', '@openai', 'codex', 'bin', 'codex.js'));
+      }
+    } catch {
+      // The explicit error below includes the supported override.
+    }
+  }
+
+  const installed = [...new Set(candidates.map(value => path.resolve(value)))]
+    .filter(value => fs.existsSync(value))
+    .map(value => ({ path: value, version: parseCodexCliVersion(readCodexCliVersion(value)) }));
+  installed.sort((left, right) => compareVersionTuple(right.version, left.version));
+  if (!installed.length) {
+    throw new Error('找不到 Codex CLI。可通过 CODEX_CLI_JS 指定 @openai/codex/bin/codex.js。');
+  }
+  return installed[0].path;
+}
+
+export function readCodexCliVersion(cliJs, nodePath = process.execPath) {
+  if (!cliJs) return '';
+  try {
+    return execFileSync(nodePath, [cliJs, '--version'], {
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: 10_000,
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+export function parseCodexCliVersion(value) {
+  const match = String(value || '').match(/(\d+)\.(\d+)\.(\d+)/);
+  return match ? match.slice(1).map(Number) : [0, 0, 0];
+}
+
+function compareVersionTuple(left, right) {
+  for (let index = 0; index < 3; index += 1) {
+    if (left[index] !== right[index]) return left[index] - right[index];
+  }
+  return 0;
+}
+
+export class AppServerRpcError extends Error {
+  constructor(method, rpcError) {
+    super(`${method} 失败：${rpcError?.message || JSON.stringify(rpcError)}`);
+    this.name = 'AppServerRpcError';
+    this.method = method;
+    this.code = rpcError?.code;
+    this.data = rpcError?.data;
+  }
+}
+
+export class AppServerClient extends EventEmitter {
+  constructor({
+    cliJs,
+    cwd = process.cwd(),
+    environment = process.env,
+    nodePath = process.execPath,
+    command,
+    args,
+    requestTimeoutMs = DEFAULT_TIMEOUT_MS,
+    closeTimeoutMs = DEFAULT_CLOSE_TIMEOUT_MS,
+    stderrLimit = DEFAULT_STDERR_LIMIT,
+    notificationLimit = DEFAULT_NOTIFICATION_LIMIT,
+    initializeParams,
+  } = {}) {
+    super();
+    this.cliJs = cliJs || null;
+    this.cwd = path.resolve(cwd);
+    this.environment = environment;
+    this.nodePath = nodePath;
+    this.command = command || nodePath;
+    this.args = args || null;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.closeTimeoutMs = closeTimeoutMs;
+    this.stderrLimit = stderrLimit;
+    this.notificationLimit = notificationLimit;
+    this.initializeParams = initializeParams || {
+      clientInfo: {
+        name: 'codex_remote_bridge',
+        title: 'Code Relax Bridge',
+        version: '0.1.0',
+      },
+      capabilities: { experimentalApi: true },
+    };
+
+    this.child = null;
+    this.lines = null;
+    this.state = 'idle';
+    this.nextId = 1;
+    this.pending = new Map();
+    this.serverRequests = new Map();
+    this.notifications = [];
+    this.notificationSequence = 0;
+    this.notificationWaiters = new Set();
+    this.stderr = '';
+    this.initializeResult = null;
+    this.cliVersion = '';
+    this.startedAt = null;
+    this.lastExit = null;
+    this.startPromise = null;
+    this.closePromise = null;
+    this.closing = false;
+    this.generation = 0;
+  }
+
+  snapshot() {
+    return {
+      state: this.state,
+      pid: this.child?.pid || null,
+      cliJs: this.cliJs,
+      cliVersion: this.cliVersion,
+      startedAt: this.startedAt,
+      lastExit: this.lastExit,
+      pendingRequestCount: this.pending.size,
+      pendingServerRequestCount: this.serverRequests.size,
+      schemaVersion: APP_SERVER_SCHEMA_VERSION,
+      requiredMethods: APP_SERVER_REQUIRED_METHODS,
+    };
+  }
+
+  async start() {
+    if (this.state === 'ready') return this.snapshot();
+    if (this.startPromise) return this.startPromise;
+    if (this.state === 'closing') throw new Error('app-server 正在关闭。');
+
+    this.startPromise = this.startSession();
+    try {
+      return await this.startPromise;
+    } finally {
+      this.startPromise = null;
+    }
+  }
+
+  async startSession() {
+    this.closing = false;
+    this.stderr = '';
+    this.initializeResult = null;
+    this.lastExit = null;
+    this.generation += 1;
+    this.setState('starting');
+    try {
+      if (!this.args) this.cliJs ||= locateCodexCliJs(this.environment);
+      this.cliVersion = readCodexCliVersion(this.cliJs, this.nodePath);
+      if (!this.args && !this.cliVersion.includes(APP_SERVER_SCHEMA_VERSION)) {
+        throw new Error(`当前迁移层只验证了 codex-cli ${APP_SERVER_SCHEMA_VERSION}，实际为 ${this.cliVersion || '未知版本'}。`);
+      }
+    } catch (error) {
+      this.setState('failed');
+      throw error;
+    }
+    const args = this.args || [this.cliJs, 'app-server', '--listen', 'stdio://'];
+
+    const child = spawn(this.command, args, {
+      cwd: this.cwd,
+      env: this.environment,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    this.child = child;
+    const generation = this.generation;
+    child.stderr.on('data', chunk => {
+      this.stderr = `${this.stderr}${chunk}`.slice(-this.stderrLimit);
+    });
+    child.once('error', error => this.handleProcessFailure(error, generation));
+    child.once('exit', (code, signal) => this.handleProcessExit(code, signal, generation));
+    this.lines = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+    this.lines.on('line', line => this.handleLine(line, generation));
+
+    try {
+      this.initializeResult = await this.sendRequest('initialize', this.initializeParams, this.requestTimeoutMs);
+      this.send({ method: 'initialized', params: {} });
+      this.startedAt = new Date().toISOString();
+      this.setState('ready');
+      return this.snapshot();
+    } catch (error) {
+      if (generation === this.generation && !this.closing) {
+        this.setState('failed');
+        if (child.exitCode === null) child.kill();
+      }
+      throw error;
+    }
+  }
+
+  async request(method, params = {}, timeoutMs = this.requestTimeoutMs) {
+    if (this.state !== 'ready') await this.start();
+    return this.sendRequest(method, params, timeoutMs);
+  }
+
+  notify(method, params = {}) {
+    if (this.state !== 'ready' && method !== 'initialized') {
+      throw new Error('app-server 尚未就绪。');
+    }
+    this.send({ method, params });
+  }
+
+  waitForNotification(method, predicate = () => true, {
+    afterSequence = 0,
+    timeoutMs = this.requestTimeoutMs,
+  } = {}) {
+    const existing = this.notifications.find(record => record.sequence > afterSequence
+      && record.method === method && predicate(record.params));
+    if (existing) return Promise.resolve(existing.params);
+    if (!['starting', 'ready'].includes(this.state)) {
+      return Promise.reject(new Error(`app-server 当前状态为 ${this.state}，无法等待通知。`));
+    }
+
+    return new Promise((resolve, reject) => {
+      const waiter = { method, predicate, afterSequence, resolve, reject, timer: null };
+      waiter.timer = setTimeout(() => {
+        this.notificationWaiters.delete(waiter);
+        reject(new Error(`等待 ${method} 超时（${timeoutMs} ms）。${this.stderrSuffix()}`));
+      }, timeoutMs);
+      waiter.timer.unref?.();
+      this.notificationWaiters.add(waiter);
+    });
+  }
+
+  listServerRequests() {
+    return [...this.serverRequests.values()].map(request => ({
+      id: request.id,
+      method: request.method,
+      params: request.params,
+      receivedAt: request.receivedAt,
+      generation: request.generation,
+    }));
+  }
+
+  respondServerRequest(id, result) {
+    const request = this.takeServerRequest(id);
+    this.send({ id: request.id, result });
+  }
+
+  rejectServerRequest(id, code, message, data) {
+    const request = this.takeServerRequest(id);
+    const error = { code, message };
+    if (data !== undefined) error.data = data;
+    this.send({ id: request.id, error });
+  }
+
+  takeServerRequest(id) {
+    const request = this.serverRequests.get(id);
+    if (!request || request.generation !== this.generation) {
+      throw new Error('app-server 反向请求不存在或已经失效。');
+    }
+    this.serverRequests.delete(id);
+    return request;
+  }
+
+  async close() {
+    if (this.closePromise) return this.closePromise;
+    if (!this.child || ['idle', 'closed'].includes(this.state)) {
+      this.setState('closed');
+      return;
+    }
+
+    this.closePromise = this.closeSession();
+    try {
+      await this.closePromise;
+    } finally {
+      this.closePromise = null;
+    }
+  }
+
+  async closeSession() {
+    this.closing = true;
+    this.setState('closing');
+    const child = this.child;
+    this.rejectAll(new Error('app-server 连接正在关闭。'));
+    this.invalidateServerRequests('client-closed');
+    child.stdin.end();
+    if (child.exitCode === null) {
+      await Promise.race([
+        new Promise(resolve => child.once('exit', resolve)),
+        new Promise(resolve => {
+          const timer = setTimeout(resolve, this.closeTimeoutMs);
+          timer.unref?.();
+        }),
+      ]);
+    }
+    if (child.exitCode === null) child.kill();
+    if (this.child === child) this.child = null;
+    this.lines?.close();
+    this.lines = null;
+    this.setState('closed');
+  }
+
+  sendRequest(method, params, timeoutMs) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} 超时（${timeoutMs} ms）。${this.stderrSuffix()}`));
+      }, timeoutMs);
+      timer.unref?.();
+      this.pending.set(id, { method, resolve, reject, timer, generation: this.generation });
+      try {
+        this.send({ method, id, params });
+      } catch (error) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(error);
+      }
+    });
+  }
+
+  send(message) {
+    if (!this.child || this.child.stdin.destroyed || !this.child.stdin.writable) {
+      throw new Error('app-server 输入通道不可用。');
+    }
+    this.child.stdin.write(`${JSON.stringify(message)}\n`);
+  }
+
+  handleLine(line, generation) {
+    if (generation !== this.generation) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch (error) {
+      this.emit('protocol-error', new Error('app-server 返回了无法解析的 JSON。', { cause: error }));
+      return;
+    }
+
+    if (Object.hasOwn(message, 'id') && !message.method) {
+      const pending = this.pending.get(message.id);
+      if (!pending || pending.generation !== generation) return;
+      clearTimeout(pending.timer);
+      this.pending.delete(message.id);
+      if (message.error) pending.reject(new AppServerRpcError(pending.method, message.error));
+      else pending.resolve(message.result);
+      return;
+    }
+
+    if (message.method && Object.hasOwn(message, 'id')) {
+      const request = {
+        id: message.id,
+        method: message.method,
+        params: message.params || {},
+        receivedAt: new Date().toISOString(),
+        generation,
+      };
+      this.serverRequests.set(message.id, request);
+      this.emit('server-request', request);
+      return;
+    }
+
+    if (!message.method) return;
+    const record = {
+      sequence: ++this.notificationSequence,
+      method: message.method,
+      params: message.params || {},
+    };
+    this.notifications.push(record);
+    if (this.notifications.length > this.notificationLimit) this.notifications.shift();
+    this.emit('notification', record);
+    this.emit(`notification:${message.method}`, record.params);
+    for (const waiter of [...this.notificationWaiters]) {
+      if (record.sequence <= waiter.afterSequence || waiter.method !== record.method) continue;
+      let matches = false;
+      try { matches = waiter.predicate(record.params); } catch (error) {
+        clearTimeout(waiter.timer);
+        this.notificationWaiters.delete(waiter);
+        waiter.reject(error);
+        continue;
+      }
+      if (!matches) continue;
+      clearTimeout(waiter.timer);
+      this.notificationWaiters.delete(waiter);
+      waiter.resolve(record.params);
+    }
+  }
+
+  handleProcessFailure(error, generation) {
+    if (generation !== this.generation) return;
+    this.rejectAll(error);
+    if (!this.closing) this.setState('failed');
+  }
+
+  handleProcessExit(code, signal, generation) {
+    if (generation !== this.generation) return;
+    const wasClosing = this.closing;
+    this.lastExit = { code, signal: signal || null, at: new Date().toISOString() };
+    this.child = null;
+    this.lines?.close();
+    this.lines = null;
+    const error = new Error(`app-server 已退出：code=${code}, signal=${signal || 'none'}。${this.stderrSuffix()}`);
+    this.rejectAll(error);
+    this.invalidateServerRequests('process-exited');
+    this.setState(wasClosing ? 'closed' : 'failed');
+    this.emit('exit', this.lastExit);
+  }
+
+  rejectAll(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+    for (const waiter of this.notificationWaiters) {
+      clearTimeout(waiter.timer);
+      waiter.reject(error);
+    }
+    this.notificationWaiters.clear();
+  }
+
+  invalidateServerRequests(reason) {
+    if (!this.serverRequests.size) return;
+    const requests = this.listServerRequests();
+    this.serverRequests.clear();
+    this.emit('server-requests-invalidated', { reason, requests });
+  }
+
+  stderrSuffix() {
+    return this.stderr ? `\n${this.stderr}` : '';
+  }
+
+  setState(state) {
+    if (this.state === state) return;
+    this.state = state;
+    this.emit('state', this.snapshot());
+  }
+}