openai-oauth 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/cli.js

@@ -4,17 +4,15 @@ import {
   resolveOpenAIOAuthModels,
   runOpenAIOAuthLogin,
   startOpenAIOAuthServer
-} from "./chunk-UZ3AHAWX.js";
+} from "./chunk-KROVQ42X.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";
 
@@ -61,6 +59,53 @@ var toStartupMessage = (baseUrl, availableModels, options) => [
   "",
   `Available Models: ${availableModels.join(", ")}`
 ].join("\n");
+var notRunning = "OpenAI OAuth is not running.";
+var cliMessages = {
+  foregroundControls: "[d] Run in background  [q] Quit",
+  backgroundActions: "Stop with `npx openai-oauth stop` or see logs with `npx openai-oauth logs --follow`",
+  notRunning,
+  notRunningWithStart: [notRunning, "", "Start with `npx openai-oauth`"].join(
+    "\n"
+  ),
+  noLogs: "No OpenAI OAuth logs found.",
+  followingLogs: "Following OpenAI OAuth logs. Press Ctrl+C to stop following.",
+  stopped: "OpenAI OAuth stopped.",
+  stoppedRemotely: "OpenAI OAuth was stopped from another terminal.",
+  couldNotStop: "Could not stop OpenAI OAuth.",
+  couldNotDetach: (details) => {
+    if (details?.startsWith("Could not move OpenAI OAuth to the background")) {
+      return details;
+    }
+    return details ? `Could not move OpenAI OAuth to the background: ${details}` : "Could not move OpenAI OAuth to the background.";
+  },
+  stoppedUnexpectedly: (details) => `OpenAI OAuth stopped unexpectedly (${details}).`,
+  workerStarted: (baseUrl) => `OpenAI OAuth started at ${baseUrl}`
+};
+var toForegroundStartupMessage = (baseUrl, availableModels, options) => [
+  toStartupMessage(baseUrl, availableModels, options),
+  "",
+  dim(cliMessages.foregroundControls, options)
+].join("\n");
+var toBackgroundStartupMessage = (baseUrl, availableModels, options) => [
+  toStartupMessage(baseUrl, availableModels, options),
+  "",
+  cliMessages.backgroundActions
+].join("\n");
+var toDetachedMessage = (baseUrl) => [
+  `OpenAI OAuth is now running in the background at ${baseUrl}`,
+  "",
+  cliMessages.backgroundActions
+].join("\n");
+var toAlreadyRunningMessage = (baseUrl) => [
+  `OpenAI OAuth is already running at ${baseUrl}`,
+  "",
+  cliMessages.backgroundActions
+].join("\n");
+var toRunningMessage = (baseUrl) => [
+  `OpenAI OAuth is running at ${baseUrl}`,
+  "",
+  cliMessages.backgroundActions
+].join("\n");
 var installCliWarningLogger = () => {
   let hasLoggedWarningSystemMessage = false;
   globalThis.AI_SDK_LOG_WARNINGS = ({ warnings, provider, model }) => {
@@ -80,6 +125,642 @@ var installCliWarningLogger = () => {
   };
 };
 
+// src/cli-runtime.ts
+import { spawn } from "child_process";
+import { randomBytes } from "crypto";
+import { promises as fs } from "fs";
+import { createServer } from "http";
+import os from "os";
+import path from "path";
+import { setTimeout as delay } from "timers/promises";
+var runtimeSchemaVersion = 1;
+var controlHost = "127.0.0.1";
+var internalRuntimeDirectoryVariable = "OPENAI_OAUTH_INTERNAL_RUNTIME_DIR";
+var internalDetachedFlag = "--internal-detached-child";
+var waitForChildExit = (child, timeoutMs) => {
+  if (child.exitCode != null || child.signalCode != null) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve) => {
+    const onExit = () => {
+      clearTimeout(timeout);
+      resolve(true);
+    };
+    const timeout = setTimeout(() => {
+      child.off("exit", onExit);
+      resolve(false);
+    }, timeoutMs);
+    child.once("exit", onExit);
+  });
+};
+var isNodeError = (error) => error instanceof Error;
+var resolveRuntimeDirectory = () => {
+  const override = process.env[internalRuntimeDirectoryVariable];
+  if (override) {
+    return override;
+  }
+  if (process.platform === "darwin") {
+    return path.join(
+      os.homedir(),
+      "Library",
+      "Application Support",
+      "openai-oauth"
+    );
+  }
+  if (process.platform === "win32") {
+    return path.join(
+      process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local"),
+      "openai-oauth"
+    );
+  }
+  return path.join(
+    process.env.XDG_STATE_HOME ?? path.join(os.homedir(), ".local", "state"),
+    "openai-oauth"
+  );
+};
+var resolveCliRuntimePaths = (directory = resolveRuntimeDirectory()) => ({
+  directory,
+  state: path.join(directory, "runtime.json"),
+  lock: path.join(directory, "runtime.lock"),
+  log: path.join(directory, "server.log")
+});
+var ensureRuntimeDirectory = async (paths) => {
+  await fs.mkdir(paths.directory, { recursive: true, mode: 448 });
+  try {
+    await fs.chmod(paths.directory, 448);
+  } catch {
+  }
+};
+var isRuntimeState = (value) => {
+  if (typeof value !== "object" || value == null) {
+    return false;
+  }
+  const state = value;
+  return state.schemaVersion === runtimeSchemaVersion && typeof state.instanceId === "string" && typeof state.pid === "number" && (state.mode === "foreground" || state.mode === "background") && typeof state.url === "string" && typeof state.startedAt === "string" && typeof state.version === "string" && typeof state.controlPort === "number" && typeof state.controlToken === "string";
+};
+var readJson = async (filePath) => {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch {
+    return void 0;
+  }
+};
+var readRuntimeState = async (paths) => {
+  const parsed = await readJson(paths.state);
+  return isRuntimeState(parsed) ? parsed : void 0;
+};
+var writeRuntimeState = async (paths, state) => {
+  const temporaryPath = `${paths.state}.${process.pid}.${randomBytes(4).toString("hex")}`;
+  await fs.writeFile(temporaryPath, `${JSON.stringify(state, null, 2)}
+`, {
+    mode: 384
+  });
+  await fs.rename(temporaryPath, paths.state);
+  try {
+    await fs.chmod(paths.state, 384);
+  } catch {
+  }
+};
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return isNodeError(error) && error.code === "EPERM";
+  }
+};
+var readLockPid = async (paths) => {
+  const parsed = await readJson(paths.lock);
+  if (typeof parsed !== "object" || parsed == null) {
+    return void 0;
+  }
+  const pid = parsed.pid;
+  return typeof pid === "number" ? pid : void 0;
+};
+var removeIfPresent = async (filePath) => {
+  await fs.rm(filePath, { force: true }).catch(() => void 0);
+};
+var fetchWithTimeout = async (input, init, timeoutMs = 750) => {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  if (typeof timeout === "object" && "unref" in timeout) {
+    timeout.unref();
+  }
+  try {
+    return await fetch(input, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+var probeRuntime = async (state) => {
+  try {
+    const response = await fetchWithTimeout(
+      `http://${controlHost}:${state.controlPort}/state`,
+      {
+        headers: { authorization: `Bearer ${state.controlToken}` }
+      }
+    );
+    if (!response.ok) {
+      return false;
+    }
+    const body = await response.json();
+    return body.instanceId === state.instanceId;
+  } catch {
+    return false;
+  }
+};
+var findRunningCliRuntime = async (directory) => {
+  const paths = resolveCliRuntimePaths(directory);
+  const state = await readRuntimeState(paths);
+  if (!state) {
+    return void 0;
+  }
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    if (await probeRuntime(state)) {
+      return state;
+    }
+    await delay(50);
+  }
+  await removeIfPresent(paths.state);
+  await removeIfPresent(paths.lock);
+  return void 0;
+};
+var CliRuntimeAlreadyRunningError = class extends Error {
+  state;
+  constructor(state) {
+    super(toAlreadyRunningMessage(state.url));
+    this.name = "CliRuntimeAlreadyRunningError";
+    this.state = state;
+  }
+};
+var acquireCliRuntimeLock = async (directory) => {
+  const paths = resolveCliRuntimePaths(directory);
+  await ensureRuntimeDirectory(paths);
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    try {
+      const handle = await fs.open(paths.lock, "wx", 384);
+      await handle.writeFile(
+        `${JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`
+      );
+      await handle.close();
+      let released = false;
+      return {
+        paths,
+        release: async () => {
+          if (released) {
+            return;
+          }
+          released = true;
+          await removeIfPresent(paths.lock);
+        }
+      };
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "EEXIST") {
+        throw error;
+      }
+      const running = await findRunningCliRuntime(directory);
+      if (running) {
+        throw new CliRuntimeAlreadyRunningError(running);
+      }
+      const ownerPid = await readLockPid(paths);
+      if (ownerPid == null || !isProcessAlive(ownerPid)) {
+        await removeIfPresent(paths.lock);
+        continue;
+      }
+      await delay(100);
+    }
+  }
+  throw new Error("OpenAI OAuth is already starting in another process.");
+};
+var closeServer = (server) => new Promise((resolve, reject) => {
+  if (!server.listening) {
+    resolve();
+    return;
+  }
+  server.close((error) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve();
+  });
+});
+var activateCliRuntime = async (lock, options) => {
+  const instanceId = randomBytes(16).toString("hex");
+  const controlToken = randomBytes(32).toString("hex");
+  let state;
+  const controlServer = createServer((request, response) => {
+    if (request.headers.authorization !== `Bearer ${controlToken}`) {
+      response.writeHead(401).end();
+      return;
+    }
+    if (request.method === "GET" && request.url === "/state") {
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(JSON.stringify({ instanceId: state.instanceId }));
+      return;
+    }
+    if (request.method === "POST" && request.url === "/stop") {
+      response.writeHead(202).end();
+      setImmediate(() => void options.onStop());
+      return;
+    }
+    response.writeHead(404).end();
+  });
+  try {
+    await new Promise((resolve, reject) => {
+      controlServer.once("error", reject);
+      controlServer.listen(0, controlHost, () => {
+        controlServer.off("error", reject);
+        resolve();
+      });
+    });
+    const address = controlServer.address();
+    state = {
+      schemaVersion: runtimeSchemaVersion,
+      instanceId,
+      pid: process.pid,
+      mode: options.mode,
+      url: options.url,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: options.version,
+      controlPort: address.port,
+      controlToken
+    };
+    await writeRuntimeState(lock.paths, state);
+  } catch (error) {
+    await closeServer(controlServer).catch(() => void 0);
+    await lock.release();
+    throw error;
+  }
+  let closed = false;
+  return {
+    state,
+    logPath: lock.paths.log,
+    setMode: async (mode) => {
+      if (state.mode === mode) {
+        return;
+      }
+      state = { ...state, mode };
+      await writeRuntimeState(lock.paths, state);
+    },
+    close: async () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      const current = await readRuntimeState(lock.paths);
+      if (current?.instanceId === state.instanceId) {
+        await removeIfPresent(lock.paths.state);
+      }
+      await closeServer(controlServer).catch(() => void 0);
+      await lock.release();
+    }
+  };
+};
+var stopCliRuntime = async (state, directory) => {
+  try {
+    const response = await fetchWithTimeout(
+      `http://${controlHost}:${state.controlPort}/stop`,
+      {
+        method: "POST",
+        headers: { authorization: `Bearer ${state.controlToken}` }
+      }
+    );
+    if (!response.ok) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    if (!await findRunningCliRuntime(directory)) {
+      return true;
+    }
+    await delay(100);
+  }
+  return false;
+};
+var isCliWorkerMessage = (value) => {
+  if (typeof value !== "object" || value == null) {
+    return false;
+  }
+  const message = value;
+  return message.type === "openai-oauth:ready" && typeof message.url === "string" && Array.isArray(message.models) || message.type === "openai-oauth:error" && typeof message.message === "string" || message.type === "openai-oauth:detached" || message.type === "openai-oauth:stopping" && message.source === "remote";
+};
+var waitForWorkerMessage = (child, predicate, timeoutMs) => new Promise((resolve, reject) => {
+  let settled = false;
+  const timeout = setTimeout(() => {
+    finish(new Error(`OpenAI OAuth did not respond within ${timeoutMs}ms.`));
+  }, timeoutMs);
+  const cleanup = () => {
+    clearTimeout(timeout);
+    child.off("message", onMessage);
+    child.off("error", onError);
+    child.off("exit", onExit);
+  };
+  const finish = (error, message) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    cleanup();
+    if (error) {
+      reject(error);
+      return;
+    }
+    if (!message) {
+      reject(new Error("OpenAI OAuth worker returned an empty response."));
+      return;
+    }
+    resolve(message);
+  };
+  const onMessage = (value) => {
+    if (!isCliWorkerMessage(value)) {
+      return;
+    }
+    if (value.type === "openai-oauth:error") {
+      finish(new Error(value.message));
+      return;
+    }
+    if (predicate(value)) {
+      finish(void 0, value);
+    }
+  };
+  const onError = (error) => finish(error);
+  const onExit = (code, signal) => finish(
+    new Error(
+      `OpenAI OAuth exited unexpectedly (${signal ?? code ?? "unknown"}).`
+    )
+  );
+  child.on("message", onMessage);
+  child.once("error", onError);
+  child.once("exit", onExit);
+});
+var startCliWorker = async (argv, options = {}) => {
+  const paths = resolveCliRuntimePaths(options.runtimeDirectory);
+  await ensureRuntimeDirectory(paths);
+  const logHandle = await fs.open(paths.log, "a", 384);
+  let child;
+  const entryPath = options.entryPath ?? process.argv[1];
+  if (!entryPath) {
+    await logHandle.close();
+    throw new Error("Could not resolve the OpenAI OAuth CLI entrypoint.");
+  }
+  try {
+    child = spawn(
+      process.execPath,
+      [
+        entryPath,
+        ...argv.filter((argument) => argument !== internalDetachedFlag),
+        internalDetachedFlag
+      ],
+      {
+        detached: true,
+        windowsHide: true,
+        stdio: ["ignore", logHandle.fd, logHandle.fd, "ipc"],
+        env: {
+          ...process.env,
+          ...options.runtimeDirectory ? {
+            [internalRuntimeDirectoryVariable]: options.runtimeDirectory
+          } : {}
+        }
+      }
+    );
+  } finally {
+    await logHandle.close();
+  }
+  let ready;
+  try {
+    ready = await waitForWorkerMessage(
+      child,
+      (message) => message.type === "openai-oauth:ready",
+      options.timeoutMs ?? 15e3
+    );
+  } catch (error) {
+    if (child.pid) {
+      try {
+        process.kill(child.pid, "SIGTERM");
+      } catch {
+      }
+    }
+    if (child.connected) {
+      child.disconnect();
+    }
+    child.unref();
+    throw error;
+  }
+  return {
+    child,
+    url: ready.url,
+    models: ready.models,
+    logPath: paths.log,
+    detach: async () => {
+      const acknowledged = waitForWorkerMessage(
+        child,
+        (message) => message.type === "openai-oauth:detached",
+        5e3
+      );
+      child.send?.({ type: "openai-oauth:detach" });
+      await acknowledged;
+      if (child.connected) {
+        child.disconnect();
+      }
+      child.unref();
+    },
+    stop: async () => {
+      child.send?.({ type: "openai-oauth:stop" });
+      if (await waitForChildExit(child, 5e3)) {
+        return;
+      }
+      child.kill("SIGTERM");
+      if (await waitForChildExit(child, 1e3)) {
+        return;
+      }
+      if (child.connected) {
+        child.disconnect();
+      }
+      child.unref();
+      throw new Error("OpenAI OAuth did not stop within 6000ms.");
+    }
+  };
+};
+var readLogSlice = async (filePath, start) => {
+  try {
+    const stat = await fs.stat(filePath);
+    const safeStart = stat.size < start ? 0 : start;
+    if (stat.size === safeStart) {
+      return { text: "", size: stat.size };
+    }
+    const handle = await fs.open(filePath, "r");
+    try {
+      const buffer = Buffer.alloc(stat.size - safeStart);
+      await handle.read(buffer, 0, buffer.length, safeStart);
+      return { text: buffer.toString("utf8"), size: stat.size };
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return { text: "", size: 0 };
+    }
+    throw error;
+  }
+};
+var readRecentCliLogs = async (directory, lineCount = 50) => {
+  const { log } = resolveCliRuntimePaths(directory);
+  try {
+    const stat = await fs.stat(log);
+    const start = Math.max(0, stat.size - 64 * 1024);
+    const { text } = await readLogSlice(log, start);
+    return text.split("\n").slice(-lineCount - 1).join("\n").trimEnd();
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+};
+var followCliLogs = async (write, signal, directory, fromStart = false) => {
+  const { log } = resolveCliRuntimePaths(directory);
+  let offset = 0;
+  if (!fromStart) {
+    try {
+      offset = (await fs.stat(log)).size;
+    } catch {
+    }
+  }
+  while (!signal.aborted) {
+    try {
+      await delay(250, void 0, { signal });
+    } catch {
+      break;
+    }
+    const next = await readLogSlice(log, offset);
+    offset = next.size;
+    if (next.text) {
+      write(next.text);
+    }
+  }
+};
+var sendDetachedReady = (url, models) => {
+  process.send?.({ type: "openai-oauth:ready", url, models });
+};
+var sendDetachedAcknowledgement = () => {
+  process.send?.({ type: "openai-oauth:detached" });
+};
+var sendRemoteStopping = () => new Promise((resolve) => {
+  if (!process.send) {
+    resolve();
+    return;
+  }
+  process.send(
+    { type: "openai-oauth:stopping", source: "remote" },
+    () => resolve()
+  );
+});
+var sendDetachedError = (message) => new Promise((resolve) => {
+  if (!process.send) {
+    resolve();
+    return;
+  }
+  process.send({ type: "openai-oauth:error", message }, () => resolve());
+});
+
+// src/cli-worker.ts
+import { createCodexOAuthClient } from "@openai-oauth/core";
+import { openaiCredentials } from "@openai-oauth/local";
+var isWorkerCommand = (value) => {
+  if (typeof value !== "object" || value == null) {
+    return false;
+  }
+  const type = value.type;
+  return type === "openai-oauth:detach" || type === "openai-oauth:stop";
+};
+var startCliInstance = async (options, mode, version, onRemoteStop) => {
+  const lock = await acquireCliRuntimeLock();
+  let server;
+  try {
+    const auth = openaiCredentials(options);
+    const client = createCodexOAuthClient({
+      ...options,
+      auth: () => auth.getSession(),
+      responsesState: false
+    });
+    const models = await resolveOpenAIOAuthModels(client, options.models);
+    server = await startOpenAIOAuthServer(options);
+    const runtime = await activateCliRuntime(lock, {
+      mode,
+      url: server.url,
+      version,
+      onStop: onRemoteStop
+    });
+    return { server, runtime, models };
+  } catch (error) {
+    await server?.close().catch(() => void 0);
+    await lock.release();
+    throw error;
+  }
+};
+var runCliWorker = async (options, initialMode, version) => {
+  if (typeof process.send !== "function") {
+    throw new Error("OpenAI OAuth worker requires an IPC channel.");
+  }
+  let detached = false;
+  let stopping = false;
+  let instance;
+  const shutdown = async (source) => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    if (source === "remote") {
+      await sendRemoteStopping();
+    }
+    await instance?.server.close().catch(() => void 0);
+    await instance?.runtime.close().catch(() => void 0);
+    if (process.connected) {
+      process.disconnect();
+    }
+    process.exit(0);
+  };
+  instance = await startCliInstance(options, initialMode, version, () => {
+    void shutdown("remote");
+  });
+  const onMessage = (value) => {
+    if (!isWorkerCommand(value) || stopping) {
+      return;
+    }
+    if (value.type === "openai-oauth:stop") {
+      void shutdown("parent");
+      return;
+    }
+    void (async () => {
+      try {
+        await instance?.runtime.setMode("background");
+        detached = true;
+        sendDetachedAcknowledgement();
+      } catch (error) {
+        await sendDetachedError(
+          error instanceof Error ? error.message : cliMessages.couldNotDetach()
+        );
+      }
+    })();
+  };
+  const onDisconnect = () => {
+    if (!detached) {
+      void shutdown("disconnect");
+    }
+  };
+  const onSignal = () => void shutdown("signal");
+  process.on("message", onMessage);
+  process.once("disconnect", onDisconnect);
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  console.log(cliMessages.workerStarted(instance.server.url));
+  sendDetachedReady(instance.server.url, instance.models);
+};
+
 // src/update-check.ts
 var REGISTRY_URL = "https://registry.npmjs.org/openai-oauth/latest";
 var normalizeVersion = (value) => {
@@ -154,7 +835,7 @@ Run \`npx openai-oauth@latest\` to use the newest version.`
 };
 
 // src/version.ts
-var packageVersion = "2.0.0-beta.2";
+var packageVersion = "2.0.0-beta.3";
 
 // src/cli-app.ts
 var defaultUpdateCheckWarning = (message) => {
@@ -172,6 +853,10 @@ var helpLines = [
   "",
   "Usage",
   "  npx openai-oauth@latest [options]",
+  "  npx openai-oauth@latest --detach [options]",
+  "  npx openai-oauth@latest status",
+  "  npx openai-oauth@latest logs [--follow]",
+  "  npx openai-oauth@latest stop",
   "  npx openai-oauth@latest login [options]",
   "",
   "Options",
@@ -187,6 +872,8 @@ var helpLines = [
   "  --login-timeout-ms <ms>    Login timeout. Default: 300000",
   "",
   "Flags",
+  "  -d, --detach               Run in the background",
+  "  -f, --follow               Follow logs",
   "  --help                     Show help",
   `  --version                  Show version (${packageVersion})`,
   "",
@@ -226,14 +913,31 @@ var createCliParser = (argv) => yargs(argv).scriptName("openai-oauth").strict().
 }).option("login-timeout-ms", {
   type: "number",
   describe: "Login timeout in milliseconds. Default: 300000"
-});
+}).option("detach", {
+  alias: "d",
+  type: "boolean",
+  default: false,
+  describe: "Run in the background."
+}).option("follow", {
+  alias: "f",
+  type: "boolean",
+  default: false,
+  describe: "Follow logs."
+}).option("internal-detached-child", {
+  type: "boolean",
+  default: false
+}).hide("internal-detached-child");
 var isHelpFlag = (argv) => argv.includes("--help") || argv.includes("-h");
 var isVersionFlag = (argv) => argv.includes("--version");
 var toHelpMessage = () => helpLines.join("\n");
 var parseCliArgs = (argv) => {
-  const command = argv[0] === "login" ? "login" : "serve";
+  const first = argv[0];
+  if (first && !first.startsWith("-") && first !== "serve" && first !== "login" && first !== "logs" && first !== "status" && first !== "stop") {
+    throw new Error(`Unknown command: ${first}`);
+  }
+  const command = first === "login" || first === "logs" || first === "status" || first === "stop" ? first : "serve";
   const parsed = createCliParser(
-    command === "login" ? argv.slice(1) : argv
+    command === "serve" && first !== "serve" ? argv : argv.slice(1)
   ).parseSync();
   return {
     command,
@@ -246,7 +950,10 @@ var parseCliArgs = (argv) => {
     tokenUrl: parsed.oauthTokenUrl,
     authFilePath: parsed.oauthFile,
     openBrowser: parsed.open,
-    loginTimeoutMs: parsed.loginTimeoutMs
+    loginTimeoutMs: parsed.loginTimeoutMs,
+    detach: parsed.detach,
+    follow: parsed.follow,
+    internalDetachedChild: parsed.internalDetachedChild
   };
 };
 var toServerOptions = (args) => ({
@@ -313,8 +1020,9 @@ var toMissingAuthFilePrompt = (authFilePath) => {
     `Sign in with ChatGPT now? This will write credentials to ${writePath}.`
   ].join("\n");
 };
+var toExistingAuthFileMessage = (authFilePath) => `OpenAI OAuth credentials already exist at ${authFilePath}.`;
 var toOverwriteAuthFilePrompt = (authFilePath) => [
-  `OpenAI OAuth credentials already exist at ${authFilePath}.`,
+  toExistingAuthFileMessage(authFilePath),
   "Sign in with ChatGPT again and overwrite them?"
 ].join("\n");
 var toMissingAuthFileMessage = (authFilePath) => {
@@ -373,6 +1081,200 @@ var runLoginWithCancellation = async (options) => {
     cancellation.dispose();
   }
 };
+var runLogsCommand = async (follow) => {
+  const recent = await readRecentCliLogs();
+  const running = await findRunningCliRuntime();
+  if (!running) {
+    console.log(cliMessages.notRunningWithStart);
+    return;
+  }
+  if (!follow) {
+    console.log(recent || cliMessages.noLogs);
+    return;
+  }
+  console.log(cliMessages.followingLogs);
+  if (recent) {
+    console.log(recent);
+  }
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  process.once("SIGINT", abort);
+  process.once("SIGTERM", abort);
+  try {
+    await followCliLogs((text) => process.stdout.write(text), controller.signal);
+  } finally {
+    process.off("SIGINT", abort);
+    process.off("SIGTERM", abort);
+  }
+};
+var runStopCommand = async () => {
+  const running = await findRunningCliRuntime();
+  if (!running) {
+    console.log(cliMessages.notRunning);
+    return;
+  }
+  if (!await stopCliRuntime(running)) {
+    throw new Error(cliMessages.couldNotStop);
+  }
+  console.log(cliMessages.stopped);
+};
+var runStatusCommand = async () => {
+  const running = await findRunningCliRuntime();
+  if (!running) {
+    console.log(cliMessages.notRunningWithStart);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(toRunningMessage(running.url));
+};
+var runForegroundController = async (worker) => new Promise((resolve, reject) => {
+  const interactive = canPrompt();
+  const stdin = process.stdin;
+  const logController = new AbortController();
+  const previousRawMode = stdin.isRaw;
+  let menuShown = false;
+  let completing = false;
+  let remoteStopping = false;
+  let rawModeEnabled = false;
+  const cleanup = () => {
+    logController.abort();
+    stdin.off("data", onData);
+    process.off("SIGINT", onSigint);
+    process.off("SIGTERM", onSigterm);
+    worker.child.off("message", onWorkerMessage);
+    worker.child.off("error", onWorkerError);
+    worker.child.off("exit", onWorkerExit);
+    if (rawModeEnabled && stdin.setRawMode) {
+      stdin.setRawMode(previousRawMode ?? false);
+    }
+    if (interactive) {
+      stdin.pause();
+    }
+  };
+  const finish = (error) => {
+    cleanup();
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve();
+  };
+  const quit = async (showMessage) => {
+    if (completing) {
+      return;
+    }
+    completing = true;
+    try {
+      await worker.stop();
+      if (showMessage) {
+        console.log(`
+${cliMessages.stopped}`);
+      }
+      finish();
+    } catch (error) {
+      finish(
+        error instanceof Error ? error : new Error(cliMessages.couldNotStop)
+      );
+    }
+  };
+  const detach = async () => {
+    if (completing) {
+      return;
+    }
+    completing = true;
+    try {
+      await worker.detach();
+      console.log(`
+${toDetachedMessage(worker.url)}`);
+      finish();
+    } catch (error) {
+      completing = false;
+      console.error(
+        `
+${cliMessages.couldNotDetach(
+          error instanceof Error ? error.message : void 0
+        )}`
+      );
+    }
+  };
+  const handleInterrupt = () => {
+    if (!interactive || menuShown) {
+      void quit(interactive);
+      return;
+    }
+    menuShown = true;
+    console.log(`
+${cliMessages.foregroundControls}`);
+  };
+  function onData(value) {
+    const input = value.toString().toLowerCase();
+    if (input.includes("")) {
+      handleInterrupt();
+      return;
+    }
+    if (input.includes("d")) {
+      void detach();
+      return;
+    }
+    if (input.includes("q")) {
+      void quit(true);
+    }
+  }
+  function onSigint() {
+    handleInterrupt();
+  }
+  function onSigterm() {
+    void quit(false);
+  }
+  function onWorkerMessage(value) {
+    const message = value;
+    if (message.type === "openai-oauth:stopping" && message.source === "remote") {
+      remoteStopping = true;
+    }
+  }
+  function onWorkerError(error) {
+    if (!completing) {
+      finish(error);
+    }
+  }
+  function onWorkerExit(code, signal) {
+    if (completing) {
+      return;
+    }
+    if (remoteStopping) {
+      console.log(`
+${cliMessages.stoppedRemotely}`);
+      finish();
+      return;
+    }
+    finish(
+      new Error(
+        cliMessages.stoppedUnexpectedly(signal ?? `${code ?? "unknown"}`)
+      )
+    );
+  }
+  if (interactive) {
+    if (stdin.setRawMode) {
+      stdin.setRawMode(true);
+      rawModeEnabled = true;
+    }
+    stdin.resume();
+    stdin.on("data", onData);
+  }
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
+  worker.child.on("message", onWorkerMessage);
+  worker.child.once("error", onWorkerError);
+  worker.child.once("exit", onWorkerExit);
+  void followCliLogs(
+    (text) => process.stdout.write(text),
+    logController.signal
+  ).catch((error) => {
+    if (!logController.signal.aborted) {
+      console.error(error instanceof Error ? error.message : error);
+    }
+  });
+});
 var runCli = async (argv = hideBin(process.argv)) => {
   if (isHelpFlag(argv)) {
     console.log(toHelpMessage());
@@ -384,9 +1286,36 @@ var runCli = async (argv = hideBin(process.argv)) => {
   }
   installCliWarningLogger();
   const args = parseCliArgs(argv);
-  const updateCheck = runUpdateCheck();
+  if (args.internalDetachedChild) {
+    try {
+      await runCliWorker(
+        toServerOptions(args),
+        args.detach ? "background" : "foreground",
+        packageVersion
+      );
+    } catch (error) {
+      await sendDetachedError(
+        error instanceof Error ? error.message : "Failed to start OpenAI OAuth."
+      );
+      throw error;
+    }
+    return;
+  }
+  if (args.command === "logs") {
+    await runLogsCommand(Boolean(args.follow));
+    return;
+  }
+  if (args.command === "stop") {
+    await runStopCommand();
+    return;
+  }
+  if (args.command === "status") {
+    await runStatusCommand();
+    return;
+  }
   if (args.command === "login") {
-    await updateCheck;
+    const updateCheck2 = runUpdateCheck();
+    await updateCheck2;
     const loginOptions = toLoginOptions(args);
     const existingAuthFile2 = await findExistingCodexAuthFile(
       loginOptions.authFilePath
@@ -395,7 +1324,7 @@ var runCli = async (argv = hideBin(process.argv)) => {
       if (!canPrompt()) {
         throw new Error(
           [
-            `OpenAI OAuth credentials already exist at ${existingAuthFile2}.`,
+            toExistingAuthFileMessage(existingAuthFile2),
             "Run `npx openai-oauth login` in an interactive terminal to confirm overwrite."
           ].join("\n")
         );
@@ -412,6 +1341,12 @@ var runCli = async (argv = hideBin(process.argv)) => {
     await runLoginWithCancellation(loginOptions);
     return;
   }
+  const running = await findRunningCliRuntime();
+  if (running) {
+    console.log(toAlreadyRunningMessage(running.url));
+    return;
+  }
+  const updateCheck = runUpdateCheck();
   const options = toServerOptions(args);
   const existingAuthFile = await findExistingAuthFile(options.authFilePath);
   if (!existingAuthFile) {
@@ -432,34 +1367,23 @@ var runCli = async (argv = hideBin(process.argv)) => {
       return;
     }
   }
-  const auth = openaiCredentials(options);
-  const client = createCodexOAuthClient({
-    ...options,
-    auth: () => auth.getSession(),
-    responsesState: false
-  });
-  const availableModels = await resolveOpenAIOAuthModels(client, options.models);
-  const server = await startOpenAIOAuthServer(options);
-  console.log(
-    toStartupMessage(
-      `http://${server.host}:${server.port}/v1`,
-      availableModels,
-      {
+  const worker = await startCliWorker(argv);
+  await updateCheck;
+  if (args.detach) {
+    await worker.detach();
+    console.log(
+      toBackgroundStartupMessage(worker.url, worker.models, {
         useColor: process.stdout.isTTY
-      }
-    )
+      })
+    );
+    return;
+  }
+  console.log(
+    toForegroundStartupMessage(worker.url, worker.models, {
+      useColor: process.stdout.isTTY
+    })
   );
-  void updateCheck;
-  const shutdown = async () => {
-    await server.close();
-    process.exit(0);
-  };
-  process.on("SIGINT", () => {
-    void shutdown();
-  });
-  process.on("SIGTERM", () => {
-    void shutdown();
-  });
+  await runForegroundController(worker);
 };
 
 // src/cli.ts