@ours.network/fleet 1.2.0-nightly.20 → 1.2.0-nightly.22

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.20",
-  "buildId": "bd038efa768e",
-  "commit": "5f7b870fe2d026aeadb508a13c6dbdc38f573d2c",
+  "version": "1.2.0-nightly.22",
+  "buildId": "f5776b7613c5",
+  "commit": "769fba35bc2918e792c353d2234d0fe5e2a48f57",
   "dirty": true,
-  "builtAt": "2026-09-29T18:01:53.344Z",
+  "builtAt": "2026-09-30T07:56:23.700Z",
   "capabilities": [
     "cowork.http-management-v1",
     "monitor.interrupt.after_tool"

package/dist/init-wizard.js

@@ -14,6 +14,7 @@ const REASONING_EFFORT = {
     quick: 'low', balanced: 'medium', thorough: 'high',
 };
 const MODEL_LABELS = {
+    'gpt-6.1-sol': 'GPT-6.1 Sol',
     'gpt-6-sol': 'GPT-6 Sol',
     'gpt-6-luna': 'GPT-6 Luna',
     'claude-fable-5-1': 'Claude Fable 5.1',

package/dist/isolation/policy.js

@@ -168,6 +168,8 @@ export function resolveIsolation(cfg, ctx) {
     }
     for (const dir of ctx.additionalWriteDirs ?? [])
         addRw(dir);
+    if (ctx.subscriptionHome)
+        addRw(ctx.subscriptionHome);
     // The selected harness/session command may live outside the system allowlist
     // (for example Node and a bundled ACP adapter under ~/.local). The runner
     // resolves its exact executable/package closure; keep every such bind RO.

package/dist/isolation/types.d.ts

@@ -63,6 +63,11 @@ export interface WrapContext {
      * them for itself or for its peers.
      */
     harnessSharedPaths?: string[];
+    /**
+     * The pinned subscription profile home (CLAUDE_CONFIG_DIR / CODEX_HOME), mounted
+     * read-write so the CLI can refresh that profile's login. Absent for the default.
+     */
+    subscriptionHome?: string;
     /** Exact launcher/interpreter/module closure required by the selected command. */
     runtimeReadPaths?: string[];
     brokerEndpoint?: string;

package/dist/runner.js

@@ -14,6 +14,7 @@ import { createMonitor, probeIdentityPresence, } from './monitor.js';
 import { DaemonGenerationObserver, RoleRecoveryController, probeDaemonGeneration, } from './daemon-recovery.js';
 import { realExec } from './exec.js';
 import { resolveIsolation } from './isolation/policy.js';
+import { pinSubscriptionForLaunch } from './subscriptions/launch.js';
 import { selectIsolationBackend } from './isolation/registry.js';
 import { resourceArgs, cpuControllerDelegated } from './isolation/resources.js';
 import { resolveLaunchRuntime } from './isolation/runtime.js';
@@ -525,6 +526,11 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     const sessionBackend = role.session ?? 'acp';
     const sessionLabel = sessionBackend === 'acp' ? 'ACP' : 'Codex app-server';
     let launch = adapter.agentSession.prepareLaunch(role, prep);
+    // Resolve the fleet-wide active subscription profile once, now: a later switch
+    // never changes this session (the operator restarts agents to move them).
+    const subscription = pinSubscriptionForLaunch(role, dir);
+    if (subscription?.pin.home)
+        deps.log(`[${name}] subscription: ${subscription.pin.provider} profile ${subscription.pin.profileId}`);
     // Preserve the role's existing isolation policy.
     let wrappedArgv = launch.argv;
     if (role.isolation) {
@@ -535,6 +541,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         launch = { ...launch, argv: runtime.argv };
         const ctx = {
             ...isolationContextFor(role), stateDir: dir, runCwd,
+            subscriptionHome: subscription?.writablePath,
             runtimeReadPaths: [...runtime.readPaths, ...resolveLaunchRuntime([process.execPath, fileURLToPath(new URL('./agent-ours/bridge.js', import.meta.url))]).readPaths],
         };
         const policy = resolveIsolation(role.isolation, ctx);
@@ -560,7 +567,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     const managedService = await deps.prepareAgentOurs(role, dir, opts.identityLifetime ? opts.identityLifetime === 'temporary' : temp);
     let layoutRetiring = false;
     try {
-        const managedHarness = prepareManagedHarness(role, dir, runCwd, managedService.descriptor, harnessChildEnv(role, launch.env, dir));
+        const managedHarness = prepareManagedHarness(role, dir, runCwd, managedService.descriptor, { ...harnessChildEnv(role, launch.env, dir), ...subscription?.env });
         // Start-stagger: space this launch at least start_stagger_ms after the previous
         // agent launch across the whole host, so a burst of boots (systemd starts every
         // user unit concurrently on boot; `ours-fleet up`/restart-all bulk-start) does not

package/dist/session/acp.js

@@ -8,6 +8,7 @@ import * as acp from '@agentclientprotocol/sdk';
 import { normalizeSessionUpdate } from './conversation-normalizer.js';
 import { ConversationEventStore } from './conversation-store.js';
 import { SessionEvents } from './events.js';
+import { recordClaudeRateLimit } from '../subscriptions/observed.js';
 import { DEFAULT_STALL_TIMEOUT_MS, STALL_RECOVERY_PROMPT, StallWatchdog, StallToolHistory, hasStallRecoveryClaim } from './stall-watchdog.js';
 import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, classifyChildExit, sessionBackendCapabilities, turnResult, } from './types.js';
 const CANCEL_SETTLE_GRACE_MS = 15_000;
@@ -1713,6 +1714,12 @@ export class AcpSession {
         this.recordConversationUpdate(update, scheduled, messagePhase === 'commentary');
         if (update.sessionUpdate === 'config_option_update')
             this.captureRuntimeMetadata(update.configOptions);
+        if (update.sessionUpdate === 'usage_update') {
+            // Claude subscription rate-limit snapshot (claude-agent-acp forwards the SDK rate_limit_event).
+            const rateLimit = update._meta?.['_claude/rateLimit'];
+            if (rateLimit)
+                recordClaudeRateLimit(this.options.stateDir, rateLimit);
+        }
         switch (update.sessionUpdate) {
             case 'agent_message_chunk': {
                 const phase = messagePhase;

package/dist/subscriptions/cli.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Thin adapters over the official CLIs. Nothing here reads or returns a token
+ * value: credentials stay in files the CLIs own, and secrets typed by the user
+ * (a Claude paste code) travel only over a child's stdin, never argv or logs.
+ */
+export interface SubscriptionBinaries {
+    claude: string;
+    codex: string;
+    /** `script(1)`, used to give `claude auth login` the terminal it expects. */
+    script: string;
+}
+export declare const defaultBinaries: () => SubscriptionBinaries;
+/**
+ * Child env for a profile helper: explicit home for added profiles, the CLI
+ * default otherwise. Every credential selector either CLI honours is removed,
+ * so a helper can only ever see the profile's own login.
+ */
+export declare function profileEnv(homeVar: string, profileId: string, home: string, base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export interface ClaudeStatus {
+    loggedIn: boolean;
+    email?: string;
+    plan?: string;
+    org?: string;
+    authMethod?: string;
+}
+/** `claude auth status --json` (documented: exit 0 when logged in, 1 otherwise). */
+export declare function claudeAuthStatus(bin: string, env: NodeJS.ProcessEnv, timeoutMs?: number): Promise<ClaudeStatus>;
+/**
+ * Login expiry timestamps from the Claude credentials file. Field names are
+ * observed (Claude Code 2.1.x), not a documented contract, so absence is normal.
+ * Only the two numbers are kept; the parsed object is discarded immediately.
+ */
+export declare function claudeLoginExpiry(home: string): {
+    accessExpiresAt?: number;
+    refreshExpiresAt?: number;
+};
+/** Minimal stdio JSON-RPC client for `codex app-server` (the supported transport). */
+export declare class CodexAppServer {
+    private readonly child;
+    private id;
+    private buffer;
+    private readonly pending;
+    private readonly listeners;
+    private closed;
+    private constructor();
+    static start(bin: string, env: NodeJS.ProcessEnv): Promise<CodexAppServer>;
+    call<T = unknown>(method: string, params: unknown, timeoutMs?: number): Promise<T>;
+    onNotification(fn: (method: string, params: unknown) => void): () => void;
+    close(): void;
+    private onData;
+}
+/** One-shot use of an app-server for a profile. */
+export declare function withCodex<T>(bin: string, env: NodeJS.ProcessEnv, fn: (s: CodexAppServer) => Promise<T>): Promise<T>;
+export interface UsageWindow {
+    id: string;
+    label: string;
+    usedPercent: number;
+    windowMins?: number;
+    resetsAt?: string;
+}
+interface CodexWindow {
+    usedPercent?: number;
+    windowDurationMins?: number | null;
+    resetsAt?: number | null;
+}
+interface CodexSnapshot {
+    limitId?: string | null;
+    limitName?: string | null;
+    primary?: CodexWindow | null;
+    secondary?: CodexWindow | null;
+}
+/** Flatten `account/rateLimits/read` into display windows. */
+export declare function codexUsageWindows(result: {
+    rateLimits?: CodexSnapshot;
+    rateLimitsByLimitId?: Record<string, CodexSnapshot | undefined> | null;
+}): UsageWindow[];
+export declare function windowName(mins?: number): string;
+export {};

package/dist/subscriptions/cli.js

@@ -0,0 +1,186 @@
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CONFLICTING_AUTH_ENV } from './launch.js';
+import { DEFAULT_PROFILE_ID } from './store.js';
+export const defaultBinaries = () => ({
+    claude: process.env.OURS_FLEET_CLAUDE_BIN ?? 'claude',
+    codex: process.env.OURS_FLEET_CODEX_BIN ?? 'codex',
+    script: 'script',
+});
+/**
+ * Child env for a profile helper: explicit home for added profiles, the CLI
+ * default otherwise. Every credential selector either CLI honours is removed,
+ * so a helper can only ever see the profile's own login.
+ */
+export function profileEnv(homeVar, profileId, home, base = process.env) {
+    const env = { ...base, BROWSER: 'true', NO_COLOR: '1' };
+    for (const key of [...CONFLICTING_AUTH_ENV.claude, ...CONFLICTING_AUTH_ENV.codex, 'ANTHROPIC_BASE_URL', 'OPENAI_BASE_URL'])
+        delete env[key];
+    if (profileId !== DEFAULT_PROFILE_ID)
+        env[homeVar] = home;
+    return env;
+}
+/** `claude auth status --json` (documented: exit 0 when logged in, 1 otherwise). */
+export function claudeAuthStatus(bin, env, timeoutMs = 20_000) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, ['auth', 'status', '--json'], { env, stdio: ['ignore', 'pipe', 'ignore'] });
+        let out = '';
+        const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('claude auth status timed out')); }, timeoutMs);
+        child.stdout.on('data', d => { out += d; if (out.length > 64 * 1024)
+            child.kill('SIGKILL'); });
+        child.once('error', error => { clearTimeout(timer); reject(error); });
+        child.once('close', code => {
+            clearTimeout(timer);
+            let parsed = {};
+            try {
+                parsed = JSON.parse(out);
+            }
+            catch { /* non-JSON: rely on exit code */ }
+            const str = (v) => typeof v === 'string' && v ? v.slice(0, 120) : undefined;
+            resolve({
+                loggedIn: code === 0 && parsed.loggedIn !== false,
+                email: str(parsed.email), plan: str(parsed.subscriptionType), org: str(parsed.orgName),
+                authMethod: str(parsed.authMethod),
+            });
+        });
+    });
+}
+/**
+ * Login expiry timestamps from the Claude credentials file. Field names are
+ * observed (Claude Code 2.1.x), not a documented contract, so absence is normal.
+ * Only the two numbers are kept; the parsed object is discarded immediately.
+ */
+export function claudeLoginExpiry(home) {
+    try {
+        const oauth = JSON.parse(readFileSync(join(home, '.credentials.json'), 'utf8')).claudeAiOauth;
+        const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+        return { accessExpiresAt: num(oauth?.expiresAt), refreshExpiresAt: num(oauth?.refreshTokenExpiresAt) };
+    }
+    catch {
+        return {};
+    }
+}
+/** Minimal stdio JSON-RPC client for `codex app-server` (the supported transport). */
+export class CodexAppServer {
+    child;
+    id = 0;
+    buffer = '';
+    pending = new Map();
+    listeners = new Set();
+    closed = false;
+    constructor(child) {
+        this.child = child;
+        child.stdout.on('data', chunk => this.onData(String(chunk)));
+        child.stdin.on('error', () => { });
+        child.stderr.resume();
+        child.once('close', () => {
+            this.closed = true;
+            for (const p of this.pending.values())
+                p.reject(new Error('codex app-server exited'));
+            this.pending.clear();
+        });
+    }
+    static async start(bin, env) {
+        const child = spawn(bin, ['app-server'], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+        await new Promise((resolve, reject) => { child.once('spawn', resolve); child.once('error', reject); });
+        const server = new CodexAppServer(child);
+        await server.call('initialize', { clientInfo: { name: 'ours-fleet', title: 'Ours Fleet', version: '1' } });
+        child.stdin.write(`${JSON.stringify({ method: 'initialized' })}\n`);
+        return server;
+    }
+    call(method, params, timeoutMs = 20_000) {
+        if (this.closed)
+            return Promise.reject(new Error('codex app-server exited'));
+        const id = ++this.id;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`${method} timed out`)); }, timeoutMs);
+            this.pending.set(id, {
+                resolve: v => { clearTimeout(timer); resolve(v); },
+                reject: e => { clearTimeout(timer); reject(e); },
+            });
+            this.child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+        });
+    }
+    onNotification(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    close() {
+        if (!this.closed)
+            this.child.kill();
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        for (let i = this.buffer.indexOf('\n'); i >= 0; i = this.buffer.indexOf('\n')) {
+            const line = this.buffer.slice(0, i).trim();
+            this.buffer = this.buffer.slice(i + 1);
+            if (!line)
+                continue;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (typeof message.id === 'number' && this.pending.has(message.id) && !message.method) {
+                const p = this.pending.get(message.id);
+                this.pending.delete(message.id);
+                if (message.error)
+                    p.reject(Object.assign(new Error(String(message.error.message ?? 'codex error').slice(0, 300)), { rpcCode: message.error.code }));
+                else
+                    p.resolve(message.result);
+            }
+            else if (message.method) {
+                for (const fn of this.listeners)
+                    fn(message.method, message.params);
+            }
+        }
+    }
+}
+/** One-shot use of an app-server for a profile. */
+export async function withCodex(bin, env, fn) {
+    const server = await CodexAppServer.start(bin, env);
+    try {
+        return await fn(server);
+    }
+    finally {
+        server.close();
+    }
+}
+/** Flatten `account/rateLimits/read` into display windows. */
+export function codexUsageWindows(result) {
+    const snapshots = result.rateLimitsByLimitId && Object.keys(result.rateLimitsByLimitId).length
+        ? Object.entries(result.rateLimitsByLimitId) : [['codex', result.rateLimits]];
+    const windows = [];
+    for (const [limitId, snap] of snapshots) {
+        if (!snap)
+            continue;
+        for (const [slot, w] of [['primary', snap.primary], ['secondary', snap.secondary]]) {
+            if (!w || typeof w.usedPercent !== 'number')
+                continue;
+            windows.push({
+                id: `${limitId}:${slot}`,
+                label: `${snap.limitName ?? limitId} · ${windowName(w.windowDurationMins ?? undefined)}`,
+                usedPercent: w.usedPercent,
+                windowMins: w.windowDurationMins ?? undefined,
+                resetsAt: typeof w.resetsAt === 'number' ? new Date(w.resetsAt * 1000).toISOString() : undefined,
+            });
+        }
+    }
+    return windows;
+}
+export function windowName(mins) {
+    if (!mins)
+        return 'window';
+    if (mins === 300)
+        return '5h';
+    if (mins === 10_080)
+        return 'weekly';
+    if (mins % 1440 === 0)
+        return `${mins / 1440}d`;
+    if (mins % 60 === 0)
+        return `${mins / 60}h`;
+    return `${mins}m`;
+}

package/dist/subscriptions/launch.d.ts

@@ -0,0 +1,37 @@
+import { type SubscriptionPin, type SubscriptionProvider } from './store.js';
+/** The subscription provider a harness authenticates with, if Fleet manages it. */
+export declare function providerForHarness(harness: string): SubscriptionProvider | undefined;
+/** Env var that selects the CLI home for each provider. */
+export declare const HOME_ENV: Record<SubscriptionProvider, string>;
+/**
+ * Credential sources that would silently outrank the fleet-wide active profile
+ * (see Claude Code's documented authentication precedence and Codex's
+ * API-key login). While a non-default profile is active they are refused.
+ */
+export declare const CONFLICTING_AUTH_ENV: Record<SubscriptionProvider, string[]>;
+/** Claude managed-settings file (Linux), which outranks user settings. */
+export declare const CLAUDE_MANAGED_SETTINGS = "/etc/claude-code/managed-settings.json";
+/**
+ * Competing Claude credential sources declared in settings files: an `env`
+ * block entry from CONFLICTING_AUTH_ENV, or an `apiKeyHelper`. Settings are
+ * shared into profiles, so they can silently outrank a profile's login.
+ */
+export declare function claudeSettingsAuthSources(home: string, managed?: string): string[];
+export interface LaunchPin {
+    pin: SubscriptionPin;
+    /** Added to the harness child env last. Empty for the adopted default. */
+    env: Record<string, string>;
+    /** Host path the sandbox must mount read-write, if any. */
+    writablePath?: string;
+}
+/**
+ * Resolve the provider's active profile for a launch and record it in the
+ * agent's state dir. Resolution happens once, here: a later switch never
+ * changes what this session uses.
+ */
+export declare function pinSubscriptionForLaunch(role: {
+    name: string;
+    harness: string;
+    env?: Record<string, string>;
+    auth_proxy?: unknown;
+}, stateDir: string, inherited?: NodeJS.ProcessEnv, now?: () => Date): LaunchPin | undefined;

package/dist/subscriptions/launch.js

@@ -0,0 +1,93 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { FleetError } from '../application/errors.js';
+import { DEFAULT_PROFILE_ID, profileHome, readSubscriptionState, writePin, } from './store.js';
+/** The subscription provider a harness authenticates with, if Fleet manages it. */
+export function providerForHarness(harness) {
+    if (harness === 'claude-code')
+        return 'claude';
+    if (harness === 'codex')
+        return 'codex';
+    return undefined;
+}
+/** Env var that selects the CLI home for each provider. */
+export const HOME_ENV = {
+    claude: 'CLAUDE_CONFIG_DIR',
+    codex: 'CODEX_HOME',
+};
+/**
+ * Credential sources that would silently outrank the fleet-wide active profile
+ * (see Claude Code's documented authentication precedence and Codex's
+ * API-key login). While a non-default profile is active they are refused.
+ */
+export const CONFLICTING_AUTH_ENV = {
+    claude: [
+        'CLAUDE_CONFIG_DIR', 'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN',
+        'CLAUDE_CODE_OAUTH_REFRESH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR',
+        'CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX', 'CLAUDE_CODE_USE_FOUNDRY', 'ANTHROPIC_PROFILE',
+        'ANTHROPIC_FEDERATION_RULE_ID', 'ANTHROPIC_ORGANIZATION_ID', 'ANTHROPIC_IDENTITY_TOKEN_FILE',
+    ],
+    codex: ['CODEX_HOME', 'OPENAI_API_KEY', 'CODEX_API_KEY'],
+};
+/** Claude managed-settings file (Linux), which outranks user settings. */
+export const CLAUDE_MANAGED_SETTINGS = '/etc/claude-code/managed-settings.json';
+/**
+ * Competing Claude credential sources declared in settings files: an `env`
+ * block entry from CONFLICTING_AUTH_ENV, or an `apiKeyHelper`. Settings are
+ * shared into profiles, so they can silently outrank a profile's login.
+ */
+export function claudeSettingsAuthSources(home, managed = CLAUDE_MANAGED_SETTINGS) {
+    const found = [];
+    for (const file of [join(home, 'settings.json'), managed]) {
+        let settings;
+        try {
+            settings = JSON.parse(readFileSync(file, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        for (const key of CONFLICTING_AUTH_ENV.claude)
+            if (settings?.env && typeof settings.env === 'object' && key in settings.env)
+                found.push(`${key} (${file})`);
+        if (settings?.apiKeyHelper)
+            found.push(`apiKeyHelper (${file})`);
+    }
+    return found;
+}
+/**
+ * Resolve the provider's active profile for a launch and record it in the
+ * agent's state dir. Resolution happens once, here: a later switch never
+ * changes what this session uses.
+ */
+export function pinSubscriptionForLaunch(role, stateDir, inherited = process.env, now = () => new Date()) {
+    const provider = providerForHarness(role.harness);
+    // A loopback auth proxy supplies credentials itself; it is not managed here.
+    if (!provider || role.auth_proxy)
+        return undefined;
+    const profileId = readSubscriptionState().providers[provider].activeProfileId;
+    const pin = { provider, profileId, pinnedAt: now().toISOString() };
+    if (profileId === DEFAULT_PROFILE_ID) {
+        // The adopted default launches exactly as before; credential env that points
+        // elsewhere is recorded so the panel can say this session is not managed.
+        const unmanaged = CONFLICTING_AUTH_ENV[provider].filter(key => role.env?.[key] !== undefined || inherited[key]);
+        if (unmanaged.length)
+            pin.unmanaged = unmanaged;
+        writePin(stateDir, pin);
+        return { pin, env: {} };
+    }
+    const conflicts = CONFLICTING_AUTH_ENV[provider].filter(key => role.env?.[key] !== undefined || (key !== HOME_ENV[provider] && inherited[key]));
+    if (conflicts.length) {
+        throw new FleetError('invalid_request', `role '${role.name}': ${conflicts.join(', ')} would bypass the active ${provider} subscription profile; ` +
+            'remove it from the role env / supervisor environment or switch back to the default profile');
+    }
+    const home = profileHome(provider, profileId);
+    if (provider === 'claude') {
+        const settings = claudeSettingsAuthSources(home);
+        if (settings.length) {
+            throw new FleetError('invalid_request', `role '${role.name}': Claude settings declare ${settings.join(', ')}, which would bypass the active subscription profile`);
+        }
+    }
+    pin.home = home;
+    writePin(stateDir, pin);
+    return { pin, env: { [HOME_ENV[provider]]: home }, writablePath: home };
+}

package/dist/subscriptions/login.d.ts

@@ -0,0 +1,75 @@
+import { type SubscriptionBinaries } from './cli.js';
+import type { SubscriptionProvider } from './store.js';
+/**
+ * A short-lived, browser-owned login. The URL comes from the official CLI and
+ * is shown only if its origin is on the provider's allowlist; the user's code
+ * goes to the CLI's stdin exactly once and is never stored.
+ */
+export type LoginState = 'starting' | 'awaiting_user' | 'verifying' | 'succeeded' | 'failed' | 'cancelled' | 'expired';
+export interface LoginView {
+    loginId: string;
+    provider: SubscriptionProvider;
+    kind: 'paste_code' | 'device_code';
+    state: LoginState;
+    url?: string;
+    /** Device code to type at `url`; only exposed while the user still needs it. */
+    userCode?: string;
+    expiresAt: string;
+    error?: string;
+}
+export declare const LOGIN_TTL_MS: number;
+export declare const LOGIN_URL_ALLOWLIST: Record<SubscriptionProvider, string[]>;
+export declare function allowedLoginUrl(provider: SubscriptionProvider, raw: string): string | undefined;
+export interface LoginHandle {
+    view(): LoginView;
+    /** Browser session that started the login; only it may act on it. */
+    readonly owner: string;
+    submitCode(code: string): void;
+    cancel(): void;
+    /** Resolves when the CLI has finished (success or not). */
+    readonly done: Promise<boolean>;
+}
+declare abstract class BaseLogin implements LoginHandle {
+    readonly provider: SubscriptionProvider;
+    readonly owner: string;
+    readonly kind: LoginView['kind'];
+    readonly loginId: string;
+    readonly expiresAt: number;
+    state: LoginState;
+    url?: string;
+    userCode?: string;
+    error?: string;
+    done: Promise<boolean>;
+    protected finish: (ok: boolean) => void;
+    private readonly timer;
+    constructor(provider: SubscriptionProvider, owner: string, kind: LoginView['kind'], now?: number);
+    view(): LoginView;
+    abstract submitCode(code: string): void;
+    protected abstract stop(): void;
+    cancel(): void;
+    protected end(state: LoginState, error?: string): void;
+    /** Called by the service after verifying the new home. */
+    complete(ok: boolean, error?: string): void;
+}
+/** `claude auth login` inside script(1): prints an authorize URL, then reads a paste code. */
+export declare class ClaudeLogin extends BaseLogin {
+    private child?;
+    private output;
+    private submitted;
+    /** Resolves with the CLI exit status once it exits. */
+    exited: Promise<number | null>;
+    constructor(owner: string, bins: SubscriptionBinaries, home: string, profileId: string);
+    submitCode(code: string): void;
+    protected stop(): void;
+}
+/** Codex device-code login through the app-server's supported account API. */
+export declare class CodexDeviceLogin extends BaseLogin {
+    private server?;
+    private codexLoginId?;
+    /** Resolves true when the app-server reports a successful login. */
+    completed: Promise<boolean>;
+    constructor(owner: string, bins: SubscriptionBinaries, home: string, profileId: string);
+    submitCode(): void;
+    protected stop(): void;
+}
+export {};