@ai-sdk/harness-codex 0.0.0-6b196531-20260710185421

package/src/bridge/tool-relay-auth.ts

@@ -0,0 +1,195 @@
+import { readdir, readFile, readlink } from 'node:fs/promises';
+import type { Socket } from 'node:net';
+
+export type ToolRelayCall = {
+  toolName: string;
+  input: unknown;
+};
+
+export type ToolRelayResult = {
+  output: unknown;
+  isError?: boolean;
+};
+
+export class ToolRelayAuthorizer {
+  private readonly ttlMs: number;
+  private readonly now: () => number;
+  private readonly authorizations: Array<{
+    key?: string;
+    expiresAt: number;
+  }> = [];
+
+  constructor({
+    ttlMs = 10_000,
+    now = Date.now,
+  }: {
+    ttlMs?: number;
+    now?: () => number;
+  } = {}) {
+    this.ttlMs = ttlMs;
+    this.now = now;
+  }
+
+  authorizeToolCall(call: ToolRelayCall): void {
+    this.pruneExpired();
+    this.authorizations.push({
+      key: toolRelayCallKey(call),
+      expiresAt: this.now() + this.ttlMs,
+    });
+  }
+
+  authorizeAnyToolCall(): void {
+    this.pruneExpired();
+    this.authorizations.push({
+      expiresAt: this.now() + this.ttlMs,
+    });
+  }
+
+  consumeToolCall(call: ToolRelayCall): boolean {
+    this.pruneExpired();
+    const key = toolRelayCallKey(call);
+    let index = this.authorizations.findIndex(auth => auth.key === key);
+    if (index === -1) {
+      index = this.authorizations.findIndex(auth => auth.key === undefined);
+    }
+    if (index === -1) return false;
+    this.authorizations.splice(index, 1);
+    return true;
+  }
+
+  private pruneExpired(): void {
+    const now = this.now();
+    for (let i = this.authorizations.length - 1; i >= 0; i--) {
+      if (this.authorizations[i].expiresAt <= now) {
+        this.authorizations.splice(i, 1);
+      }
+    }
+  }
+}
+
+export class ToolRelayPendingCalls {
+  private readonly calls = new Map<string, Promise<ToolRelayResult>>();
+
+  begin({
+    call,
+    run,
+  }: {
+    call: ToolRelayCall;
+    run: () => Promise<ToolRelayResult>;
+  }): { result: Promise<ToolRelayResult>; isNew: boolean } {
+    const key = toolRelayCallKey(call);
+    const existing = this.calls.get(key);
+    if (existing) return { result: existing, isNew: false };
+
+    const result = run();
+    this.calls.set(key, result);
+    void result
+      .finally(() => {
+        if (this.calls.get(key) === result) {
+          this.calls.delete(key);
+        }
+      })
+      .catch(() => {});
+    return { result, isNew: true };
+  }
+}
+
+function toolRelayCallKey({ toolName, input }: ToolRelayCall): string {
+  return `${toolName}\0${canonicalJson(input ?? {})}`;
+}
+
+function canonicalJson(value: unknown): string {
+  return JSON.stringify(normalizeJsonValue(value));
+}
+
+function normalizeJsonValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(normalizeJsonValue);
+  }
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>)
+        .filter(([, entryValue]) => entryValue !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entryValue]) => [key, normalizeJsonValue(entryValue)]),
+    );
+  }
+  return value;
+}
+
+export async function isToolRelayRequestFromAllowedProcess({
+  socket,
+  allowedScriptPaths,
+}: {
+  socket: Socket;
+  allowedScriptPaths: ReadonlySet<string>;
+}): Promise<boolean> {
+  if (process.platform !== 'linux') return false;
+  if (!socket.remotePort || !socket.localPort) return false;
+
+  const inode = await findTcpSocketInode({
+    clientPort: socket.remotePort,
+    serverPort: socket.localPort,
+  });
+  if (!inode) return false;
+
+  const cmdline = await findProcessCmdlineForSocketInode({ inode });
+  return cmdline?.some(arg => allowedScriptPaths.has(arg)) ?? false;
+}
+
+async function findTcpSocketInode({
+  clientPort,
+  serverPort,
+}: {
+  clientPort: number;
+  serverPort: number;
+}): Promise<string | undefined> {
+  for (const tablePath of ['/proc/net/tcp', '/proc/net/tcp6']) {
+    const table = await readFile(tablePath, 'utf8').catch(() => undefined);
+    if (!table) continue;
+    for (const line of table.split('\n').slice(1)) {
+      const columns = line.trim().split(/\s+/);
+      if (columns.length < 10) continue;
+      const local = parseProcNetAddress(columns[1]);
+      const remote = parseProcNetAddress(columns[2]);
+      if (
+        local?.port === clientPort &&
+        remote?.port === serverPort &&
+        columns[9] !== '0'
+      ) {
+        return columns[9];
+      }
+    }
+  }
+  return undefined;
+}
+
+function parseProcNetAddress(value: string): { port: number } | undefined {
+  const [, portHex] = value.split(':');
+  if (!portHex) return undefined;
+  return { port: Number.parseInt(portHex, 16) };
+}
+
+async function findProcessCmdlineForSocketInode({
+  inode,
+}: {
+  inode: string;
+}): Promise<string[] | undefined> {
+  const procEntries = await readdir('/proc', { withFileTypes: true }).catch(
+    () => [],
+  );
+  for (const entry of procEntries) {
+    if (!entry.isDirectory() || !/^\d+$/.test(entry.name)) continue;
+    const fdDir = `/proc/${entry.name}/fd`;
+    const fds = await readdir(fdDir).catch(() => []);
+    for (const fd of fds) {
+      const target = await readlink(`${fdDir}/${fd}`).catch(() => undefined);
+      if (target !== `socket:[${inode}]`) continue;
+      const cmdline = await readFile(`/proc/${entry.name}/cmdline`, 'utf8')
+        .then(value => value.split('\0').filter(Boolean))
+        .catch(() => undefined);
+      if (cmdline) return cmdline;
+    }
+  }
+  return undefined;
+}

package/src/codex-auth.ts

@@ -0,0 +1,119 @@
+import { getAiGatewayAuthFromEnv } from '@ai-sdk/harness/utils';
+
+export type CodexAuthOptions = {
+  readonly openaiCompatible?: {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly modelProviderName?: string;
+    readonly queryParamsJson?: string;
+  };
+  readonly openai?: {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly organization?: string;
+    readonly project?: string;
+  };
+  readonly gateway?: {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+  };
+};
+
+/**
+ * Resolve the environment-variable blob the codex bridge needs. Precedence:
+ *
+ *   1. Explicit `auth.openaiCompatible` — pin to a custom OpenAI-compatible endpoint.
+ *   2. Explicit `auth.openai` — pin to direct OpenAI auth.
+ *   3. Explicit `auth.gateway` — pin to Vercel AI Gateway.
+ *   4. Auto-detect from the host process env: gateway first
+ *      (`AI_GATEWAY_API_KEY` / `VERCEL_OIDC_TOKEN`), then `CODEX_API_KEY` /
+ *      `OPENAI_API_KEY`.
+ */
+export function resolveCodexEnv(
+  auth: CodexAuthOptions | undefined,
+  processEnv: Record<string, string | undefined> = process.env,
+): Record<string, string> {
+  if (auth?.openaiCompatible) {
+    return pickOpenAICompatible(auth.openaiCompatible, processEnv);
+  }
+  if (auth?.openai) {
+    return pickOpenAI({ explicit: auth.openai, processEnv });
+  }
+  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({
+    env: processEnv,
+  });
+  if (auth?.gateway) {
+    return pickGateway({
+      explicit: auth.gateway,
+      gatewayAuthFromEnv,
+    });
+  }
+  if (gatewayAuthFromEnv.apiKey) {
+    return pickGateway({
+      explicit: {},
+      gatewayAuthFromEnv,
+    });
+  }
+  return pickOpenAI({ processEnv });
+}
+
+function pickOpenAICompatible(
+  explicit: NonNullable<CodexAuthOptions['openaiCompatible']>,
+  processEnv: Record<string, string | undefined>,
+): Record<string, string> {
+  const env: Record<string, string> = {};
+  const apiKey =
+    explicit.apiKey ?? processEnv.OPENAI_API_KEY ?? processEnv.CODEX_API_KEY;
+  if (apiKey) env.CODEX_API_KEY = apiKey;
+  if (explicit.baseUrl) env.OPENAI_BASE_URL = explicit.baseUrl;
+  if (explicit.modelProviderName)
+    env.CODEX_MODEL_PROVIDER_NAME = explicit.modelProviderName;
+  if (explicit.queryParamsJson)
+    env.OPENAI_QUERY_PARAMS_JSON = explicit.queryParamsJson;
+  return env;
+}
+
+function pickOpenAI({
+  explicit,
+  processEnv,
+}: {
+  explicit?: NonNullable<CodexAuthOptions['openai']>;
+  processEnv: Record<string, string | undefined>;
+}): Record<string, string> {
+  const env: Record<string, string> = {};
+  const apiKey =
+    explicit?.apiKey ?? processEnv.OPENAI_API_KEY ?? processEnv.CODEX_API_KEY;
+  if (apiKey) env.CODEX_API_KEY = apiKey;
+  const baseUrl = explicit?.baseUrl ?? processEnv.OPENAI_BASE_URL;
+  if (baseUrl) env.OPENAI_BASE_URL = baseUrl;
+  const organization = explicit?.organization ?? processEnv.OPENAI_ORGANIZATION;
+  if (organization) env.OPENAI_ORGANIZATION = organization;
+  const project = explicit?.project ?? processEnv.OPENAI_PROJECT;
+  if (project) env.OPENAI_PROJECT = project;
+  return env;
+}
+
+function pickGateway({
+  explicit,
+  gatewayAuthFromEnv,
+}: {
+  explicit: NonNullable<CodexAuthOptions['gateway']>;
+  gatewayAuthFromEnv: ReturnType<typeof getAiGatewayAuthFromEnv>;
+}): Record<string, string> {
+  const apiKey = explicit.apiKey ?? gatewayAuthFromEnv.apiKey;
+  const baseUrl = toCodexGatewayBaseUrl(
+    explicit.baseUrl ?? gatewayAuthFromEnv.baseUrl,
+  );
+  const env: Record<string, string> = {};
+  if (apiKey) {
+    env.AI_GATEWAY_API_KEY = apiKey;
+    env.CODEX_API_KEY = apiKey;
+  }
+  env.AI_GATEWAY_BASE_URL = baseUrl;
+  return env;
+}
+
+function toCodexGatewayBaseUrl(baseUrl: string): string {
+  const trimmed = baseUrl.replace(/\/+$/, '');
+  return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`;
+}

package/src/codex-bridge-protocol.ts

@@ -0,0 +1,38 @@
+import {
+  harnessV1BridgeInboundCommandSchemas,
+  harnessV1BridgeOutboundMessageSchema,
+  harnessV1BridgeReadySchema,
+  harnessV1BridgeStartBaseSchema,
+} from '@ai-sdk/harness';
+import { z } from 'zod/v4';
+
+/*
+ * Codex's bridge wire protocol. The outbound events (including `file-change`
+ * and the `bridge-thread` resume coordinate), transport frames, shared inbound
+ * commands, and `bridge-ready` line all come from the shared `@ai-sdk/harness`
+ * protocol — the only Codex-specific piece is the `start` payload.
+ */
+
+export const outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+export type OutboundMessage = z.infer<typeof outboundMessageSchema>;
+
+export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+  reasoningEffort: z.enum(['low', 'medium', 'high']).optional(),
+  webSearch: z.boolean().optional(),
+  // Resume signal. When supplied, the bridge calls
+  // `codex.resumeThread(resumeThreadId, …)` instead of starting a fresh thread.
+  // The host sources the id from lifecycle state `data` cached from a prior
+  // `agent.detach`.
+  resumeThreadId: z.string().optional(),
+});
+
+export type StartMessage = z.infer<typeof startMessageSchema>;
+
+export const inboundMessageSchema = z.discriminatedUnion('type', [
+  startMessageSchema,
+  ...harnessV1BridgeInboundCommandSchemas,
+]);
+export type InboundMessage = z.infer<typeof inboundMessageSchema>;
+
+export const bridgeReadySchema = harnessV1BridgeReadySchema;
+export type BridgeReady = z.infer<typeof bridgeReadySchema>;