@orchestero/codex-gateway 0.0.3

package/lib/codex-app-server.ts

@@ -0,0 +1,450 @@
+type JsonRecord = Record<string, unknown>;
+type JsonRpcId = number | string;
+
+type JsonRpcMessage = JsonRecord & {
+  id?: JsonRpcId;
+  method?: string;
+  params?: unknown;
+};
+
+type CodexAppServerConnection = {
+  close: () => Promise<void>;
+  messages: AsyncIterable<unknown>;
+  send: (message: JsonRpcMessage) => void;
+};
+
+type CodexAppServerState = {
+  connection: CodexAppServerConnection;
+  messages: AsyncIterator<unknown>;
+};
+
+type CodexAppServerOptions = {
+  args?: string[];
+  clientInfo?: {
+    name: string;
+    title: string;
+    version: string;
+  };
+  command?: string;
+  connect?: () => CodexAppServerConnection;
+  model?: string;
+};
+
+type CodexAppServerRequest = {
+  input: string;
+  onThreadId?: (threadId: string) => Promise<void> | void;
+  threadId?: string;
+  workingDirectory?: string;
+};
+
+const defaultClientInfo = {
+  name: "orchestero_codex_gateway",
+  title: "Orchestero Codex Gateway",
+  version: "0.0.0",
+};
+const incompleteTurnMessage =
+  "Codex app-server closed before completing a turn.";
+const initializationMessage =
+  "Codex app-server closed before initialization completed.";
+
+function isRecord(value: unknown): value is JsonRecord {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function getRecord(value: unknown, key: string): JsonRecord | undefined {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const nextValue = value[key];
+  if (!isRecord(nextValue)) {
+    return undefined;
+  }
+
+  return nextValue;
+}
+
+function getString(value: unknown, key: string): string | undefined {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const nextValue = value[key];
+  if (typeof nextValue !== "string") {
+    return undefined;
+  }
+
+  return nextValue;
+}
+
+function getResponseError(message: unknown) {
+  return getRecord(message, "error");
+}
+
+function getResponseId(message: unknown) {
+  if (
+    !isRecord(message) ||
+    (typeof message.id !== "number" && typeof message.id !== "string")
+  ) {
+    return undefined;
+  }
+
+  return message.id;
+}
+
+function isServerRequest(message: unknown): message is JsonRpcMessage & {
+  id: JsonRpcId;
+  method: string;
+} {
+  return (
+    isRecord(message) &&
+    (typeof message.id === "number" || typeof message.id === "string") &&
+    typeof message.method === "string"
+  );
+}
+
+function getThreadId(message: unknown) {
+  return getString(getRecord(getRecord(message, "result"), "thread"), "id");
+}
+
+function getResultTurnId(message: unknown) {
+  return getString(getRecord(getRecord(message, "result"), "turn"), "id");
+}
+
+function getNotificationTurnId(message: unknown) {
+  const params = getRecord(message, "params");
+
+  return (
+    getString(params, "turnId") || getString(getRecord(params, "turn"), "id")
+  );
+}
+
+function getCompletedTurnErrorMessage(message: unknown) {
+  const turn = getRecord(getRecord(message, "params"), "turn");
+  if (getString(turn, "status") !== "failed") {
+    return undefined;
+  }
+
+  return (
+    getString(getRecord(turn, "error"), "message") ||
+    "Codex app-server turn failed."
+  );
+}
+
+function getAgentMessageDelta(message: unknown, turnId: string) {
+  if (!isRecord(message) || message.method !== "item/agentMessage/delta") {
+    return undefined;
+  }
+
+  if (getNotificationTurnId(message) !== turnId) {
+    return undefined;
+  }
+
+  return getString(message.params, "delta");
+}
+
+function isTurnCompleted(message: unknown, turnId: string) {
+  return (
+    isRecord(message) &&
+    message.method === "turn/completed" &&
+    getNotificationTurnId(message) === turnId
+  );
+}
+
+function connectStdio(
+  command: string,
+  args: string[],
+): CodexAppServerConnection {
+  const process = Bun.spawn([command, ...args], {
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "inherit",
+  });
+
+  return {
+    async close() {
+      process.stdin.end();
+      process.kill();
+      await process.exited;
+    },
+    messages: readJsonLines(process.stdout),
+    send(message) {
+      process.stdin.write(`${JSON.stringify(message)}\n`);
+      process.stdin.flush();
+    },
+  };
+}
+
+async function* readJsonLines(stream: ReadableStream<Uint8Array>) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  for await (const chunk of stream) {
+    buffer += decoder.decode(chunk, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (line.trim()) {
+        yield JSON.parse(line);
+      }
+    }
+  }
+
+  buffer += decoder.decode();
+  if (buffer.trim()) {
+    yield JSON.parse(buffer);
+  }
+}
+
+function create(options: CodexAppServerOptions = {}) {
+  const {
+    args = ["app-server"],
+    clientInfo = defaultClientInfo,
+    command = "codex",
+    connect = () => connectStdio(command, args),
+    model,
+  } = options;
+  let state: CodexAppServerState | null = null;
+  let nextRequestId = 0;
+  let queue = Promise.resolve();
+
+  const close = async () => {
+    const currentState = state;
+    state = null;
+
+    if (currentState) {
+      await currentState.connection.close();
+    }
+  };
+  const sendRequest = (
+    currentState: CodexAppServerState,
+    method: string,
+    params: JsonRecord,
+  ) => {
+    const id = nextRequestId;
+    nextRequestId += 1;
+    currentState.connection.send({ id, method, params });
+
+    return id;
+  };
+  const sendRequestAndResetOnError = async (
+    currentState: CodexAppServerState,
+    method: string,
+    params: JsonRecord,
+  ) => {
+    try {
+      return sendRequest(currentState, method, params);
+    } catch (error) {
+      await close();
+      throw error;
+    }
+  };
+  const acquireTurn = async () => {
+    const previous = queue;
+    const { promise: current, resolve: release } =
+      Promise.withResolvers<void>();
+    queue = previous.then(() => current);
+    await previous;
+
+    return release;
+  };
+  const sendNotification = (
+    currentState: CodexAppServerState,
+    method: string,
+    params: JsonRecord,
+  ) => {
+    currentState.connection.send({ method, params });
+  };
+  const sendUnsupportedRequestResponse = async (
+    currentState: CodexAppServerState,
+    id: JsonRpcId,
+  ) => {
+    try {
+      currentState.connection.send({
+        id,
+        error: {
+          code: -32601,
+          message: "Unsupported Codex app-server request.",
+        },
+      });
+    } catch (error) {
+      await close();
+      throw error;
+    }
+  };
+  const readMessage = async (currentState: CodexAppServerState) => {
+    const result = await currentState.messages.next();
+    if (result.done) {
+      await close();
+      return undefined;
+    }
+
+    return result.value;
+  };
+  const readResponse = async (
+    currentState: CodexAppServerState,
+    id: number,
+    closedMessage: string,
+    pendingMessages: unknown[] = [],
+  ) => {
+    while (true) {
+      const message = await readMessage(currentState);
+
+      if (message === undefined) {
+        throw new Error(closedMessage);
+      }
+
+      if (isServerRequest(message)) {
+        await sendUnsupportedRequestResponse(currentState, message.id);
+        continue;
+      }
+
+      const responseId = getResponseId(message);
+      if (responseId !== id) {
+        if (responseId === undefined) {
+          pendingMessages.push(message);
+        }
+        continue;
+      }
+
+      const error = getResponseError(message);
+      if (error) {
+        throw new Error(
+          getString(error, "message") || "Codex app-server request failed.",
+        );
+      }
+
+      return message;
+    }
+  };
+  const ensureConnection = async () => {
+    if (state) {
+      return state;
+    }
+
+    const connection = connect();
+    const nextState: CodexAppServerState = {
+      connection,
+      messages: connection.messages[Symbol.asyncIterator](),
+    };
+    state = nextState;
+
+    try {
+      const initializeRequestId = sendRequest(nextState, "initialize", {
+        clientInfo,
+        capabilities: { experimentalApi: true },
+      });
+      await readResponse(nextState, initializeRequestId, initializationMessage);
+      sendNotification(nextState, "initialized", {});
+
+      return nextState;
+    } catch (error) {
+      await close();
+      throw error;
+    }
+  };
+
+  return {
+    close,
+    async *stream(request: CodexAppServerRequest) {
+      const release = await acquireTurn();
+      let turnCompleted = false;
+      let turnStarted = false;
+
+      try {
+        const currentState = await ensureConnection();
+
+        const threadRequestId = await sendRequestAndResetOnError(
+          currentState,
+          request.threadId ? "thread/resume" : "thread/start",
+          {
+            ...(model ? { model } : {}),
+            ...(request.threadId ? { threadId: request.threadId } : {}),
+            ...(request.workingDirectory
+              ? { cwd: request.workingDirectory }
+              : {}),
+          },
+        );
+        const threadMessage = await readResponse(
+          currentState,
+          threadRequestId,
+          "Codex app-server closed before starting a turn.",
+        );
+        const threadId = getThreadId(threadMessage);
+        if (!threadId) {
+          throw new Error("Codex app-server closed before starting a turn.");
+        }
+
+        await request.onThreadId?.(threadId);
+        const pendingMessages: unknown[] = [];
+        const turnRequestId = await sendRequestAndResetOnError(
+          currentState,
+          "turn/start",
+          {
+            threadId,
+            input: [{ type: "text", text: request.input }],
+          },
+        );
+        turnStarted = true;
+        const turnMessage = await readResponse(
+          currentState,
+          turnRequestId,
+          incompleteTurnMessage,
+          pendingMessages,
+        );
+        const turnId = getResultTurnId(turnMessage);
+        if (!turnId) {
+          throw new Error(incompleteTurnMessage);
+        }
+
+        while (true) {
+          const message =
+            pendingMessages.length > 0
+              ? pendingMessages.shift()
+              : await readMessage(currentState);
+
+          if (message === undefined) {
+            throw new Error(incompleteTurnMessage);
+          }
+
+          if (isServerRequest(message)) {
+            await sendUnsupportedRequestResponse(currentState, message.id);
+            continue;
+          }
+
+          const error = getResponseError(message);
+          if (error) {
+            throw new Error(
+              getString(error, "message") || "Codex app-server request failed.",
+            );
+          }
+
+          const delta = getAgentMessageDelta(message, turnId);
+          if (delta) {
+            yield delta;
+          }
+
+          if (isTurnCompleted(message, turnId)) {
+            turnCompleted = true;
+            const errorMessage = getCompletedTurnErrorMessage(message);
+            if (errorMessage) {
+              throw new Error(errorMessage);
+            }
+            return;
+          }
+        }
+      } finally {
+        try {
+          if (turnStarted && !turnCompleted) {
+            await close();
+          }
+        } finally {
+          release();
+        }
+      }
+    },
+  };
+}
+
+export const codexAppServer = { create };

package/lib/codex-gateway-server.ts

@@ -0,0 +1,77 @@
+import type { WebhookOptions } from "chat";
+import { type Context, Hono } from "hono";
+
+type WebhookHandler = (
+  request: Request,
+  options?: WebhookOptions,
+) => Promise<Response>;
+
+type GatewayBot = {
+  webhooks: Partial<Record<"telegram" | "zalo", WebhookHandler>>;
+};
+
+type GatewayBots = Record<string, GatewayBot>;
+
+type GatewayServerOptions = {
+  bots: GatewayBots;
+  port?: number;
+};
+
+const platformNames = ["telegram", "zalo"] as const;
+
+type PlatformName = (typeof platformNames)[number];
+
+function isPlatformName(value: string): value is PlatformName {
+  return platformNames.some((platformName) => platformName === value);
+}
+
+function routeWebhook(
+  context: Context,
+  bot: GatewayBot | undefined,
+  platformName: PlatformName,
+) {
+  if (!bot) {
+    return context.text("agent is not configured.", 404);
+  }
+
+  const webhook = bot.webhooks[platformName];
+
+  if (!webhook) {
+    return context.text(`${platformName} is not configured.`, 404);
+  }
+
+  return webhook(context.req.raw, {
+    waitUntil: (task) => {
+      task.catch((error: unknown) => {
+        console.error(error);
+      });
+    },
+  });
+}
+
+function create(options: GatewayServerOptions) {
+  const { bots, port = 42240 } = options;
+  const hono = new Hono();
+
+  hono.get("/health", (context) => context.text("OK"));
+
+  hono.all("/webhooks/:agentId/:platformName", (context) => {
+    const platformName = context.req.param("platformName");
+    if (!isPlatformName(platformName)) {
+      return context.text(`${platformName} is not configured.`, 404);
+    }
+
+    return routeWebhook(
+      context,
+      bots[context.req.param("agentId")],
+      platformName,
+    );
+  });
+
+  return {
+    port,
+    fetch: hono.fetch,
+  };
+}
+
+export const codexGatewayServer = { create };

package/lib/main.ts

@@ -0,0 +1,12 @@
+import { agentConfigs } from "~/lib/agent-configs";
+import { chatBot } from "~/lib/chat-bot";
+import { codexGatewayServer } from "~/lib/codex-gateway-server";
+
+const agents = await agentConfigs.load();
+const bots = chatBot.createMany({ agents });
+
+await Promise.all(Object.values(bots).map((bot) => bot.initialize()));
+
+export default codexGatewayServer.create({
+  bots,
+});

package/lib/pg-pool.ts

@@ -0,0 +1,7 @@
+import pg from "pg";
+import { pgURL } from "~/lib/pg-url";
+
+export const pgPool = new pg.Pool({
+  connectionString: pgURL,
+  options: "-c search_path=codex_gateway",
+});

package/lib/pg-state.ts

@@ -0,0 +1,35 @@
+import { createPostgresState } from "@chat-adapter/state-pg";
+import { pgPool } from "~/lib/pg-pool";
+
+type PgStateOptions = {
+  keyPrefix: string;
+};
+
+let schemaPromise: Promise<unknown> | undefined;
+
+function ensureSchema() {
+  schemaPromise ||= pgPool
+    .query("CREATE SCHEMA IF NOT EXISTS codex_gateway")
+    .catch((error: unknown) => {
+      schemaPromise = undefined;
+      throw error;
+    });
+  return schemaPromise;
+}
+
+function create(options: PgStateOptions) {
+  const state = createPostgresState({
+    client: pgPool,
+    keyPrefix: options.keyPrefix,
+  });
+  const pgConnect = state.connect.bind(state);
+
+  state.connect = async (...args: Parameters<typeof state.connect>) => {
+    await ensureSchema();
+    await pgConnect(...args);
+  };
+
+  return state;
+}
+
+export const pgState = { create };

package/lib/pg-url.ts

@@ -0,0 +1,2 @@
+export const pgURL =
+  Bun.env.PG_URL || "postgres://postgres:postgres@localhost:42340/postgres";