@jrkropp/codex-js 0.1.4 → 0.2.0

package/dist/index.js

@@ -1,20 +1,699 @@
-import './chunk-ZX5OIIJX.js';
-export { CodexChat, CodexChatLayout, CodexChatProvider, CodexChatSidebar, CodexChatView } from './chunk-W7S6HFCQ.js';
-import './chunk-5JMJ6OI5.js';
-import './chunk-NCI4MAWZ.js';
-import './chunk-FN3SWHRH.js';
-export { createCodexAppServerClient } from './chunk-6ZMJ34KE.js';
-import './chunk-4DPLJPB5.js';
-import './chunk-V4BMZWBM.js';
-import './chunk-LWQNX4LI.js';
-import './chunk-PST3ZWX2.js';
-import './chunk-Z63UPBS3.js';
-import './chunk-YHVCFD2D.js';
-import './chunk-DCMKA2A6.js';
-import './chunk-CGBS37IU.js';
-import './chunk-2DZRMCI2.js';
-import './chunk-DYLHN3HG.js';
-import './chunk-SYPHCDRD.js';
-import './chunk-O44XP7LH.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+// src/internal/codex/app-server-transport/src/transport/mod.ts
+function parseJsonRpcTransportPayload(payload) {
+  let value;
+  if (typeof payload === "string") {
+    try {
+      value = JSON.parse(payload);
+    } catch {
+      return {
+        error: jsonRpcParseError("Parse error"),
+        id: null,
+        type: "invalid"
+      };
+    }
+  } else if (payload instanceof ArrayBuffer || ArrayBuffer.isView(payload)) {
+    const bytes = payload instanceof ArrayBuffer ? new Uint8Array(payload) : new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength);
+    try {
+      value = JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      return {
+        error: jsonRpcParseError("Parse error"),
+        id: null,
+        type: "invalid"
+      };
+    }
+  } else {
+    value = payload;
+  }
+  return parseJsonRpcMessage(value);
+}
+function parseJsonRpcMessage(value) {
+  if (!isRecord(value)) {
+    return {
+      error: jsonRpcInvalidRequestError("Invalid JSON-RPC message"),
+      id: null,
+      type: "invalid"
+    };
+  }
+  const candidateId = requestIdFromValue(value.id);
+  const id = candidateId ?? null;
+  if (typeof value.method === "string") {
+    if (candidateId !== null) {
+      return {
+        message: jsonRpcRequest(value.method, candidateId, value.params),
+        type: "ok"
+      };
+    }
+    if (Object.prototype.hasOwnProperty.call(value, "id")) {
+      return {
+        error: jsonRpcInvalidRequestError("Invalid JSON-RPC request id"),
+        id: null,
+        type: "invalid"
+      };
+    }
+    return {
+      message: jsonRpcNotification(value.method, value.params),
+      type: "ok"
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(value, "error")) {
+    if (!isJsonRpcErrorError(value.error)) {
+      return {
+        error: jsonRpcInvalidRequestError("Invalid JSON-RPC error object"),
+        id,
+        type: "invalid"
+      };
+    }
+    return {
+      message: { error: value.error, id },
+      type: "ok"
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(value, "result")) {
+    if (candidateId === null) {
+      return {
+        error: jsonRpcInvalidRequestError("Invalid JSON-RPC response id"),
+        id: null,
+        type: "invalid"
+      };
+    }
+    return {
+      message: { id: candidateId, result: value.result },
+      type: "ok"
+    };
+  }
+  return {
+    error: jsonRpcInvalidRequestError("Invalid JSON-RPC message"),
+    id,
+    type: "invalid"
+  };
+}
+function parseClientTransportPayload(payload) {
+  const parsed = parseJsonRpcTransportPayload(payload);
+  if (parsed.type === "invalid") {
+    return parsed;
+  }
+  return {
+    message: clientTransportMessage(parsed.message),
+    type: "ok"
+  };
+}
+function serializeOutgoingMessage(message) {
+  return JSON.stringify(message);
+}
+function serializeJsonRpcResponse(id, result) {
+  return serializeOutgoingMessage({ id, result });
+}
+function serializeJsonRpcError(id, error) {
+  return JSON.stringify({ error, id });
+}
+function jsonRpcParseError(message) {
+  return { code: -32700, message };
+}
+function jsonRpcInvalidRequestError(message) {
+  return { code: -32600, message };
+}
+function clientTransportMessage(message) {
+  if (isRequest(message)) {
+    return { request: message, type: "server_request" };
+  }
+  if (isNotification(message)) {
+    return {
+      notification: message,
+      type: "server_notification"
+    };
+  }
+  if (isError(message)) {
+    return { error: message, type: "error" };
+  }
+  return { response: message, type: "response" };
+}
+function jsonRpcRequest(method, id, params) {
+  return params === void 0 ? { id, method } : { id, method, params };
+}
+function jsonRpcNotification(method, params) {
+  return params === void 0 ? { method } : { method, params };
+}
+function isRequest(message) {
+  return typeof message.method === "string" && Object.prototype.hasOwnProperty.call(message, "id");
+}
+function isNotification(message) {
+  return typeof message.method === "string" && !Object.prototype.hasOwnProperty.call(message, "id");
+}
+function isError(message) {
+  return Object.prototype.hasOwnProperty.call(message, "error");
+}
+function requestIdFromValue(value) {
+  return typeof value === "string" || typeof value === "number" ? value : null;
+}
+function isJsonRpcErrorError(value) {
+  return isRecord(value) && typeof value.code === "number" && typeof value.message === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/internal/codex/app-server-client/src/remote.ts
+var CodexAppServerClientTransportError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "CodexAppServerClientTransportError";
+  }
+  status;
+  body;
+};
+function createCodexAppServerClient(options) {
+  let socket = null;
+  let openPromise = null;
+  let initializePromise = null;
+  let initialized = false;
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const eventQueue = createEventQueue();
+  async function ensureOpenSocket() {
+    const openState = 1;
+    if (socket?.readyState === openState) {
+      return socket;
+    }
+    openPromise ??= openSocket();
+    return openPromise;
+  }
+  async function ensureInitialized() {
+    if (initialized) {
+      return;
+    }
+    initializePromise ??= sendClientRequest({
+      id: 0,
+      method: "initialize",
+      params: await resolveInitializeParams(options.initializeParams)
+    });
+    await initializePromise;
+    initialized = true;
+  }
+  async function request(request2) {
+    if (request2.method !== "initialize") {
+      await ensureInitialized();
+      return sendClientRequest(request2);
+    }
+    const result = await sendClientRequest(request2);
+    initialized = true;
+    return result;
+  }
+  async function sendClientRequest(request2) {
+    const websocket = await ensureOpenSocket();
+    return new Promise((resolve, reject) => {
+      pendingRequests.set(request2.id, { reject, resolve });
+      try {
+        websocket.send(JSON.stringify(request2));
+      } catch (error) {
+        pendingRequests.delete(request2.id);
+        reject(error);
+      }
+    });
+  }
+  async function sendClientResponse(requestId, result) {
+    const websocket = await ensureOpenSocket();
+    websocket.send(serializeJsonRpcResponse(requestId, result));
+  }
+  async function sendClientError(requestId, error) {
+    const websocket = await ensureOpenSocket();
+    websocket.send(serializeJsonRpcError(requestId, error));
+  }
+  async function openSocket() {
+    options.onConnectionStatus?.("connecting");
+    eventQueue.reopen();
+    const WebSocketCtor = options.WebSocket ?? WebSocket;
+    const websocketUrl = await resolveUrl(options.url);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const nextSocket = new WebSocketCtor(websocketUrl);
+      socket = nextSocket;
+      nextSocket.addEventListener("open", () => {
+        settled = true;
+        options.onConnectionStatus?.("connected");
+        resolve(nextSocket);
+      });
+      nextSocket.addEventListener("message", (message) => {
+        handleSocketMessage(message.data);
+      });
+      nextSocket.addEventListener("close", () => {
+        const error = new CodexAppServerClientTransportError(
+          "Codex app-server WebSocket closed."
+        );
+        closeSocketState(error);
+        eventQueue.push({ message: "closed", type: "disconnected" });
+        eventQueue.close();
+        options.onConnectionStatus?.("closed");
+        if (!settled) {
+          reject(error);
+        }
+      });
+      nextSocket.addEventListener("error", () => {
+        const error = new CodexAppServerClientTransportError(
+          "Codex app-server WebSocket failed."
+        );
+        closeSocketState(error);
+        eventQueue.fail(error);
+        options.onConnectionStatus?.("error");
+        if (!settled) {
+          reject(error);
+        }
+      });
+    });
+  }
+  function handleSocketMessage(value) {
+    const parsed = parseClientTransportPayload(value);
+    if (parsed.type === "invalid") {
+      const event = options.parseEvent?.(value);
+      if (event) {
+        eventQueue.push(event);
+      }
+      return;
+    }
+    const message = parsed.message;
+    switch (message.type) {
+      case "response": {
+        const pending = pendingRequests.get(message.response.id);
+        if (!pending) {
+          return;
+        }
+        pendingRequests.delete(message.response.id);
+        pending.resolve(message.response.result);
+        return;
+      }
+      case "error": {
+        if (message.error.id === null) {
+          eventQueue.fail(message.error.error);
+          return;
+        }
+        const pending = pendingRequests.get(message.error.id);
+        if (!pending) {
+          return;
+        }
+        pendingRequests.delete(message.error.id);
+        pending.reject(message.error.error);
+        return;
+      }
+      case "server_notification":
+        eventQueue.push({
+          notification: message.notification,
+          type: "server_notification"
+        });
+        return;
+      case "server_request":
+        eventQueue.push({ request: message.request, type: "server_request" });
+        return;
+    }
+  }
+  function closeSocketState(error) {
+    socket = null;
+    openPromise = null;
+    initializePromise = null;
+    initialized = false;
+    for (const pending of pendingRequests.values()) {
+      pending.reject(error);
+    }
+    pendingRequests.clear();
+  }
+  function close() {
+    const currentSocket = socket;
+    closeSocketState(
+      new CodexAppServerClientTransportError(
+        "Codex app-server WebSocket closed."
+      )
+    );
+    eventQueue.close();
+    if (currentSocket && currentSocket.readyState !== 3) {
+      currentSocket.close();
+    }
+  }
+  return {
+    close,
+    events() {
+      void ensureInitialized().catch((error) => eventQueue.fail(error));
+      return eventQueue.iterable();
+    },
+    request,
+    requestTyped(clientRequest) {
+      return requestTyped(clientRequest, request);
+    },
+    rejectServerRequest(requestId, error) {
+      return sendClientError(requestId, error);
+    },
+    resolveServerRequest(requestId, result) {
+      return sendClientResponse(requestId, result);
+    }
+  };
+}
+function parseCodexAppServerEvent(value) {
+  const parsed = parseClientTransportPayload(value);
+  if (parsed.type === "ok") {
+    switch (parsed.message.type) {
+      case "server_notification":
+        return {
+          notification: parsed.message.notification,
+          type: "server_notification"
+        };
+      case "server_request":
+        return { request: parsed.message.request, type: "server_request" };
+      case "error":
+      case "response":
+        return null;
+    }
+  }
+  if (typeof value !== "string") {
+    return appServerEventFromParsed(value);
+  }
+  try {
+    return appServerEventFromParsed(JSON.parse(value));
+  } catch {
+    return null;
+  }
+}
+async function resolveInitializeParams(params) {
+  if (typeof params === "function") {
+    return params();
+  }
+  return params ?? defaultInitializeParams();
+}
+async function resolveUrl(url) {
+  return typeof url === "function" ? await url() : url;
+}
+function defaultInitializeParams() {
+  return {
+    capabilities: {
+      experimentalApi: false,
+      optOutNotificationMethods: []
+    },
+    clientInfo: {
+      name: "codex-js",
+      title: null,
+      version: "0.0.0"
+    }
+  };
+}
+function appServerEventFromParsed(value) {
+  if (isObject(value) && typeof value.type === "string") {
+    if (value.type === "server_notification" || value.type === "server_request" || value.type === "lagged" || value.type === "disconnected") {
+      return value;
+    }
+  }
+  if (isObject(value) && typeof value.method === "string" && "params" in value) {
+    if ("id" in value) {
+      return { request: value, type: "server_request" };
+    }
+    return {
+      notification: value,
+      type: "server_notification"
+    };
+  }
+  return null;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function createEventQueue() {
+  const values = [];
+  const waiters = [];
+  let closed = false;
+  let failure = null;
+  return {
+    close() {
+      closed = true;
+      for (const waiter of waiters.splice(0)) {
+        waiter.settled = true;
+        waiter.resolve({ done: true, value: void 0 });
+      }
+    },
+    fail(error) {
+      failure = error;
+      for (const waiter of waiters.splice(0)) {
+        waiter.settled = true;
+        waiter.reject(error);
+      }
+    },
+    push(value) {
+      while (waiters.length > 0) {
+        const waiter = waiters.shift();
+        if (waiter.settled) {
+          continue;
+        }
+        waiter.settled = true;
+        waiter.resolve({ done: false, value });
+        return;
+      }
+      values.push(value);
+    },
+    reopen() {
+      values.splice(0);
+      closed = false;
+      failure = null;
+    },
+    iterable(options = {}) {
+      return {
+        [Symbol.asyncIterator]() {
+          let active = true;
+          let pendingWaiter = null;
+          return {
+            next() {
+              if (!active) {
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              if (failure) {
+                return Promise.reject(failure);
+              }
+              if (values.length > 0) {
+                return Promise.resolve({
+                  done: false,
+                  value: values.shift()
+                });
+              }
+              if (closed) {
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              return new Promise((resolve, reject) => {
+                const waiter = { reject, resolve, settled: false };
+                pendingWaiter = waiter;
+                waiters.push(waiter);
+              });
+            },
+            return() {
+              options.onReturn?.();
+              active = false;
+              if (pendingWaiter && !pendingWaiter.settled) {
+                pendingWaiter.settled = true;
+                const index = waiters.indexOf(pendingWaiter);
+                if (index !== -1) {
+                  waiters.splice(index, 1);
+                }
+                pendingWaiter.resolve({ done: true, value: void 0 });
+              }
+              return Promise.resolve({ done: true, value: void 0 });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+
+// src/internal/codex/app-server-client/src/session.ts
+var AppServerSession = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  nextRequestIdValue = 1;
+  nextRequestId() {
+    const requestId = this.nextRequestIdValue;
+    this.nextRequestIdValue += 1;
+    return requestId;
+  }
+  nextEvent() {
+    return this.client.nextEvent?.() ?? Promise.resolve(null);
+  }
+  events() {
+    return this.client.events?.() ?? null;
+  }
+  requestTyped(request) {
+    return this.client.requestTyped(request);
+  }
+  initialize(params = defaultInitializeParams2()) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "initialize",
+      params
+    });
+  }
+  threadStart(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/start",
+      params
+    });
+  }
+  threadResume(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/resume",
+      params
+    });
+  }
+  threadList(params = {}) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/list",
+      params
+    });
+  }
+  collaborationModeList(params = {}) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "collaborationMode/list",
+      params
+    });
+  }
+  configMcpServerReload() {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "config/mcpServer/reload",
+      params: void 0
+    });
+  }
+  mcpServerStatusList(params = {}) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "mcpServerStatus/list",
+      params
+    });
+  }
+  mcpResourceRead(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "mcpServer/resource/read",
+      params
+    });
+  }
+  mcpServerToolCall(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "mcpServer/tool/call",
+      params
+    });
+  }
+  mcpServerOauthLogin(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "mcpServer/oauth/login",
+      params
+    });
+  }
+  threadRead(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/read",
+      params
+    });
+  }
+  threadNameSet(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/name/set",
+      params
+    });
+  }
+  threadArchive(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/archive",
+      params
+    });
+  }
+  threadUnarchive(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/unarchive",
+      params
+    });
+  }
+  threadMetadataUpdate(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/metadata/update",
+      params
+    });
+  }
+  turnStart(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "turn/start",
+      params
+    });
+  }
+  turnSteer(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "turn/steer",
+      params
+    });
+  }
+  turnInterrupt(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "turn/interrupt",
+      params
+    });
+  }
+  threadCompactStart(params) {
+    return this.requestTyped({
+      id: this.nextRequestId(),
+      method: "thread/compact/start",
+      params
+    });
+  }
+  resolveServerRequest(requestId, result) {
+    return this.client.resolveServerRequest(requestId, result);
+  }
+  rejectServerRequest(requestId, error) {
+    return this.client.rejectServerRequest(requestId, error);
+  }
+};
+function defaultInitializeParams2() {
+  return {
+    capabilities: {
+      experimentalApi: false,
+      optOutNotificationMethods: []
+    },
+    clientInfo: {
+      name: "codex-js",
+      title: null,
+      version: "0.0.0"
+    }
+  };
+}
+
+// src/internal/codex/app-server-client/src/lib.ts
+async function requestTyped(request, send) {
+  try {
+    return await send(request);
+  } catch (source) {
+    if (isJsonRpcError(source)) {
+      throw {
+        method: request.method,
+        source,
+        type: "server"
+      };
+    }
+    throw {
+      method: request.method,
+      source,
+      type: "transport"
+    };
+  }
+}
+function isJsonRpcError(value) {
+  return typeof value === "object" && value !== null && typeof value.code === "number" && typeof value.message === "string";
+}
+
+export { AppServerSession, CodexAppServerClientTransportError, createCodexAppServerClient, parseCodexAppServerEvent };