@moxxy/plugin-provider-codex-agent 0.0.0-stage → 0.46.0

package/src/index.test.ts

@@ -0,0 +1,45 @@
+/** The plugin entry: the conversation's Codex ends when the conversation does. */
+import { describe, expect, it } from 'vitest';
+import { collectTurn } from '@moxxy/core';
+import { assertDefined } from '@moxxy/sdk';
+import { createFakeSession } from '@moxxy/testing';
+import { defaultModePlugin } from '@moxxy/mode-default';
+import { CodexAgentProvider, codexSessions, codexAgentPlugin } from './index.js';
+import { FakeCodex } from './fake-codex.testkit.js';
+
+describe('the Codex plugin', () => {
+  it('starts a new conversation on GPT-6 Luna while the person chose no default model', async () => {
+    const { codexAgentProviderDef } = await import('./index.js');
+    const provider = new CodexAgentProvider({ startAppServer: new FakeCodex(async () => undefined).start });
+    const session = createFakeSession({ provider, plugins: [defaultModePlugin] });
+
+    expect(session.getInfo().defaultModel).toBe('gpt-6-luna');
+    expect(codexAgentProviderDef.starterModel).toBe('gpt-6-luna');
+    await session.close();
+  });
+
+  it('closes the conversation running Codex when the conversation shuts down', async () => {
+    const codex = new FakeCodex(async (turn) => {
+      await turn.say('hi');
+    });
+    const provider = new CodexAgentProvider({ startAppServer: codex.start });
+    const session = createFakeSession({ provider, plugins: [defaultModePlugin] });
+    await collectTurn(session, 'hello');
+    expect(codexSessions().size).toBe(1);
+
+    const onShutdown = codexAgentPlugin.hooks?.onShutdown;
+    assertDefined(onShutdown, 'the plugin onShutdown hook');
+    await onShutdown(session.appContext());
+
+    expect(codex.last.closed).toBe(true);
+    expect(codexSessions().size).toBe(0);
+    await session.close();
+  });
+
+  it("lists the models the person's Codex offers, and still knows its newest when Codex is not asked", async () => {
+    const { codexAgentProviderDef, codexAgentModels } = await import('./index.js');
+
+    expect(typeof codexAgentProviderDef.agentCli?.models).toBe('function');
+    expect(codexAgentModels.map((m) => m.id)).toContain('gpt-6.1-sol');
+  });
+});

package/src/index.ts

@@ -0,0 +1,99 @@
+import { homedir } from 'node:os';
+import { defineProvider, definePlugin, MoxxyError } from '@moxxy/sdk';
+import { CODEX_CLI, checkAgentCli } from '@moxxy/agent-connection-kit';
+import { CODEX_AGENT_NAME, CODEX_AGENT_PROVIDER_ID, CODEX_SERVICE_NAME } from './constants.js';
+import { CODEX_AGENT_STARTER_MODEL, codexAgentModels, codexSessions, createCodexAgentClient, type CodexAgentProviderConfig } from './agent-provider.js';
+import { codexTarget, spawnCodexAppServer } from './executable.js';
+import { codexOwnAutoApprove } from './own-settings.js';
+import { codexOfferedModels } from './offered-models.js';
+import { authError, checkCodexAuth, codexLogin, codexLogout, codexSignIn, codexStatus, resolveCodexExecutable } from './login.js';
+
+export const codexAgentProviderDef = defineProvider({
+  name: CODEX_AGENT_PROVIDER_ID,
+  agentName: CODEX_AGENT_NAME,
+  models: codexAgentModels,
+  starterModel: CODEX_AGENT_STARTER_MODEL,
+  agentCli: {
+    check: (opts) => {
+      const command = resolveCodexExecutable();
+      return checkAgentCli(CODEX_CLI, { command, refresh: opts?.refresh === true }, { signIn: () => codexSignIn(command) });
+    },
+    // Asked outside any project, so no folder's config narrows the list.
+    models: () => codexOfferedModels(homedir(), spawnCodexAppServer(resolveCodexExecutable())),
+  },
+  ownAutoApprove: ({ cwd }) => codexOwnAutoApprove(cwd, spawnCodexAppServer(resolveCodexExecutable())),
+  createClient: (config) => createCodexAgentClient(providerConfigFrom(config)),
+  async resolveCredentials({ providerConfig, host }) {
+    const config = { ...providerConfig, cwd: host.cwd };
+    const executable = resolveCodexExecutable(config);
+    const status = await checkCodexAuth(executable);
+    if (status.state !== 'signed-in') throw authError(status);
+    try {
+      codexTarget(executable);
+    } catch (err) {
+      throw new MoxxyError({
+        code: 'AUTH_INVALID',
+        message: err instanceof Error ? err.message : String(err),
+        context: { provider: CODEX_AGENT_PROVIDER_ID, executable },
+      });
+    }
+    return { ...config, executable };
+  },
+  // No validateKey: readiness is reported by the installed Codex CLI.
+  auth: {
+    kind: 'oauth',
+    serviceName: CODEX_SERVICE_NAME,
+    login: codexLogin,
+    logout: codexLogout,
+    status: codexStatus,
+  },
+});
+
+export const codexAgentPlugin = definePlugin({
+  name: '@moxxy/plugin-provider-codex-agent',
+  version: '0.0.0',
+  providers: [codexAgentProviderDef],
+  hooks: {
+    // The conversation's Codex ends with it; its thread stays saved by Codex, to resume.
+    onShutdown: (ctx) => codexSessions().close(String(ctx.sessionId)),
+  },
+});
+
+export default codexAgentPlugin;
+
+function providerConfigFrom(config: Readonly<Record<string, unknown>>): CodexAgentProviderConfig {
+  const text = (key: string) => (typeof config[key] === 'string' && config[key] !== '' ? (config[key] as string) : undefined);
+  const executable = text('executable');
+  const model = text('model');
+  const defaultModel = text('defaultModel');
+  const cwd = text('cwd');
+  return {
+    ...(executable ? { executable } : {}),
+    ...(model ? { model } : {}),
+    ...(defaultModel ? { defaultModel } : {}),
+    ...(cwd ? { cwd } : {}),
+  };
+}
+
+export { CODEX_AGENT_PROVIDER_ID, CODEX_SERVICE_NAME, CODEX_EXECUTABLE_ENV } from './constants.js';
+export {
+  CODEX_AGENT_DEFAULT_MODEL,
+  CODEX_AGENT_STARTER_MODEL,
+  CodexAgentProvider,
+  codexAgentModels,
+  codexSessions,
+  createCodexAgentClient,
+  type CodexAgentProviderConfig,
+} from './agent-provider.js';
+export type { CodexConnection, StartCodexAppServer } from './codex-session.js';
+export { codexTarget, spawnCodexAppServer } from './executable.js';
+export {
+  __setCodexCommandRunner,
+  checkCodexAuth,
+  codexLogin,
+  codexLogout,
+  codexStatus,
+  resolveCodexExecutable,
+  type CodexAuthState,
+  type CodexAuthStatus,
+} from './login.js';

package/src/login.test.ts

@@ -0,0 +1,93 @@
+import { afterAll, beforeEach, describe, expect, it } from 'vitest';
+import type { ProviderAuthContext } from '@moxxy/sdk';
+import { __setCodexCommandRunner, checkCodexAuth, codexLogin, codexLogout, codexStatus, resolveCodexExecutable } from './login.js';
+
+function ctx(extra: Partial<ProviderAuthContext> = {}): ProviderAuthContext {
+  return {
+    headless: false,
+    write: () => {},
+    vault: { get: async () => null, set: async () => {}, delete: async () => false },
+    ...extra,
+  };
+}
+
+const run = (stdout: string, code = 0, stderr = '') => Promise.resolve({ code, stdout, stderr });
+
+beforeEach(() => {
+  delete process.env.CODEX_EXECUTABLE;
+});
+
+afterAll(() => {
+  __setCodexCommandRunner(async () => ({ code: 1, stdout: '', stderr: 'not configured' }));
+});
+
+describe('Codex sign-in, read from the person own Codex', () => {
+  it('reads a ChatGPT sign-in from `codex login status`', async () => {
+    const calls: string[][] = [];
+    __setCodexCommandRunner(async (_exe, args) => {
+      calls.push([...args]);
+      return run('Logged in using ChatGPT\n');
+    });
+    await expect(checkCodexAuth()).resolves.toMatchObject({ state: 'signed-in', executable: 'codex', accountId: 'ChatGPT' });
+    expect(calls).toEqual([['login', 'status']]);
+  });
+
+  it('reads a signed-out Codex', async () => {
+    __setCodexCommandRunner(async () => run('', 1, 'Not logged in\n'));
+    await expect(checkCodexAuth()).resolves.toMatchObject({ state: 'signed-out' });
+  });
+
+  it('says Codex is missing when it is not installed', async () => {
+    __setCodexCommandRunner(async () => ({ code: 1, stdout: '', stderr: '', error: Object.assign(new Error('spawn codex ENOENT'), { code: 'ENOENT' }) }));
+    await expect(checkCodexAuth()).resolves.toMatchObject({ state: 'missing', message: expect.stringContaining('CODEX_EXECUTABLE') });
+  });
+
+  it('uses the configured Codex, then CODEX_EXECUTABLE, then codex on PATH', () => {
+    expect(resolveCodexExecutable({ executable: '/opt/codex' })).toBe('/opt/codex');
+    process.env.CODEX_EXECUTABLE = '/env/codex';
+    expect(resolveCodexExecutable()).toBe('/env/codex');
+    delete process.env.CODEX_EXECUTABLE;
+    expect(resolveCodexExecutable()).toBe('codex');
+  });
+
+  it('signs in with Codex own `codex login` only when signed out, and checks it worked', async () => {
+    const calls: string[][] = [];
+    __setCodexCommandRunner(async (_exe, args) => {
+      calls.push([...args]);
+      if (args[0] === 'login' && args.length === 1) return run('Successfully logged in\n');
+      return calls.length > 2 ? run('Logged in using ChatGPT\n') : run('', 1, 'Not logged in\n');
+    });
+    await expect(codexLogin(ctx())).resolves.toEqual({ accountId: 'ChatGPT' });
+    expect(calls).toEqual([['login', 'status'], ['login'], ['login', 'status']]);
+  });
+
+  it('in the desktop, hands the sign-in page to the desktop to open', async () => {
+    const urls: string[] = [];
+    let signedIn = false;
+    __setCodexCommandRunner(async (_exe, args, opts) => {
+      if (args.length === 1) {
+        opts?.onOutput?.('Starting local login server on http://localhost:1455.\nIf your browser did not open, navigate to this URL to authenticate:\n\nhttps://auth.openai.com/oauth/authorize?client_id=app_x&state=s\n');
+        signedIn = true;
+        return run('');
+      }
+      return signedIn ? run('Logged in using ChatGPT\n') : run('', 1, 'Not logged in\n');
+    });
+    await codexLogin(ctx({ noOpen: true, onAuthUrl: (url) => urls.push(url) }));
+    expect(urls).toEqual(['https://auth.openai.com/oauth/authorize?client_id=app_x&state=s']);
+  });
+
+  it('signs out with `codex logout`', async () => {
+    const calls: string[][] = [];
+    __setCodexCommandRunner(async (_exe, args) => {
+      calls.push([...args]);
+      return args[0] === 'logout' ? run('Successfully logged out\n') : run('Logged in using ChatGPT\n');
+    });
+    await expect(codexLogout(ctx())).resolves.toBe(true);
+    expect(calls).toEqual([['login', 'status'], ['logout']]);
+  });
+
+  it('reports the state for status surfaces', async () => {
+    __setCodexCommandRunner(async () => run('', 1, 'Not logged in\n'));
+    await expect(codexStatus(ctx())).resolves.toMatchObject({ authState: 'signed-out', accountId: null });
+  });
+});

package/src/login.ts

@@ -0,0 +1,167 @@
+import { MoxxyError } from '@moxxy/sdk';
+import { spawnExecutableTarget } from '@moxxy/sdk/server';
+import type { AgentSignIn } from '@moxxy/agent-connection-kit';
+import type { ProviderAuthContext, ProviderOAuthResult, ProviderOAuthStatus } from '@moxxy/sdk';
+import {
+  CODEX_AGENT_PROVIDER_ID,
+  CODEX_EXECUTABLE_ENV,
+  CODEX_LOGIN_ARGS,
+  CODEX_LOGIN_STATUS_ARGS,
+  CODEX_LOGOUT_ARGS,
+} from './constants.js';
+import { codexTarget } from './executable.js';
+
+export type CodexAuthState = 'signed-in' | 'signed-out' | 'missing' | 'error';
+
+export interface CodexAuthStatus {
+  readonly state: CodexAuthState;
+  readonly executable: string;
+  /** How Codex is signed in (`ChatGPT`, `an API key`); Codex does not print the account. */
+  readonly accountId?: string;
+  readonly message: string;
+}
+
+export interface CodexCommandResult {
+  readonly code: number;
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly error?: NodeJS.ErrnoException;
+}
+
+interface CommandOptions {
+  /** Hand Codex the terminal (a CLI login). */
+  readonly inherit?: boolean;
+  /** See Codex's output as it comes (a GUI login, to find the sign-in page). */
+  readonly onOutput?: (chunk: string) => void;
+}
+
+type CommandRunner = (executable: string, args: readonly string[], options?: CommandOptions) => Promise<CodexCommandResult>;
+
+const SIGN_IN_PAGE = /https:\/\/auth\.openai\.com\/\S+/;
+
+let runCommandImpl: CommandRunner = runCommand;
+/** Test seam. */
+export function __setCodexCommandRunner(runner: CommandRunner): void {
+  runCommandImpl = runner;
+}
+
+export function resolveCodexExecutable(config: Readonly<Record<string, unknown>> = {}): string {
+  const configured = config.executable;
+  if (typeof configured === 'string' && configured.trim()) return configured;
+  return process.env[CODEX_EXECUTABLE_ENV]?.trim() || 'codex';
+}
+
+/** Read the sign-in from the person's own Codex (`codex login status`); Moxxy never touches its tokens. */
+export async function checkCodexAuth(executable = resolveCodexExecutable()): Promise<CodexAuthStatus> {
+  const result = await runCommandImpl(executable, CODEX_LOGIN_STATUS_ARGS);
+  if (result.error?.code === 'ENOENT') {
+    return { state: 'missing', executable, message: `Codex CLI not found: ${executable}. Install Codex or set ${CODEX_EXECUTABLE_ENV}.` };
+  }
+  if (result.error) return { state: 'error', executable, message: `Could not run Codex: ${result.error.message}` };
+  const text = `${result.stdout}\n${result.stderr}`.trim();
+  if (/not logged in/i.test(text)) {
+    return { state: 'signed-out', executable, message: `Codex is installed but signed out. Run \`moxxy login ${CODEX_AGENT_PROVIDER_ID}\`.` };
+  }
+  const using = /logged in using (.+)/i.exec(text);
+  if (using?.[1] && result.code === 0) {
+    const accountId = using[1].trim();
+    return { state: 'signed-in', executable, accountId, message: `Codex is signed in using ${accountId}.` };
+  }
+  return { state: 'error', executable, message: `Codex login status failed${text ? `: ${text}` : ` with exit code ${result.code}`}.` };
+}
+
+/** Who Codex is signed in as, for the connection's row. */
+export async function codexSignIn(executable = resolveCodexExecutable()): Promise<AgentSignIn> {
+  const status = await checkCodexAuth(executable);
+  return { signedIn: status.state === 'signed-in', ...(status.accountId ? { account: status.accountId } : {}) };
+}
+
+export async function codexLogin(ctx: ProviderAuthContext): Promise<ProviderOAuthResult> {
+  const executable = resolveCodexExecutable(ctx.providerConfig);
+  let status = await checkCodexAuth(executable);
+  if (status.state === 'signed-in') return { accountId: status.accountId ?? null };
+  if (status.state !== 'signed-out') throw authError(status);
+
+  // A GUI host (the desktop) has no terminal: show Codex's output and let the host open the sign-in page.
+  let opened = false;
+  const login = await runCommandImpl(
+    executable,
+    CODEX_LOGIN_ARGS,
+    ctx.noOpen
+      ? {
+          onOutput: (chunk) => {
+            ctx.write(chunk);
+            const page = SIGN_IN_PAGE.exec(chunk);
+            if (page && !opened) {
+              opened = true;
+              ctx.onAuthUrl?.(page[0]);
+            }
+          },
+        }
+      : { inherit: true },
+  );
+  if (login.error) throw authError({ state: login.error.code === 'ENOENT' ? 'missing' : 'error', executable, message: login.error.message });
+  if (login.code !== 0) {
+    throw new MoxxyError({
+      code: 'AUTH_DENIED',
+      message: `Codex login failed${login.stderr ? `: ${login.stderr.trim()}` : ` with exit code ${login.code}`}.`,
+      hint: 'Run `codex login` directly for more detail, then retry.',
+      context: { provider: CODEX_AGENT_PROVIDER_ID },
+    });
+  }
+  status = await checkCodexAuth(executable);
+  if (status.state !== 'signed-in') throw authError(status);
+  return { accountId: status.accountId ?? null };
+}
+
+export async function codexLogout(ctx: ProviderAuthContext): Promise<boolean> {
+  const executable = resolveCodexExecutable(ctx.providerConfig);
+  const before = await checkCodexAuth(executable);
+  if (before.state !== 'signed-in') return false;
+  const result = await runCommandImpl(executable, CODEX_LOGOUT_ARGS, { inherit: true });
+  if (result.error || result.code !== 0) {
+    throw new MoxxyError({ code: 'AUTH_INVALID', message: `Codex logout failed${result.stderr ? `: ${result.stderr}` : '.'}` });
+  }
+  return true;
+}
+
+export async function codexStatus(ctx: ProviderAuthContext): Promise<ProviderOAuthStatus | null> {
+  const status = await checkCodexAuth(resolveCodexExecutable(ctx.providerConfig));
+  return { accountId: status.accountId ?? null, authState: status.state, message: status.message };
+}
+
+export function authError(status: CodexAuthStatus): MoxxyError {
+  return new MoxxyError({
+    code: status.state === 'signed-out' ? 'AUTH_NO_CREDENTIALS' : 'AUTH_INVALID',
+    message: status.message,
+    hint: status.state === 'signed-out' ? `Run \`moxxy login ${CODEX_AGENT_PROVIDER_ID}\`.` : undefined,
+    context: { provider: CODEX_AGENT_PROVIDER_ID, executable: status.executable, state: status.state },
+  });
+}
+
+async function runCommand(executable: string, args: readonly string[], options: CommandOptions = {}): Promise<CodexCommandResult> {
+  let target;
+  try {
+    target = codexTarget(executable);
+  } catch (err) {
+    const error = Object.assign(err instanceof Error ? err : new Error(String(err)), { code: 'ENOENT' }) as NodeJS.ErrnoException;
+    return { code: 1, stdout: '', stderr: '', error };
+  }
+  return await new Promise((resolve) => {
+    const child = spawnExecutableTarget(target, [...args], options.inherit ? { stdio: 'inherit' } : { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.setEncoding('utf8');
+    child.stderr?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk: string) => {
+      stdout += chunk;
+      options.onOutput?.(chunk);
+    });
+    child.stderr?.on('data', (chunk: string) => {
+      stderr += chunk;
+      options.onOutput?.(chunk);
+    });
+    child.once('error', (error: NodeJS.ErrnoException) => resolve({ code: 1, stdout, stderr, error }));
+    child.once('close', (code) => resolve({ code: code ?? 1, stdout, stderr }));
+  });
+}

package/src/offered-models.test.ts

@@ -0,0 +1,87 @@
+/**
+ * The models the person's Codex offers their account, as its own picker lists
+ * them: a short-lived `codex app-server` is asked `model/list`, page by page,
+ * and closed again. The pages are a recorded Codex 0.163.0 answer; Codex is
+ * the external boundary.
+ */
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { FakeCodex } from './fake-codex.testkit.js';
+import { codexOfferedModels } from './offered-models.js';
+
+const recorded = JSON.parse(readFileSync(new URL('./fixtures/codex-model-list-0.163.0.json', import.meta.url), 'utf8')) as {
+  pages: ReadonlyArray<{ data: ReadonlyArray<Record<string, unknown>>; nextCursor?: string | null }>;
+};
+const nothing = async () => undefined;
+
+describe("the models the person's Codex offers", () => {
+  it('lists every page, in Codex order, and leaves no Codex running', async () => {
+    const codex = new FakeCodex(nothing, { modelPages: recorded.pages });
+
+    const models = await codexOfferedModels('/work/app', codex.start);
+
+    expect(models.map((m) => m.id)).toEqual([
+      'gpt-6.1-sol',
+      'gpt-6-astra',
+      'gpt-6-sol',
+      'gpt-6-luna',
+      'gpt-5.6-sol',
+      'gpt-5.6-terra',
+      'gpt-5.6-luna',
+    ]);
+    expect(codex.last.sent('model/list')).toEqual([{}, { cursor: '4' }]);
+    expect(codex.last.closed).toBe(true);
+  });
+
+  it('describes each model as an agent model: tools, images, reasoning, and fast where Codex offers it', async () => {
+    const codex = new FakeCodex(nothing, { modelPages: recorded.pages });
+
+    const [sol] = await codexOfferedModels('/work/app', codex.start);
+
+    expect(sol).toMatchObject({ id: 'gpt-6.1-sol', supportsTools: true, supportsImages: true, supportsReasoning: true, supportsFast: true });
+    expect(sol?.contextWindow).toBe(500_000);
+  });
+
+  it('starts the GPT-6 models at the 272k window Codex runs them with by default', async () => {
+    const codex = new FakeCodex(nothing, { modelPages: recorded.pages });
+
+    const offered = await codexOfferedModels('/work/app', codex.start);
+
+    const gpt6 = offered.filter((model) => model.id.startsWith('gpt-6-'));
+    expect(gpt6.length).toBeGreaterThan(0);
+    expect(gpt6.map((model) => model.contextWindow)).toEqual(gpt6.map(() => 272_000));
+  });
+
+  it('gives a model Moxxy does not know a 400k window', async () => {
+    const [first] = recorded.pages;
+    if (!first) throw new Error('recording has no pages');
+    const codex = new FakeCodex(nothing, { modelPages: [{ data: [{ ...first.data[0], id: 'gpt-7-sol', model: 'gpt-7-sol' }], nextCursor: null }] });
+
+    const [next] = await codexOfferedModels('/work/app', codex.start);
+
+    expect(next).toMatchObject({ id: 'gpt-7-sol', contextWindow: 400_000, maxOutputTokens: 128_000, supportsTools: true });
+  });
+
+  it('leaves out models Codex hides from its picker', async () => {
+    const [first] = recorded.pages;
+    if (!first) throw new Error('recording has no pages');
+    const hidden = { ...first.data[0], id: 'gpt-internal', model: 'gpt-internal', hidden: true };
+    const codex = new FakeCodex(nothing, { modelPages: [{ data: [hidden, first.data[1]], nextCursor: null }] });
+
+    expect((await codexOfferedModels('/work/app', codex.start)).map((m) => m.id)).toEqual(['gpt-6-astra']);
+  });
+
+  it('fails when Codex cannot be started, so the last list stays', async () => {
+    const missing = async () => Promise.reject(new Error('spawn codex ENOENT'));
+
+    await expect(codexOfferedModels('/work/app', missing)).rejects.toThrow(/ENOENT/);
+  });
+
+  it('gives up on a Codex that does not answer', async () => {
+    const codex = new FakeCodex(nothing, { modelPages: recorded.pages });
+    codex.silent = true;
+
+    await expect(codexOfferedModels('/work/app', codex.start, { timeoutMs: 50 })).rejects.toThrow(/did not answer/);
+    expect(codex.last.closed).toBe(true);
+  });
+});

package/src/offered-models.ts

@@ -0,0 +1,65 @@
+/**
+ * The models the person's Codex offers their account, as its own picker lists
+ * them: a short-lived `codex app-server` answers `model/list`, page by page,
+ * and is closed. Codex caches the list for a few minutes; the hourly check
+ * picks up a change after that.
+ */
+import type { ModelDescriptor } from '@moxxy/sdk';
+import { JsonRpcLineClient } from '@moxxy/agent-connection-kit';
+import { codexAgentModels } from './agent-provider.js';
+import type { StartCodexAppServer } from './codex-session.js';
+import type { CodexModelList } from './protocol.js';
+
+/** Codex answers in well under a second; one stuck on startup is not waited on longer. */
+const OFFERED_MODELS_TIMEOUT_MS = 15_000;
+/** `model/list` says nothing of the window; a model Moxxy does not know gets this one. */
+const UNKNOWN_MODEL: Omit<ModelDescriptor, 'id'> = {
+  contextWindow: 400_000,
+  maxOutputTokens: 128_000,
+  supportsTools: true,
+  supportsStreaming: true,
+  supportsImages: true,
+  supportsDocuments: false,
+  supportsAudio: false,
+  supportsReasoning: true,
+  hostedTools: ['web_search'],
+};
+
+export async function codexOfferedModels(
+  cwd: string,
+  start: StartCodexAppServer,
+  opts: { readonly timeoutMs?: number } = {},
+): Promise<ReadonlyArray<ModelDescriptor>> {
+  let connection: Awaited<ReturnType<StartCodexAppServer>> | undefined;
+  let client: JsonRpcLineClient | undefined;
+  const timer = setTimeout(() => client?.close(new Error('Codex did not answer in time.')), opts.timeoutMs ?? OFFERED_MODELS_TIMEOUT_MS);
+  try {
+    connection = await start({ cwd });
+    client = new JsonRpcLineClient({ readable: connection.readable, writable: connection.writable });
+    await client.request('initialize', { clientInfo: { name: 'moxxy', title: 'Moxxy', version: '1' }, capabilities: { experimentalApi: true } });
+    client.notify('initialized');
+    const models: ModelDescriptor[] = [];
+    let cursor: string | null | undefined;
+    do {
+      const page: CodexModelList = await client.request<CodexModelList>('model/list', cursor ? { cursor } : {});
+      for (const model of page.data) if (!model.hidden) models.push(describe(model));
+      cursor = page.nextCursor;
+    } while (cursor);
+    return models;
+  } finally {
+    clearTimeout(timer);
+    client?.close();
+    connection?.close();
+  }
+}
+
+function describe(model: CodexModelList['data'][number]): ModelDescriptor {
+  const known = codexAgentModels.find((descriptor) => descriptor.id === model.id) ?? UNKNOWN_MODEL;
+  return {
+    ...known,
+    id: model.id,
+    supportsImages: model.inputModalities?.includes('image') ?? known.supportsImages ?? false,
+    supportsReasoning: (model.supportedReasoningEfforts?.length ?? 0) > 0,
+    supportsFast: model.additionalSpeedTiers?.includes('fast') ?? false,
+  };
+}

package/src/own-settings.test.ts

@@ -0,0 +1,45 @@
+/**
+ * How the person's own Codex runs, read as a conversation opens so its
+ * auto-approve is the truth before the first message: a short-lived
+ * `codex app-server` is asked for the folder's config and closed again,
+ * without starting a thread. Codex is the external boundary.
+ */
+import { describe, expect, it } from 'vitest';
+import { FakeCodex } from './fake-codex.testkit.js';
+import { codexOwnAutoApprove } from './own-settings.js';
+
+const nothing = async () => undefined;
+
+describe("the auto-approve of the person's own Codex", () => {
+  it('is on when their config runs Codex with no approvals and full access, and leaves no Codex running', async () => {
+    const codex = new FakeCodex(nothing);
+
+    expect(await codexOwnAutoApprove('/work/app', codex.start)).toBe(true);
+    expect(codex.last.cwd).toBe('/work/app');
+    expect(codex.last.sent('config/read')).toEqual([{ cwd: '/work/app' }]);
+    expect(codex.last.sent('thread/start')).toEqual([]);
+    expect(codex.last.closed).toBe(true);
+  });
+
+  it('is off when their config asks, or keeps Codex in a sandbox', async () => {
+    const asking = new FakeCodex(nothing, { approvalPolicy: 'on-request' });
+    const sandboxed = new FakeCodex(nothing, { sandbox: { type: 'readOnly', networkAccess: false } });
+
+    expect(await codexOwnAutoApprove('/work/app', asking.start)).toBe(false);
+    expect(await codexOwnAutoApprove('/work/app', sandboxed.start)).toBe(false);
+  });
+
+  it('is unknown when Codex cannot be started', async () => {
+    const missing = async () => Promise.reject(new Error('spawn codex ENOENT'));
+
+    expect(await codexOwnAutoApprove('/work/app', missing)).toBeUndefined();
+  });
+
+  it('is unknown, and closes Codex, when it does not answer in time', async () => {
+    const codex = new FakeCodex(nothing);
+    codex.silent = true;
+
+    expect(await codexOwnAutoApprove('/work/app', codex.start, { timeoutMs: 50 })).toBeUndefined();
+    expect(codex.last.closed).toBe(true);
+  });
+});

package/src/own-settings.ts

@@ -0,0 +1,39 @@
+/**
+ * How the person's own Codex runs, read without starting a thread: a
+ * short-lived `codex app-server` answers `config/read` for the folder (the
+ * effective config, profiles and project config included) and is closed.
+ */
+import { JsonRpcLineClient } from '@moxxy/agent-connection-kit';
+import type { StartCodexAppServer } from './codex-session.js';
+import type { CodexConfigRead } from './protocol.js';
+
+/** Codex answers in well under a second; one stuck on startup is not waited on longer. */
+const OWN_SETTINGS_TIMEOUT_MS = 15_000;
+
+/**
+ * Whether the person's own Codex runs in `cwd` with no approvals and full
+ * access, as Moxxy's auto-approve does; `undefined` when Codex cannot say.
+ */
+export async function codexOwnAutoApprove(
+  cwd: string,
+  start: StartCodexAppServer,
+  opts: { readonly timeoutMs?: number } = {},
+): Promise<boolean | undefined> {
+  let connection: Awaited<ReturnType<StartCodexAppServer>> | undefined;
+  let client: JsonRpcLineClient | undefined;
+  const timer = setTimeout(() => client?.close(new Error('Codex did not answer in time.')), opts.timeoutMs ?? OWN_SETTINGS_TIMEOUT_MS);
+  try {
+    connection = await start({ cwd });
+    client = new JsonRpcLineClient({ readable: connection.readable, writable: connection.writable });
+    await client.request('initialize', { clientInfo: { name: 'moxxy', title: 'Moxxy', version: '1' }, capabilities: { experimentalApi: true } });
+    client.notify('initialized');
+    const { config } = await client.request<CodexConfigRead>('config/read', { cwd });
+    return config.approval_policy === 'never' && config.sandbox_mode === 'danger-full-access';
+  } catch {
+    return undefined;
+  } finally {
+    clearTimeout(timer);
+    client?.close();
+    connection?.close();
+  }
+}