@stage-labs/metro 0.1.0-beta.28 → 0.1.0-beta.280

package/runtime/node_modules/@metro-labs/daemon/src/gateway/bedrock.ts

@@ -0,0 +1,233 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from '@metro-labs/core/log';
+import { EventStreamDecoder, type EventStreamMessage } from './eventstream.js';
+import { errorFrame, GatewayError, providerStatus, relayFrames, sendError, upstreamMessage, type Watch } from './forward.js';
+import type { Connection } from './model-config.js';
+import { estimateTokens } from './subscription.js';
+import { UsageScanner } from './usage.js';
+
+const ANTHROPIC_VERSION = 'bedrock-2023-05-31';
+const EXTRA_INPUT_RE = /^([A-Za-z0-9_]+)(?:\.[^:]*)?: Extra inputs are not permitted/;
+const MAX_REPAIRS = 4;
+
+export interface Adaptations {
+  fields: Set<string>;
+  dropBetas: boolean;
+}
+
+export const freshAdaptations = (): Adaptations => ({ fields: new Set(), dropBetas: false });
+
+export interface BedrockUpstream {
+  settings: Connection;
+  base: string;
+  learned: Adaptations;
+  watch: Watch;
+}
+
+interface Rewritten {
+  modelId: string;
+  stream: boolean;
+  body: Record<string, unknown>;
+  betas: string[];
+}
+
+interface Attempt {
+  body: Record<string, unknown>;
+  betas: string[];
+}
+
+const PREFIXES: [RegExp, string][] = [
+  [/^us-gov-/, 'us-gov'],
+  [/^us-/, 'us'],
+  [/^eu-/, 'eu'],
+  [/^ap-/, 'apac'],
+];
+
+function regionPrefix(region: string): string {
+  for (const [pattern, prefix] of PREFIXES) if (pattern.test(region)) return prefix;
+  return 'global';
+}
+
+function bedrockModelId(requested: string, region: string): string {
+  if (requested.includes('anthropic.')) return requested;
+  return `${regionPrefix(region)}.anthropic.${requested}`;
+}
+
+export const bedrockBase = (region: string): string => `https://bedrock-runtime.${region}.amazonaws.com`;
+
+function splitBetas(header: string | string[] | undefined): string[] {
+  const raw = Array.isArray(header) ? header.join(',') : (header ?? '');
+  return raw
+    .split(',')
+    .map((b) => b.trim())
+    .filter((b) => b !== '');
+}
+
+function rewriteForBedrock(
+  body: Record<string, unknown>,
+  model: string,
+  betaHeader: string | string[] | undefined,
+  region: string,
+): Rewritten {
+  const betas = splitBetas(betaHeader);
+  const out: Record<string, unknown> = {
+    ...Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'model' && key !== 'stream')),
+    anthropic_version: ANTHROPIC_VERSION,
+  };
+  if (betas.length > 0) out.anthropic_beta = betas;
+  return { modelId: bedrockModelId(model, region), stream: body.stream === true, body: out, betas };
+}
+
+function errorKind(status: number, errorType: string | null): string {
+  if (status === 429 || errorType === 'ThrottlingException') return 'rate_limit_error';
+  if (status === 400) return 'invalid_request_error';
+  if (status === 401 || status === 403) return 'permission_error';
+  if (status === 404) return 'not_found_error';
+  if (status === 503) return 'overloaded_error';
+  return 'api_error';
+}
+
+const invokeUrl = (up: BedrockUpstream, modelId: string, action: string): string =>
+  `${up.base}/model/${encodeURIComponent(modelId)}/${action}`;
+
+function callBedrock(up: BedrockUpstream, url: string, body: unknown, accept: string): Promise<Response> {
+  return fetch(url, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${up.settings.apiKey}`,
+      'content-type': 'application/json',
+      accept,
+    },
+    body: JSON.stringify(body),
+    signal: up.watch.signal,
+  });
+}
+
+const without = (body: Record<string, unknown>, keys: Set<string>): Record<string, unknown> =>
+  Object.fromEntries(Object.entries(body).filter(([key]) => !keys.has(key)));
+
+function applyLearned(req: Rewritten, learned: Adaptations): Attempt {
+  const dropped = new Set(learned.fields);
+  if (learned.dropBetas) dropped.add('anthropic_beta');
+  return { body: without(req.body, dropped), betas: learned.dropBetas ? [] : req.betas };
+}
+
+function repair(attempt: Attempt, learned: Adaptations, message: string): Attempt | null {
+  const named = EXTRA_INPUT_RE.exec(message)?.[1];
+  if (named !== undefined && named in attempt.body) {
+    learned.fields.add(named);
+    log.warn({ field: named }, 'gateway: Bedrock refused an extra input; dropping it from every request');
+    return { body: without(attempt.body, new Set([named])), betas: attempt.betas };
+  }
+  if (attempt.betas.length > 0) {
+    learned.dropBetas = true;
+    log.warn({ betas: attempt.betas }, 'gateway: retrying without anthropic_beta');
+    return { body: without(attempt.body, new Set(['anthropic_beta'])), betas: [] };
+  }
+  return null;
+}
+
+async function withRepairs(up: BedrockUpstream, req: Rewritten, send: (attempt: Attempt) => Promise<Response>): Promise<Response> {
+  let attempt = applyLearned(req, up.learned);
+  for (let repairs = 0; ; repairs += 1) {
+    const res = await send(attempt);
+    if (res.status !== 400 || repairs >= MAX_REPAIRS) return res;
+    const text = await res.text();
+    const next = repair(attempt, up.learned, upstreamMessage(text, 'Bedrock returned no body'));
+    if (next === null) return new Response(text, { status: 400, headers: res.headers });
+    attempt = next;
+  }
+}
+
+function invoke(up: BedrockUpstream, req: Rewritten): Promise<Response> {
+  const action = req.stream ? 'invoke-with-response-stream' : 'invoke';
+  const accept = req.stream ? 'application/vnd.amazon.eventstream' : 'application/json';
+  const url = invokeUrl(up, req.modelId, action);
+  return withRepairs(up, req, (attempt) => callBedrock(up, url, attempt.body, accept));
+}
+
+function eventTypeOf(event: string): string {
+  try {
+    const parsed = JSON.parse(event) as { type?: unknown };
+    return typeof parsed.type === 'string' ? parsed.type : 'message';
+  } catch {
+    return 'message';
+  }
+}
+
+function eventFrame(message: EventStreamMessage): string {
+  if (message.headers[':message-type'] === 'event') {
+    const parsed = JSON.parse(message.payload.toString('utf8')) as { bytes?: unknown };
+    if (typeof parsed.bytes !== 'string') return '';
+    const event = Buffer.from(parsed.bytes, 'base64').toString('utf8');
+    return `event: ${eventTypeOf(event)}\ndata: ${event}\n\n`;
+  }
+  const errorType = message.headers[':exception-type'] ?? message.headers[':error-code'] ?? null;
+  return errorFrame(errorKind(500, errorType), upstreamMessage(message.payload.toString('utf8'), 'Bedrock stream error'));
+}
+
+function relayStream(upstream: Response, res: ServerResponse, watch: Watch, key: string): Promise<void> {
+  const decoder = new EventStreamDecoder();
+  return relayFrames(upstream, res, watch, key, {
+    push: (chunk, emit) => {
+      for (const message of decoder.push(Buffer.from(chunk))) emit(eventFrame(message));
+    },
+    close: () => '',
+    idle: (message) => errorFrame('api_error', message),
+  });
+}
+
+async function relayFailure(upstream: Response, res: ServerResponse): Promise<void> {
+  const text = await upstream.text();
+  sendError(res, providerStatus(upstream.status), errorKind(upstream.status, upstream.headers.get('x-amzn-errortype')), upstreamMessage(text, 'Bedrock returned no body'));
+}
+
+export async function bedrockMessages(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  model: string,
+  up: BedrockUpstream,
+): Promise<void> {
+  const rewritten = rewriteForBedrock(body, model, req.headers['anthropic-beta'], up.settings.region);
+  const upstream = await invoke(up, rewritten);
+  if (!upstream.ok) {
+    await relayFailure(upstream, res);
+    return;
+  }
+  if (rewritten.stream) {
+    await relayStream(upstream, res, up.watch, up.settings.id);
+    return;
+  }
+  const text = await upstream.text();
+  const scanner = new UsageScanner(up.settings.id);
+  scanner.feed(text);
+  scanner.done();
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(text);
+}
+
+export async function bedrockCount(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  model: string,
+  up: BedrockUpstream,
+): Promise<void> {
+  const rewritten = rewriteForBedrock(body, model, req.headers['anthropic-beta'], up.settings.region);
+  const url = invokeUrl(up, rewritten.modelId, 'count-tokens');
+  const upstream = await withRepairs(up, rewritten, (attempt) => callBedrock(up, url, { input: { invokeModel: { body: JSON.stringify(attempt.body) } } }, 'application/json'));
+  const text = await upstream.text();
+  let counted: number | null = null;
+  if (upstream.ok) {
+    const parsed = JSON.parse(text) as { inputTokens?: unknown };
+    if (typeof parsed.inputTokens === 'number') counted = parsed.inputTokens;
+  }
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ input_tokens: counted ?? estimateTokens(rewritten.body) }));
+}
+
+export function assertBedrockReady(settings: Connection): void {
+  if (settings.apiKey === '' || settings.region === '')
+    throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key and a region: add them on the Model page.');
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/claude-logins.ts

@@ -0,0 +1,168 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ID_RE, newId } from '@metro-labs/core/ids';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import { ApiError } from '@metro-labs/http/api-error';
+import { readFileSync } from '../agent-user/agent-fs.js';
+import { removeHome } from '../agent-user/home-fs.js';
+import { claudeHome } from '../agent-user/user.js';
+import { claudeAccountIn, type ClaudeAccount, type LoginTarget } from '../claude/login.js';
+import { readClaudeUsage } from '../claude/usage-probe.js';
+import { currentOf, reach, refreshed, type TokenSource, type TokenState } from './subscription.js';
+import { forgetReported } from './usage.js';
+import { addConnection, connectionOf, readModelConfig, setClaudeLogin, writeModelConfig, type ModelConfig } from './model-config.js';
+
+const CREDENTIALS = '.credentials.json';
+const RENEW_MARGIN_MS = 60_000;
+const NEW = 'new';
+const MISSING = 'this Claude login is no longer on the box: sign in again on the Model page';
+
+export interface ClaudeLoginDeps {
+  root?: string;
+  probe?: (env: Record<string, string>) => Promise<unknown>;
+  account?: (env: Record<string, string>) => ClaudeAccount;
+  read?: () => ModelConfig;
+  write?: (cfg: ModelConfig) => void;
+}
+
+interface ClaudeTokens {
+  accessToken: string;
+  expiresAt: number | null;
+  savedAt: string;
+}
+
+const state: TokenState<ClaudeTokens> = new Map();
+const seen = new Map<string, ClaudeTokens>();
+
+const claudeLoginsRoot = (): string => join(claudeHome() ?? homedir(), '.metro', 'claude-logins');
+
+const rootOf = (deps: ClaudeLoginDeps): string => deps.root ?? claudeLoginsRoot();
+
+function claudeLoginEnv(login: string, deps: ClaudeLoginDeps = {}): Record<string, string> {
+  if (!ID_RE.test(login)) throw new Error('not a Claude login id');
+  return { CLAUDE_CONFIG_DIR: join(rootOf(deps), login) };
+}
+
+export const probeClaudeLogin = (login: string, deps: ClaudeLoginDeps = {}): Promise<unknown> =>
+  (deps.probe ?? ((env) => readClaudeUsage({ env })))(claudeLoginEnv(login, deps));
+
+const stale = (tokens: ClaudeTokens, margin = RENEW_MARGIN_MS): boolean => tokens.expiresAt !== null && tokens.expiresAt - margin <= Date.now();
+
+function onDisk(login: string, deps: ClaudeLoginDeps): ClaudeTokens | null {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(join(claudeLoginEnv(login, deps).CLAUDE_CONFIG_DIR ?? '', CREDENTIALS), 'utf8'));
+  } catch {
+    return null;
+  }
+  const oauth = isRecord(raw) && isRecord(raw.claudeAiOauth) ? raw.claudeAiOauth : {};
+  const accessToken = typeof oauth.accessToken === 'string' ? oauth.accessToken : '';
+  const expiresAt = typeof oauth.expiresAt === 'number' && Number.isFinite(oauth.expiresAt) ? oauth.expiresAt : null;
+  return accessToken === '' ? null : { accessToken, expiresAt, savedAt: new Date(expiresAt ?? 0).toISOString() };
+}
+
+function remembered(login: string, tokens: ClaudeTokens | null): ClaudeTokens | null {
+  if (tokens === null) seen.delete(login);
+  else seen.set(login, tokens);
+  return tokens;
+}
+
+function known(login: string, deps: ClaudeLoginDeps): ClaudeTokens | null {
+  const kept = seen.get(login);
+  if (kept !== undefined && !stale(kept)) return kept;
+  const read = onDisk(login, deps);
+  return read === null && kept !== undefined ? kept : remembered(login, read);
+}
+
+function sourceFor(login: string, deps: ClaudeLoginDeps): TokenSource<ClaudeTokens> {
+  return {
+    label: 'Claude',
+    stale: (tokens) => stale(tokens),
+    refresh: async () => {
+      try {
+        await probeClaudeLogin(login, deps);
+      } catch (err) {
+        log.warn({ err: errMsg(err) }, 'claude-logins: Claude Code stumbled while renewing a login, so its folder is read as it is');
+      }
+      const fresh = onDisk(login, deps);
+      if (fresh === null || stale(fresh, 0)) throw new Error('Claude Code could not renew this login');
+      return fresh;
+    },
+    save: (id, tokens) => {
+      remembered(id, tokens);
+    },
+  };
+}
+
+function again(login: string, failed: ClaudeTokens, deps: ClaudeLoginDeps, source: TokenSource<ClaudeTokens>): Promise<ClaudeTokens> {
+  const disk = onDisk(login, deps);
+  if (disk !== null && disk.accessToken !== failed.accessToken && !stale(disk)) return Promise.resolve(remembered(login, disk) ?? disk);
+  return refreshed(state, login, failed, source);
+}
+
+export function withClaudeLogin(login: string, deps: ClaudeLoginDeps, send: (token: string) => Promise<Response>): Promise<Response> {
+  const source = sourceFor(login, deps);
+  return reach(
+    () => currentOf(state, login, known(login, deps), source, MISSING),
+    (failed) => again(login, failed, deps, source),
+    (tokens) => send(tokens.accessToken),
+  );
+}
+
+function dropClaudeLogin(login: string, deps: ClaudeLoginDeps): void {
+  seen.delete(login);
+  state.delete(login);
+  try {
+    removeHome(claudeLoginEnv(login, deps).CLAUDE_CONFIG_DIR ?? '', true);
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'claude-logins: could not remove a Claude login that is no longer used');
+  }
+}
+
+export function dropUnusedClaudeLogins(before: ModelConfig, after: ModelConfig, deps: ClaudeLoginDeps = {}): void {
+  const kept = new Set(after.connections.flatMap((c) => (c.claude === null ? [] : [c.claude.id])));
+  for (const c of before.connections) if (c.claude !== null && !kept.has(c.claude.id)) dropClaudeLogin(c.claude.id, deps);
+}
+
+function keep(login: string, connection: string | null, account: ClaudeAccount, deps: ClaudeLoginDeps): string | null {
+  const before = (deps.read ?? readModelConfig)();
+  const cfg = connection === null ? addConnection(before, { provider: 'anthropic' }) : before;
+  const id = connection ?? cfg.connections.at(-1)?.id ?? '';
+  if (connectionOf(cfg, id)?.provider !== 'anthropic') return 'that connection was removed during the sign-in';
+  const next = setClaudeLogin(cfg, id, { id: login, email: account.account, plan: account.plan, savedAt: new Date().toISOString() });
+  (deps.write ?? writeModelConfig)(next);
+  dropUnusedClaudeLogins(before, next, deps);
+  forgetReported(id);
+  log.info({ connection: id, plan: account.plan, added: connection === null }, 'claude-logins: the Claude login was kept for its own connection');
+  return null;
+}
+
+function settle(ok: boolean, login: string, connection: string | null, deps: ClaudeLoginDeps): Promise<string | null> {
+  if (!ok) {
+    dropClaudeLogin(login, deps);
+    return Promise.resolve(null);
+  }
+  let problem: string | null;
+  try {
+    const account = (deps.account ?? claudeAccountIn)(claudeLoginEnv(login, deps));
+    problem = account.signedIn ? keep(login, connection, account, deps) : 'the sign-in finished but Claude Code holds no login; try again';
+  } catch (err) {
+    problem = errMsg(err);
+  }
+  if (problem !== null) dropClaudeLogin(login, deps);
+  return Promise.resolve(problem);
+}
+
+export function claudeLoginTarget(asked: string, deps: ClaudeLoginDeps = {}): LoginTarget {
+  const connection = asked === NEW ? null : asked;
+  if (connection !== null && connectionOf((deps.read ?? readModelConfig)(), connection)?.provider !== 'anthropic')
+    throw new ApiError('no such Anthropic connection', 404);
+  const login = newId();
+  return { key: asked, env: claudeLoginEnv(login, deps), settle: (ok) => settle(ok, login, connection, deps) };
+}
+
+export function forgetClaudeTokens(): void {
+  seen.clear();
+  state.clear();
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/codex-auth.ts

@@ -0,0 +1,219 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { isRecord } from '@metro-labs/core/is-record';
+import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
+import { ticketStore } from '@metro-labs/core/tickets';
+import { agentsDir } from '../agents/files.js';
+import { newPkce } from './pkce.js';
+import { nonEmpty } from './text.js';
+
+export const CODEX_ISSUER = 'https://auth.openai.com';
+export const CODEX_REDIRECT = 'http://127.0.0.1:1455/auth/callback';
+export const OPENAI_API = 'https://api.openai.com/v1';
+export const NEW_CLIENT = 'dynamic_agent_client';
+export const APP_NAME = 'Metro';
+export const PLAN_SCOPE = 'chatgpt.tokens.use.direct';
+export const CODEX_SIGN_IN = 'Codex is not signed in: sign in with ChatGPT on the Model page.';
+const SCOPE = `openid profile email offline_access resource.invoke ${PLAN_SCOPE}`;
+const PROFILE_CLAIM = 'https://api.openai.com/profile';
+const HOST_FILE = 'chatgpt-host.json';
+const HOST_RE = /^urn:uuid:[0-9a-f-]{36}$/;
+const PENDING_TTL_MS = 10 * 60_000;
+const DEFAULT_TTL_MS = 60 * 60_000;
+const RENEW_BEFORE_MS = 2 * 60_000;
+const AGAIN = 'press Continue with ChatGPT again';
+
+export type CodexMethod = 'chatgpt' | 'code';
+
+export interface CodexCredential {
+  email: string | null;
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: number;
+  savedAt: string;
+}
+
+export interface ChatgptTokens extends CodexCredential {
+  method: 'chatgpt';
+  clientId: string;
+  subject: string;
+}
+
+export interface CodeTokens extends CodexCredential {
+  method: 'code';
+  accountId: string;
+  plan: string | null;
+}
+
+export type CodexTokens = ChatgptTokens | CodeTokens;
+
+export class CodexAuthError extends Error {}
+
+interface Pending {
+  verifier: string;
+  nonce: string;
+  clientId: string | null;
+  subject: string | null;
+}
+
+const pending = ticketStore<Pending>(PENDING_TTL_MS, 24);
+
+export function chatgptHostId(dir = agentsDir()): string {
+  const path = join(dir, HOST_FILE);
+  const saved = readJson<unknown>(path, null);
+  if (isRecord(saved) && typeof saved.hostId === 'string' && HOST_RE.test(saved.hostId)) return saved.hostId;
+  const made = `urn:uuid:${randomUUID()}`;
+  writeSecure(path, JSON.stringify({ hostId: made }));
+  return made;
+}
+
+function returning(previous: ChatgptTokens | null): Record<string, string> {
+  if (previous === null) return { client_id: NEW_CLIENT, agent_name_hint: APP_NAME };
+  return { client_id: previous.clientId, ...(previous.email === null ? {} : { login_hint: previous.email }) };
+}
+
+export function beginLogin(previous: ChatgptTokens | null, hostId: string, issuer = CODEX_ISSUER, now = Date.now()): string {
+  const { verifier, challenge } = newPkce();
+  const nonce = randomBytes(32).toString('base64url');
+  const { ticket: state } = pending.mint({ verifier, nonce, clientId: previous?.clientId ?? null, subject: previous?.subject ?? null }, now);
+  const query = new URLSearchParams({
+    ...returning(previous),
+    ext_agent_host_id: hostId,
+    response_type: 'code',
+    redirect_uri: CODEX_REDIRECT,
+    scope: SCOPE,
+    resource: OPENAI_API,
+    state,
+    nonce,
+    code_challenge_method: 'S256',
+    code_challenge: challenge,
+  });
+  return `${issuer}/api/accounts/authorize?${query.toString()}`;
+}
+
+function queryOf(raw: string): URLSearchParams {
+  const text = raw.trim();
+  try {
+    return new URL(text).searchParams;
+  } catch {
+    return new URLSearchParams(text.replace(/^\?/, ''));
+  }
+}
+
+const param = (query: URLSearchParams, name: string): string => query.get(name)?.trim() ?? '';
+
+function assertAllowed(query: URLSearchParams): void {
+  const error = param(query, 'error');
+  if (error === 'access_denied') throw new CodexAuthError('you did not allow Metro to use your ChatGPT plan, so nothing was saved');
+  if (error !== '') throw new CodexAuthError(`ChatGPT stopped the sign-in (${query.get('error_description') ?? error}); ${AGAIN}`);
+}
+
+export function parseCallback(raw: string): { code: string; state: string; clientId: string | null } {
+  const query = queryOf(raw);
+  assertAllowed(query);
+  const code = param(query, 'code');
+  const state = param(query, 'state');
+  if (code === '' || state === '') throw new CodexAuthError('paste the whole address the browser landed on; it carries code= and state=');
+  return { code, state, clientId: nonEmpty(param(query, 'client_id')) };
+}
+
+export function decodeJwtPayload(jwt: string): Record<string, unknown> {
+  const part = jwt.split('.')[1] ?? '';
+  try {
+    const parsed: unknown = JSON.parse(Buffer.from(part, 'base64url').toString('utf8'));
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+export function emailOf(claims: Record<string, unknown>): string | null {
+  const profile = isRecord(claims[PROFILE_CLAIM]) ? claims[PROFILE_CLAIM] : {};
+  return nonEmpty(claims.email) ?? nonEmpty(profile.email);
+}
+
+function identityOf(idToken: unknown, expected: { issuer: string; clientId: string; nonce: string }): { subject: string; email: string | null } {
+  const claims = decodeJwtPayload(typeof idToken === 'string' ? idToken : '');
+  const audience: unknown[] = Array.isArray(claims.aud) ? claims.aud : [claims.aud];
+  const subject = nonEmpty(claims.sub);
+  if (subject === null || claims.iss !== expected.issuer || !audience.includes(expected.clientId) || claims.nonce !== expected.nonce)
+    throw new CodexAuthError(`OpenAI sent back an identity that does not match this sign-in; ${AGAIN}`);
+  return { subject, email: emailOf(claims) };
+}
+
+interface Encoded {
+  type: string;
+  body: string;
+}
+
+export const asForm = (fields: Record<string, string>): Encoded => ({ type: 'application/x-www-form-urlencoded', body: new URLSearchParams(fields).toString() });
+
+export const asJson = (fields: Record<string, string>): Encoded => ({ type: 'application/json', body: JSON.stringify(fields) });
+
+export async function tokenCall(url: string, sent: Encoded, fetchImpl: typeof fetch): Promise<Record<string, unknown>> {
+  const res = await fetchImpl(url, { method: 'POST', headers: { 'content-type': sent.type, accept: 'application/json' }, body: sent.body });
+  const raw = await res.text();
+  let parsed: unknown = null;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    parsed = null;
+  }
+  const body = isRecord(parsed) ? parsed : {};
+  if (!res.ok) throw new CodexAuthError(`OpenAI refused the token request (${String(res.status)}): ${nonEmpty(body.error_description) ?? nonEmpty(body.error) ?? raw.slice(0, 300)}`);
+  return body;
+}
+
+export function grantOf(body: Record<string, unknown>, keptRefresh: string, now: number): Omit<CodexCredential, 'email'> {
+  const accessToken = nonEmpty(body.access_token) ?? '';
+  const refreshToken = nonEmpty(body.refresh_token) ?? keptRefresh;
+  if (accessToken === '' || refreshToken === '') throw new CodexAuthError('OpenAI returned no usable tokens; sign in again');
+  const ttl = typeof body.expires_in === 'number' && body.expires_in > 0 ? body.expires_in * 1000 : DEFAULT_TTL_MS;
+  return { accessToken, refreshToken, expiresAt: now + ttl, savedAt: new Date(now).toISOString() };
+}
+
+const tokensFrom = (body: Record<string, unknown>, who: Pick<ChatgptTokens, 'clientId' | 'subject' | 'email'>, keptRefresh: string, now: number): ChatgptTokens => ({
+  method: 'chatgpt',
+  clientId: who.clientId,
+  subject: who.subject,
+  email: who.email,
+  ...grantOf(body, keptRefresh, now),
+});
+
+const officialToken = (issuer: string): string => `${issuer}/api/accounts/oauth/token`;
+
+function clientOf(started: Pending, returned: string | null): string {
+  const clientId = started.clientId ?? returned;
+  if (clientId === null || clientId === NEW_CLIENT) throw new CodexAuthError(`ChatGPT did not finish registering Metro; ${AGAIN}`);
+  if (returned !== null && returned !== clientId) throw new CodexAuthError(`ChatGPT answered for another Metro registration; ${AGAIN}`);
+  return clientId;
+}
+
+export async function finishLogin(callback: string, issuer = CODEX_ISSUER, fetchImpl: typeof fetch = fetch, now = Date.now()): Promise<ChatgptTokens> {
+  const { code, state, clientId: returned } = parseCallback(callback);
+  const started = pending.take(state, now);
+  if (started === undefined) throw new CodexAuthError(`this sign-in link has expired or was started elsewhere; ${AGAIN}`);
+  const clientId = clientOf(started, returned);
+  const body = await tokenCall(
+    officialToken(issuer),
+    asForm({ grant_type: 'authorization_code', client_id: clientId, code, code_verifier: started.verifier, redirect_uri: CODEX_REDIRECT, resource: OPENAI_API }),
+    fetchImpl,
+  );
+  const who = identityOf(body.id_token, { issuer, clientId, nonce: started.nonce });
+  if (started.subject !== null && who.subject !== started.subject)
+    throw new CodexAuthError('this is another ChatGPT account than the one this connection signed in with; add a new connection for it');
+  const scopes = (nonEmpty(body.scope) ?? '').split(/\s+/);
+  if (!scopes.includes(PLAN_SCOPE)) throw new CodexAuthError('ChatGPT did not allow Metro to use your plan: sign in again and allow it (it needs ChatGPT Plus or Pro)');
+  return tokensFrom(body, { clientId, ...who }, '', now);
+}
+
+export async function refreshTokens(previous: ChatgptTokens, issuer = CODEX_ISSUER, fetchImpl: typeof fetch = fetch, now = Date.now()): Promise<ChatgptTokens> {
+  const body = await tokenCall(
+    officialToken(issuer),
+    asForm({ grant_type: 'refresh_token', client_id: previous.clientId, refresh_token: previous.refreshToken, resource: OPENAI_API }),
+    fetchImpl,
+  );
+  return tokensFrom(body, previous, previous.refreshToken, now);
+}
+
+export const tokensStale = (tokens: CodexTokens, now = Date.now()): boolean => now >= tokens.expiresAt - RENEW_BEFORE_MS;