openai-oauth 1.0.2 → 2.0.0-beta.0

package/dist/cli.js

@@ -1,65 +1,23 @@
 #!/usr/bin/env node
 import {
   DEFAULT_PORT,
-  createCodexOAuthClient,
-  resolveAuthFileCandidates,
   resolveOpenAIOAuthModels,
+  runOpenAIOAuthLogin,
   startOpenAIOAuthServer
-} from "./chunk-2AENSHRT.js";
+} from "./chunk-XZLFK5NT.js";
 
 // src/cli-app.ts
 import { access } from "fs/promises";
+import { createInterface } from "readline/promises";
+import {
+  createCodexOAuthClient,
+  resolveAuthFileCandidates,
+  resolveCodexAuthFilePath
+} from "@openai-oauth/core";
+import { openaiCredentials } from "@openai-oauth/local";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
-// package.json
-var package_default = {
-  name: "openai-oauth",
-  version: "1.0.2",
-  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",
-    prepublishOnly: "bun run build",
-    typecheck: "tsc --noEmit",
-    test: "vitest run",
-    "test:live": "LIVE_CODEX_E2E=1 vitest run test/live.e2e.test.ts"
-  },
-  dependencies: {
-    ai: "6.0.116",
-    yargs: "^17.7.2"
-  },
-  devDependencies: {
-    "@ai-sdk/openai": "3.0.41",
-    "@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"
-};
-
 // src/cli-logging.ts
 var ansi = {
   dim: "\x1B[2m",
@@ -146,13 +104,17 @@ var compareSemver = (left, right) => {
   }
   return 0;
 };
-var fetchLatestVersion = async (fetchImpl) => {
+var fetchLatestVersion = async (fetchImpl, signal) => {
   try {
-    const response = await fetchImpl(REGISTRY_URL, {
+    const requestInit = {
       headers: {
         accept: "application/json"
       }
-    });
+    };
+    if (signal) {
+      requestInit.signal = signal;
+    }
+    const response = await fetchImpl(REGISTRY_URL, requestInit);
     if (!response.ok) {
       return void 0;
     }
@@ -167,9 +129,18 @@ var checkForOpenAIOAuthUpdates = async (currentVersion, dependencies = {}) => {
   if (normalizedCurrentVersion == null) {
     return;
   }
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => {
+    abortController.abort();
+  }, dependencies.timeoutMs ?? 1500);
+  if (typeof timeout === "object" && "unref" in timeout) {
+    timeout.unref();
+  }
   const latestVersion = await fetchLatestVersion(
-    dependencies.fetchImpl ?? globalThis.fetch
+    dependencies.fetchImpl ?? globalThis.fetch,
+    abortController.signal
   );
+  clearTimeout(timeout);
   if (latestVersion == null) {
     return;
   }
@@ -182,7 +153,13 @@ Run \`npx openai-oauth@latest\` to use the newest version.`
   );
 };
 
+// src/version.ts
+var packageVersion = "2.0.0-beta.0";
+
 // src/cli-app.ts
+var defaultUpdateCheckWarning = (message) => {
+  console.error(message);
+};
 var parseModels = (value) => {
   if (typeof value !== "string") {
     return void 0;
@@ -195,31 +172,34 @@ var helpLines = [
   "",
   "Usage",
   "  npx openai-oauth@latest [options]",
+  "  npx openai-oauth@latest login [options]",
   "",
   "Options",
-  "  --host <host>              Host interface to bind to.",
-  "  --port <port>              Port to listen on. Default: 10531",
+  "  --host <host>              Proxy host. Login callback always listens on loopback.",
+  "  --port <port>              Proxy port. Default: 10531.",
   "  --models <ids>             Comma-separated model ids to expose from /v1/models.",
   "  --codex-version <version>  Codex API version to use for model discovery.",
   "  --base-url <url>           Override the upstream Codex base URL.",
   "  --oauth-client-id <id>     Override the OAuth client id used for refresh.",
   "  --oauth-token-url <url>    Override the OAuth token URL used for refresh.",
   "  --oauth-file <path>        Path to the local auth.json file.",
+  "  --no-open                  Print the login URL without opening a browser.",
+  "  --login-timeout-ms <ms>    Login timeout. Default: 300000",
   "",
   "Flags",
   "  --help                     Show help",
-  `  --version                  Show version (${package_default.version})`,
+  `  --version                  Show version (${packageVersion})`,
   "",
   "Notes",
-  "  If no auth file is found, run: npx @openai/codex login",
+  "  If no auth file is found, run: npx openai-oauth login",
   "  By default, available models are discovered from your account."
 ];
 var createCliParser = (argv) => yargs(argv).scriptName("openai-oauth").strict().help(false).version(false).option("host", {
   type: "string",
-  describe: "Host interface to bind to."
+  describe: "Proxy host. Login callback always listens on loopback."
 }).option("port", {
   type: "number",
-  describe: "Port to listen on. Default: 10531"
+  describe: "Proxy port. Default: 10531."
 }).option("models", {
   type: "string",
   describe: "Comma-separated model ids to expose from /v1/models.",
@@ -239,13 +219,24 @@ var createCliParser = (argv) => yargs(argv).scriptName("openai-oauth").strict().
 }).option("oauth-file", {
   type: "string",
   describe: "Path to the local auth.json file."
+}).option("open", {
+  type: "boolean",
+  default: true,
+  describe: "Open the login URL in a browser."
+}).option("login-timeout-ms", {
+  type: "number",
+  describe: "Login timeout in milliseconds. Default: 300000"
 });
 var isHelpFlag = (argv) => argv.includes("--help") || argv.includes("-h");
 var isVersionFlag = (argv) => argv.includes("--version");
 var toHelpMessage = () => helpLines.join("\n");
 var parseCliArgs = (argv) => {
-  const parsed = createCliParser(argv).parseSync();
+  const command = argv[0] === "login" ? "login" : "serve";
+  const parsed = createCliParser(
+    command === "login" ? argv.slice(1) : argv
+  ).parseSync();
   return {
+    command,
     host: parsed.host,
     port: parsed.port,
     models: parsed.models,
@@ -253,7 +244,9 @@ var parseCliArgs = (argv) => {
     baseURL: parsed.baseUrl,
     clientId: parsed.oauthClientId,
     tokenUrl: parsed.oauthTokenUrl,
-    authFilePath: parsed.oauthFile
+    authFilePath: parsed.oauthFile,
+    openBrowser: parsed.open,
+    loginTimeoutMs: parsed.loginTimeoutMs
   };
 };
 var toServerOptions = (args) => ({
@@ -266,6 +259,13 @@ var toServerOptions = (args) => ({
   tokenUrl: args.tokenUrl,
   authFilePath: args.authFilePath
 });
+var toLoginOptions = (args) => ({
+  clientId: args.clientId,
+  tokenUrl: args.tokenUrl,
+  authFilePath: args.authFilePath,
+  openBrowser: args.openBrowser,
+  timeoutMs: args.loginTimeoutMs
+});
 var findExistingAuthFile = async (authFilePath) => {
   for (const candidate of resolveAuthFileCandidates(authFilePath)) {
     try {
@@ -276,37 +276,166 @@ var findExistingAuthFile = async (authFilePath) => {
   }
   return void 0;
 };
+var findExistingCodexAuthFile = async (authFilePath) => {
+  const candidate = resolveCodexAuthFilePath(authFilePath);
+  try {
+    await access(candidate);
+    return candidate;
+  } catch {
+    return void 0;
+  }
+};
+var canPrompt = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+var parseConfirmationAnswer = (answer, defaultValue) => {
+  const normalized = answer.trim().toLowerCase();
+  if (!normalized) {
+    return defaultValue;
+  }
+  return normalized === "y" || normalized === "yes";
+};
+var confirm = async (question, defaultValue) => {
+  const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
+  const readline = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await readline.question(`${question}${suffix}`);
+    return parseConfirmationAnswer(answer, defaultValue);
+  } finally {
+    readline.close();
+  }
+};
+var toMissingAuthFilePrompt = (authFilePath) => {
+  const writePath = resolveCodexAuthFilePath(authFilePath);
+  return [
+    "No OpenAI OAuth credentials were found.",
+    `Sign in with ChatGPT now? This will write credentials to ${writePath}.`
+  ].join("\n");
+};
+var toOverwriteAuthFilePrompt = (authFilePath) => [
+  `OpenAI OAuth credentials already exist at ${authFilePath}.`,
+  "Sign in with ChatGPT again and overwrite them?"
+].join("\n");
 var toMissingAuthFileMessage = (authFilePath) => {
   if (authFilePath) {
     return [
       `No auth file was found at ${authFilePath}.`,
-      "Run `npx @openai/codex login` and try again."
+      "Run `npx openai-oauth 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."
+    "Run `npx openai-oauth login` and try again."
   ].join("\n");
 };
+var runUpdateCheck = () => checkForOpenAIOAuthUpdates(packageVersion, {
+  onWarning: defaultUpdateCheckWarning
+});
+var createLoginCancellation = () => {
+  const abortController = new AbortController();
+  let signalName;
+  const abort = (receivedSignal) => {
+    signalName = receivedSignal;
+    abortController.abort();
+  };
+  const onSigint = () => abort("SIGINT");
+  const onSigterm = () => abort("SIGTERM");
+  process.once("SIGINT", onSigint);
+  process.once("SIGTERM", onSigterm);
+  return {
+    signal: abortController.signal,
+    exitCode: () => signalName === "SIGTERM" ? 143 : 130,
+    dispose: () => {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+    }
+  };
+};
+var isLoginCancelledError = (error) => error instanceof Error && error.message === "OpenAI OAuth login cancelled.";
+var runLoginWithCancellation = async (options) => {
+  const cancellation = createLoginCancellation();
+  try {
+    await runOpenAIOAuthLogin({
+      ...options,
+      signal: cancellation.signal
+    });
+    return true;
+  } catch (error) {
+    if (cancellation.signal.aborted && isLoginCancelledError(error)) {
+      process.exitCode = cancellation.exitCode();
+      console.error("\nLogin cancelled.");
+      return false;
+    }
+    throw error;
+  } finally {
+    cancellation.dispose();
+  }
+};
 var runCli = async (argv = hideBin(process.argv)) => {
   if (isHelpFlag(argv)) {
     console.log(toHelpMessage());
     return;
   }
   if (isVersionFlag(argv)) {
-    console.log(package_default.version);
+    console.log(packageVersion);
     return;
   }
   installCliWarningLogger();
   const args = parseCliArgs(argv);
+  const updateCheck = runUpdateCheck();
+  if (args.command === "login") {
+    await updateCheck;
+    const loginOptions = toLoginOptions(args);
+    const existingAuthFile2 = await findExistingCodexAuthFile(
+      loginOptions.authFilePath
+    );
+    if (existingAuthFile2) {
+      if (!canPrompt()) {
+        throw new Error(
+          [
+            `OpenAI OAuth credentials already exist at ${existingAuthFile2}.`,
+            "Run `npx openai-oauth login` in an interactive terminal to confirm overwrite."
+          ].join("\n")
+        );
+      }
+      const shouldOverwrite = await confirm(
+        toOverwriteAuthFilePrompt(existingAuthFile2),
+        false
+      );
+      if (!shouldOverwrite) {
+        console.log("Login cancelled.");
+        return;
+      }
+    }
+    await runLoginWithCancellation(loginOptions);
+    return;
+  }
   const options = toServerOptions(args);
   const existingAuthFile = await findExistingAuthFile(options.authFilePath);
   if (!existingAuthFile) {
-    throw new Error(toMissingAuthFileMessage(options.authFilePath));
+    await updateCheck;
+    if (!canPrompt()) {
+      throw new Error(toMissingAuthFileMessage(options.authFilePath));
+    }
+    const shouldLogin = await confirm(
+      toMissingAuthFilePrompt(options.authFilePath),
+      true
+    );
+    if (!shouldLogin) {
+      console.log("Login cancelled.");
+      return;
+    }
+    const didLogin = await runLoginWithCancellation(toLoginOptions(args));
+    if (!didLogin) {
+      return;
+    }
   }
+  const auth = openaiCredentials(options);
   const client = createCodexOAuthClient({
     ...options,
+    auth: () => auth.getSession(),
     responsesState: false
   });
   const availableModels = await resolveOpenAIOAuthModels(
@@ -320,12 +449,6 @@ var runCli = async (argv = hideBin(process.argv)) => {
     }
   );
   const server = await startOpenAIOAuthServer(options);
-  if ((options.port ?? DEFAULT_PORT) !== server.port) {
-    console.log(
-      `Port ${options.port ?? DEFAULT_PORT} was unavailable. Using port ${server.port} instead.
-`
-    );
-  }
   console.log(
     toStartupMessage(
       `http://${server.host}:${server.port}/v1`,
@@ -335,11 +458,7 @@ var runCli = async (argv = hideBin(process.argv)) => {
       }
     )
   );
-  void checkForOpenAIOAuthUpdates(package_default.version, {
-    onWarning: (message) => {
-      console.error(message);
-    }
-  });
+  void updateCheck;
   const shutdown = async () => {
     await server.close();
     process.exit(0);

package/dist/index.d.ts

@@ -1,57 +1,20 @@
+import { SavedAuthTokens } from '@openai-oauth/core';
 import { Server } from 'node:http';
-import { FetchFunction } from '@ai-sdk/provider-utils';
+import { LocalOpenAIOAuthOptions } from '@openai-oauth/local';
 
-type AuthLoaderOptions = {
+type OpenAIOAuthLoginOptions = {
+    host?: string;
+    redirectHost?: string;
     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;
-    codexVersion?: string;
-    fetch?: FetchFunction;
-    headers?: Record<string, string>;
-    instructions?: string;
-    store?: boolean;
-    responsesState?: CodexResponsesState | false;
+    openBrowser?: boolean;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+    onMessage?: (message: string) => void;
+    signal?: AbortSignal;
 };
+declare const runOpenAIOAuthLogin: (options?: OpenAIOAuthLoginOptions) => Promise<SavedAuthTokens>;
 
 type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject;
 type JsonObject = {
@@ -134,7 +97,7 @@ type OpenAIOAuthServerLogEvent = ({
     requestId: string;
 };
 declare const defaultOpenAIOAuthModels: readonly string[];
-type OpenAIOAuthServerOptions = Omit<CodexOAuthSettings, "responsesState"> & {
+type OpenAIOAuthServerOptions = LocalOpenAIOAuthOptions & {
     host?: string;
     port?: number;
     models?: string[];
@@ -152,4 +115,4 @@ type RunningOpenAIOAuthServer = {
 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 };
+export { type OpenAIOAuthLoginOptions, type OpenAIOAuthServerLogEvent, type OpenAIOAuthServerOptions, type RunningOpenAIOAuthServer, createOpenAIOAuthFetchHandler, defaultOpenAIOAuthModels, runOpenAIOAuthLogin, startOpenAIOAuthServer };

package/dist/index.js

@@ -1,10 +1,12 @@
 import {
   createOpenAIOAuthFetchHandler,
   defaultOpenAIOAuthModels,
+  runOpenAIOAuthLogin,
   startOpenAIOAuthServer
-} from "./chunk-2AENSHRT.js";
+} from "./chunk-XZLFK5NT.js";
 export {
   createOpenAIOAuthFetchHandler,
   defaultOpenAIOAuthModels,
+  runOpenAIOAuthLogin,
   startOpenAIOAuthServer
 };

package/package.json

@@ -1,22 +1,36 @@
 {
 	"name": "openai-oauth",
-	"version": "1.0.2",
+	"version": "2.0.0-beta.0",
 	"description": "Free OpenAI API access with your ChatGPT account.",
+	"keywords": [
+		"openai",
+		"oauth",
+		"chatgpt",
+		"codex",
+		"cli",
+		"openai-compatible"
+	],
 	"type": "module",
+	"sideEffects": false,
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"bin": {
-		"openai-oauth": "./dist/cli.js"
+		"openai-oauth": "dist/cli.js"
 	},
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
 			"default": "./dist/index.js"
 		}
 	},
 	"files": [
-		"dist"
+		"dist",
+		"README.md",
+		"LICENSE"
 	],
 	"scripts": {
-		"build": "tsup src/index.ts src/cli.ts --format esm --dts --outDir dist --clean",
+		"build": "tsup src/index.ts src/cli.ts --format esm --dts --outDir dist --clean --loader .html=text",
 		"dev": "bun ./src/cli.ts",
 		"prepublishOnly": "bun run build",
 		"typecheck": "tsc --noEmit",
@@ -24,6 +38,9 @@
 		"test:live": "LIVE_CODEX_E2E=1 vitest run test/live.e2e.test.ts"
 	},
 	"dependencies": {
+		"@openai-oauth/ai-sdk": "2.0.0-beta.0",
+		"@openai-oauth/core": "2.0.0-beta.0",
+		"@openai-oauth/local": "2.0.0-beta.0",
 		"ai": "6.0.116",
 		"yargs": "^17.7.2"
 	},
@@ -31,14 +48,17 @@
 		"@ai-sdk/openai": "3.0.41",
 		"@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",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/EvanZhouDev/openai-oauth.git",
+		"directory": "packages/openai-oauth"
+	},
 	"bugs": {
 		"url": "https://github.com/EvanZhouDev/openai-oauth/issues"
 	},