openai-oauth 0.0.1

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_PORT,
+  resolveAuthFileCandidates,
+  startOpenAIOAuthServer
+} from "./chunk-VZQM4BY4.js";
+
+// src/cli-app.ts
+import { access } from "fs/promises";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+var parseModels = (value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const models = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return models.length > 0 ? models : void 0;
+};
+var parseCliArgs = (argv) => {
+  const parsed = yargs(argv).scriptName("openai-oauth").strict().help().option("host", {
+    type: "string",
+    describe: "Host interface to bind the local proxy to."
+  }).option("port", {
+    type: "number",
+    describe: "Port to bind the local proxy to."
+  }).option("models", {
+    type: "string",
+    describe: "Comma-separated list of models exposed by /v1/models.",
+    coerce: parseModels
+  }).option("base-url", {
+    type: "string",
+    describe: "Override the upstream Codex responses base URL."
+  }).option("oauth-client-id", {
+    type: "string",
+    describe: "Override the OAuth client id used for token refresh."
+  }).option("oauth-token-url", {
+    type: "string",
+    describe: "Override the OAuth token URL used for token refresh."
+  }).option("oauth-file", {
+    type: "string",
+    describe: "Override the auth.json file path used for local OAuth tokens."
+  }).parseSync();
+  return {
+    host: parsed.host,
+    port: parsed.port,
+    models: parsed.models,
+    baseURL: parsed.baseUrl,
+    clientId: parsed.oauthClientId,
+    tokenUrl: parsed.oauthTokenUrl,
+    authFilePath: parsed.oauthFile
+  };
+};
+var toServerOptions = (args) => ({
+  host: args.host ?? process.env.HOST,
+  port: args.port ?? Number(process.env.PORT ?? String(DEFAULT_PORT)),
+  models: args.models,
+  baseURL: args.baseURL,
+  clientId: args.clientId,
+  tokenUrl: args.tokenUrl,
+  authFilePath: args.authFilePath
+});
+var findExistingAuthFile = async (authFilePath) => {
+  for (const candidate of resolveAuthFileCandidates(authFilePath)) {
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+};
+var toMissingAuthFileMessage = (authFilePath) => {
+  if (authFilePath) {
+    return [
+      `No auth file was found at ${authFilePath}.`,
+      "Run `npx @openai/codex login` and try again."
+    ].join("\n");
+  }
+  const candidates = resolveAuthFileCandidates(void 0);
+  return [
+    `No auth file was found in the default search paths: ${candidates.join(", ")}.`,
+    "Run `npx @openai/codex login` and try again."
+  ].join("\n");
+};
+var toStartupMessage = (options) => {
+  const baseUrl = `http://${options.host ?? "127.0.0.1"}:${options.port ?? DEFAULT_PORT}/v1`;
+  return [
+    `OpenAI-compatible endpoint ready at ${baseUrl}`,
+    "Use this as your OpenAI base URL. No API key is required."
+  ].join("\n");
+};
+var runCli = async (argv = hideBin(process.argv)) => {
+  const args = parseCliArgs(argv);
+  const options = toServerOptions(args);
+  const existingAuthFile = await findExistingAuthFile(options.authFilePath);
+  if (!existingAuthFile) {
+    throw new Error(toMissingAuthFileMessage(options.authFilePath));
+  }
+  const server = await startOpenAIOAuthServer(options);
+  console.log(
+    toStartupMessage({
+      ...options,
+      host: server.host,
+      port: server.port
+    })
+  );
+  const shutdown = async () => {
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => {
+    void shutdown();
+  });
+  process.on("SIGTERM", () => {
+    void shutdown();
+  });
+};
+
+// src/cli.ts
+void runCli().catch((error) => {
+  console.error(
+    error instanceof Error ? error.message : "Failed to start openai-oauth."
+  );
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,153 @@
+import { Server } from 'node:http';
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+type AuthLoaderOptions = {
+    clientId?: string;
+    issuer?: string;
+    tokenUrl?: string;
+    authFilePath?: string;
+    fetch: FetchFunction;
+    ensureFresh?: boolean;
+    now?: () => Date;
+};
+
+type JsonRecord = Record<string, unknown>;
+type CodexResponsesStateSnapshot = {
+    items: Array<{
+        id: string;
+        item: JsonRecord;
+    }>;
+    responses: Array<{
+        id: string;
+        input: unknown[];
+        output: JsonRecord[];
+    }>;
+};
+type CodexResponsesStateOptions = {
+    snapshot?: CodexResponsesStateSnapshot;
+    onChange?: (snapshot: CodexResponsesStateSnapshot) => void;
+};
+declare class CodexResponsesState {
+    private readonly items;
+    private readonly responses;
+    private readonly pendingCaptures;
+    private readonly onChange?;
+    constructor(options?: CodexResponsesStateOptions);
+    waitForPendingCaptures(): Promise<void>;
+    trackPendingCapture(promise: Promise<void>): void;
+    requiresCachedState(body: JsonRecord): boolean;
+    expandRequestBody(body: JsonRecord): JsonRecord;
+    rememberResponse(response: unknown, requestBody?: JsonRecord): void;
+    snapshot(): CodexResponsesStateSnapshot;
+    private expandInput;
+    private emitChange;
+}
+
+type CodexOAuthSettings = Omit<AuthLoaderOptions, "fetch"> & {
+    baseURL?: string;
+    fetch?: FetchFunction;
+    headers?: Record<string, string>;
+    instructions?: string;
+    store?: boolean;
+    responsesState?: CodexResponsesState | false;
+};
+
+type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject;
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type ChatToolDefinition = {
+    type?: string;
+    function?: {
+        name?: string;
+        description?: string;
+        parameters?: JsonObject;
+    };
+};
+type ChatToolChoice = "auto" | "none" | "required" | {
+    type?: string;
+    function?: {
+        name?: string;
+    };
+};
+type ChatMessage = {
+    role?: string;
+    content?: unknown;
+    tool_calls?: Array<{
+        id?: string;
+        type?: string;
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }>;
+    tool_call_id?: string;
+};
+type ChatRequest = {
+    model?: string;
+    messages?: ChatMessage[];
+    stream?: boolean;
+    tools?: ChatToolDefinition[];
+    tool_choice?: ChatToolChoice;
+    temperature?: number;
+    top_p?: number;
+    stop?: string | string[];
+    max_tokens?: number;
+    parallel_tool_calls?: boolean;
+    reasoning_effort?: "none" | "minimal" | "low" | "medium" | "high";
+};
+type ChatRequestSummary = {
+    bodyKeys: string[];
+    messageCount: number;
+    messageRoles: string[];
+    model?: string;
+    reasoningEffort?: ChatRequest["reasoning_effort"];
+    stream: boolean;
+    toolCount: number;
+};
+type UsageLike = {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    reasoningTokens?: number;
+    cachedInputTokens?: number;
+};
+type OpenAIOAuthServerLogEvent = ({
+    type: "chat_request";
+    requestId: string;
+    path: "/v1/chat/completions";
+} & ChatRequestSummary) | {
+    type: "chat_response";
+    durationMs: number;
+    finishReason?: string;
+    path: "/v1/chat/completions";
+    requestId: string;
+    status: number;
+    stream: boolean;
+    usage: UsageLike;
+} | {
+    type: "chat_error";
+    durationMs: number;
+    message: string;
+    path: "/v1/chat/completions";
+    requestId: string;
+};
+declare const defaultOpenAIOAuthModels: readonly string[];
+type OpenAIOAuthServerOptions = Omit<CodexOAuthSettings, "responsesState"> & {
+    host?: string;
+    port?: number;
+    models?: string[];
+    requestLogger?: (event: OpenAIOAuthServerLogEvent) => void;
+};
+type RunningOpenAIOAuthServer = {
+    server: Server;
+    host: string;
+    port: number;
+    url: string;
+    close: () => Promise<void>;
+};
+
+declare const createOpenAIOAuthFetchHandler: (settings?: OpenAIOAuthServerOptions) => ((request: Request) => Promise<Response>);
+declare const startOpenAIOAuthServer: (settings?: OpenAIOAuthServerOptions) => Promise<RunningOpenAIOAuthServer>;
+
+export { type OpenAIOAuthServerLogEvent, type OpenAIOAuthServerOptions, type RunningOpenAIOAuthServer, createOpenAIOAuthFetchHandler, defaultOpenAIOAuthModels, startOpenAIOAuthServer };

package/dist/index.js

@@ -0,0 +1,10 @@
+import {
+  createOpenAIOAuthFetchHandler,
+  defaultOpenAIOAuthModels,
+  startOpenAIOAuthServer
+} from "./chunk-VZQM4BY4.js";
+export {
+  createOpenAIOAuthFetchHandler,
+  defaultOpenAIOAuthModels,
+  startOpenAIOAuthServer
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "openai-oauth",
+	"version": "0.0.1",
+	"description": "Free OpenAI API access with your ChatGPT account.",
+	"type": "module",
+	"bin": {
+		"openai-oauth": "./dist/cli.js"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsup src/index.ts src/cli.ts --format esm --dts --outDir dist --clean",
+		"dev": "bun ./src/cli.ts",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run",
+		"test:live": "LIVE_CODEX_E2E=1 vitest run test/live.e2e.test.ts"
+	},
+	"dependencies": {
+		"ai": "6.0.0-beta.138",
+		"yargs": "^17.7.2"
+	},
+	"devDependencies": {
+		"@ai-sdk/openai": "3.0.0-beta.87",
+		"@types/node": "20.17.24",
+		"@types/yargs": "^17.0.33",
+		"openai-oauth-core": "workspace:*",
+		"openai-oauth-provider": "workspace:*",
+		"typescript": "latest",
+		"vitest": "latest",
+		"zod": "^3.25.76"
+	},
+	"author": "EvanZhouDev",
+	"license": "AGPL-3.0-only",
+	"bugs": {
+		"url": "https://github.com/EvanZhouDev/openai-oauth/issues"
+	},
+	"homepage": "https://github.com/EvanZhouDev/openai-oauth#readme"
+}