@stage-labs/metro 0.1.0-beta.310 → 0.1.0-beta.311

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

@@ -26,7 +26,7 @@ export interface Connection {
   zdr: boolean;
   revision: number;
   codex: CodexAccess | null;
-  claude: string | null;
+  claudeToken: string;
   account: Account;
   signedOut: boolean;
 }
@@ -48,48 +48,15 @@ export interface Route {
   model: string;
 }
 
-export const LOCAL_PREFIX = 'local:';
-export const SESSION_LOGIN = `${LOCAL_PREFIX}session`;
 export const CODEX_SIGN_IN = "Codex is not signed in: sign in again on the organization's Models page.";
 
 const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex):(.+)$/;
 const SMALL_RE = /haiku/i;
-const NO_ACCOUNT: Account = { email: null, plan: null, method: null };
 
 export const isProvider = (value: unknown): value is Provider => typeof value === 'string' && (PROVIDERS as readonly string[]).includes(value);
 
 export const emptySetup = (): ModelSetup => ({ primary: null, fallbacks: [], connections: [], source: null });
 
-export const loginRef = (login: string): string => `${LOCAL_PREFIX}${login}`;
-
-const localConnection = (id: string, label: string, claude: string | null, account: Account, missing: boolean): Connection => ({
-  id,
-  provider: 'anthropic',
-  label,
-  model: '',
-  apiKey: '',
-  region: '',
-  zdr: false,
-  revision: 0,
-  codex: null,
-  claude,
-  account,
-  signedOut: missing,
-});
-
-export const sessionConnection = (): Connection => localConnection(SESSION_LOGIN, 'Claude Code login', null, NO_ACCOUNT, false);
-
-export interface LocalLogin {
-  id: string;
-  email: string | null;
-  plan: string | null;
-}
-
-export function loginConnection(login: string, known: LocalLogin | undefined): Connection {
-  const account = known === undefined ? NO_ACCOUNT : { email: known.email, plan: known.plan, method: null };
-  return localConnection(loginRef(login), known?.email ?? 'Claude login', login, account, known === undefined);
-}
-
 export const connectionOf = (setup: ModelSetup, id: string): Connection | null => setup.connections.find((c) => c.id === id) ?? null;
 
 export function primaryRoute(setup: ModelSetup): Route | null {
@@ -99,13 +66,8 @@ export function primaryRoute(setup: ModelSetup): Route | null {
   return { connection: conn, model: primary.model === '' ? conn.model : primary.model };
 }
 
-const MISSING_LOGIN = 'This Claude login is not on this box: sign in again on the Model page.';
-
 const CHECKS: Record<Provider, [(r: Route) => boolean, string][]> = {
-  anthropic: [
-    [(r) => r.connection.claude !== null && r.connection.signedOut, MISSING_LOGIN],
-    [(r) => !r.connection.id.startsWith(LOCAL_PREFIX) && r.connection.apiKey === '', "Anthropic has no API key: add it on the organization's Models page."],
-  ],
+  anthropic: [[(r) => r.connection.apiKey === '' && r.connection.claudeToken === '', "Anthropic has no API key or Claude subscription: add one on the organization's Models page."]],
   bedrock: [
     [(r) => r.connection.apiKey === '', "Bedrock has no API key: add it on the organization's Models page."],
     [(r) => r.connection.region === '', "Bedrock needs a region: add it on the organization's Models page."],

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

@@ -1,9 +1,13 @@
 import { lstatSync, readdirSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { errMsg, log } from '@metro-labs/core/log';
 import { agentsDir } from '../agents/files.js';
+import { existsSync } from '../agent-user/agent-fs.js';
+import { removeHome } from '../agent-user/home-fs.js';
+import { agentUser, agentUserExpected } from '../agent-user/user.js';
 
-const LEFTOVER_RE = /^chatgpt-host\.json(?:\.tmp-[0-9]+)?$/;
+const LEFTOVER_RE = /^(?:chatgpt-host|model)\.json(?:\.tmp-[0-9]+)?$/;
 
 const codeOf = (err: unknown): unknown => (err instanceof Error && 'code' in err ? err.code : undefined);
 
@@ -30,9 +34,26 @@ function removeOne(path: string): boolean {
   }
 }
 
-export function removeModelLeftovers(dir = agentsDir()): number {
+export function claudeLoginsDir(): string | null {
+  const user = agentUser();
+  if (user === null && agentUserExpected()) return null;
+  return join(user?.home ?? homedir(), '.metro', 'claude-logins');
+}
+
+function removeClaudeLogins(dir: string | null): number {
+  if (dir === null || !existsSync(dir)) return 0;
+  try {
+    removeHome(dir, true);
+    return 1;
+  } catch (err) {
+    log.warn({ err: errMsg(err), dir }, 'org-models: could not remove the folder of the old Claude logins');
+    return 0;
+  }
+}
+
+export function removeModelLeftovers(dir = agentsDir(), logins: string | null = claudeLoginsDir()): number {
   try {
-    const removed = namesIn(dir).filter((name) => removeOne(join(dir, name))).length;
+    const removed = namesIn(dir).filter((name) => removeOne(join(dir, name))).length + removeClaudeLogins(logins);
     log.info({ removed }, 'org-models: removed the files of the old model setup');
     return removed;
   } catch (err) {

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

@@ -1,71 +1,11 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg } from '@metro-labs/core/log';
 import { assembleMessage, SseParser, type SseEvent } from './frames.js';
-import { GatewayError, relayFrames, type Watch } from './forward.js';
+import { relayFrames, type Watch } from './forward.js';
 import { UsageScanner } from './usage.js';
 
 const STATUS_OF: Record<string, number> = { rate_limit_error: 429, invalid_request_error: 400, permission_error: 403, overloaded_error: 529 };
 
-interface Slot<T> {
-  refreshing: Promise<T> | null;
-  latest: T | null;
-}
-
-export type TokenState<T> = Map<string, Slot<T>>;
-
-export interface TokenSource<T extends { savedAt: string }> {
-  label: string;
-  stale: (tokens: T) => boolean;
-  refresh: (tokens: T) => Promise<T>;
-  save: (id: string, tokens: T) => void;
-}
-
-function slotFor<T>(state: TokenState<T>, id: string): Slot<T> {
-  const found = state.get(id);
-  if (found !== undefined) return found;
-  const made: Slot<T> = { refreshing: null, latest: null };
-  state.set(id, made);
-  return made;
-}
-
-const newerThan = (a: { savedAt: string }, b: { savedAt: string }): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
-
-export function refreshed<T extends { savedAt: string }>(state: TokenState<T>, id: string, tokens: T, source: TokenSource<T>): Promise<T> {
-  const slot = slotFor(state, id);
-  const latest = slot.latest;
-  if (latest !== null && newerThan(latest, tokens) && !source.stale(latest)) return Promise.resolve(latest);
-  if (slot.refreshing !== null) return slot.refreshing;
-  const run = source
-    .refresh(tokens)
-    .then((fresh) => {
-      source.save(id, fresh);
-      slot.latest = fresh;
-      return fresh;
-    })
-    .catch((err: unknown) => {
-      throw new GatewayError(403, 'permission_error', `${source.label} sign-in expired (${errMsg(err)}): connect again on the Model page`);
-    })
-    .finally(() => {
-      slot.refreshing = null;
-    });
-  slot.refreshing = run;
-  return run;
-}
-
-export function currentOf<T extends { savedAt: string }>(state: TokenState<T>, id: string, tokens: T | null, source: TokenSource<T>, missing: string): Promise<T> {
-  if (tokens === null) throw new GatewayError(400, 'invalid_request_error', missing);
-  return source.stale(tokens) ? refreshed(state, id, tokens, source) : Promise.resolve(tokens);
-}
-
-export async function reach<T>(current: () => Promise<T>, again: (tokens: T) => Promise<T>, send: (tokens: T) => Promise<Response>): Promise<Response> {
-  const tokens = await current();
-  const upstream = await send(tokens);
-  if (upstream.status !== 401) return upstream;
-  await upstream.body?.cancel();
-  return send(await again(tokens));
-}
-
 export function errorKind(status: number, invalid: readonly number[] = [400, 404]): string {
   if (status === 401 || status === 403) return 'permission_error';
   if (status === 429) return 'rate_limit_error';

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

@@ -1,20 +1,14 @@
 import { errMsg, log } from '@metro-labs/core/log';
-import { readClaudeUsage } from '../claude/usage-probe.js';
 import { openrouterKey } from './openrouter.js';
-import { claudeLoginUsage, keepProbeAnswer, mayProbe, mergeUsage, noteUsage, openrouterUsage, probeAnswer, usageOf } from './usage.js';
-import { loginRef, primaryRoute, SESSION_LOGIN, type Connection, type ModelSetup } from './model-config.js';
-import { probeClaudeLogin, type ClaudeLoginDeps } from './claude-logins.js';
-import type { ClaudeLogin } from './claude-store.js';
+import { mayProbe, noteUsage, openrouterUsage, usageOf } from './usage.js';
+import type { Connection, ModelSetup } from './model-config.js';
 
 export const CREDITS_TTL_MS = 5 * 60_000;
 const WAIT_MS = 4_000;
-const LOGIN_PROBE = 'claude-login';
 
 export interface UsageDeps {
   fetchImpl?: typeof fetch;
   openrouterBase?: string;
-  claudeUsage?: (env?: Record<string, string>) => Promise<unknown>;
-  claudeLogins?: ClaudeLoginDeps;
   usageWaitMs?: number;
 }
 
@@ -23,47 +17,15 @@ const fresh = (id: string, now: number): boolean => {
   return seen !== undefined && now - Date.parse(seen.at) < CREDITS_TTL_MS;
 };
 
-const due = (id: string, now: number): boolean => !fresh(id, now) && mayProbe(id, now, CREDITS_TTL_MS);
-
-async function probe(what: string, run: () => Promise<void>): Promise<void> {
+async function refreshKey(conn: Connection, deps: UsageDeps, now: number): Promise<void> {
+  if (conn.provider !== 'openrouter' || conn.apiKey === '' || fresh(conn.id, now) || !mayProbe(conn.id, now, CREDITS_TTL_MS)) return;
   try {
-    await run();
+    noteUsage(conn.id, openrouterUsage(await openrouterKey(conn.apiKey, deps.openrouterBase, deps.fetchImpl), new Date(now)));
   } catch (err) {
-    log.warn({ err: errMsg(err) }, `model-api: could not read the ${what}`);
+    log.warn({ err: errMsg(err) }, 'model-api: could not read the OpenRouter key spend');
   }
 }
 
-async function refreshKey(conn: Connection, deps: UsageDeps, now: number): Promise<void> {
-  if (conn.provider !== 'openrouter' || conn.apiKey === '' || !due(conn.id, now)) return;
-  await probe('OpenRouter key spend', async () => {
-    noteUsage(conn.id, openrouterUsage(await openrouterKey(conn.apiKey, deps.openrouterBase, deps.fetchImpl), new Date(now)));
-  });
-}
-
-const hasFallbacks = (setup: ModelSetup): boolean => setup.fallbacks.length > 0;
-
-async function refreshOwnLogin(login: string, setup: ModelSetup, deps: UsageDeps, now: number): Promise<void> {
-  const key = loginRef(login);
-  if ((fresh(key, now) && !hasFallbacks(setup)) || !mayProbe(key, now, CREDITS_TTL_MS)) return;
-  await probe('usage of a Claude login', async () => {
-    const usage = claudeLoginUsage(await probeClaudeLogin(login, deps.claudeLogins), new Date(now));
-    if (usage !== null) mergeUsage(key, usage);
-  });
-}
-
-const ridesSession = (setup: ModelSetup): boolean => primaryRoute(setup) === null || setup.connections.some((c) => c.id === SESSION_LOGIN);
-
-async function refreshSession(setup: ModelSetup, deps: UsageDeps, now: number): Promise<void> {
-  if (!ridesSession(setup) || (fresh(SESSION_LOGIN, now) && !hasFallbacks(setup))) return;
-  if (mayProbe(LOGIN_PROBE, now, CREDITS_TTL_MS))
-    await probe('usage of the Claude Code login', async () => {
-      const usage = claudeLoginUsage(await (deps.claudeUsage ?? (() => readClaudeUsage()))(), new Date(now));
-      if (usage !== null) keepProbeAnswer(LOGIN_PROBE, usage);
-    });
-  const usage = probeAnswer(LOGIN_PROBE);
-  if (usage !== undefined && now - Date.parse(usage.at) < CREDITS_TTL_MS) mergeUsage(SESSION_LOGIN, usage);
-}
-
 async function within(ms: number, work: Promise<unknown>): Promise<void> {
   let timer: ReturnType<typeof setTimeout> | undefined;
   const waited = new Promise<void>((resolve) => {
@@ -73,21 +35,15 @@ async function within(ms: number, work: Promise<unknown>): Promise<void> {
   clearTimeout(timer);
 }
 
-export async function refreshUsage(setup: ModelSetup, logins: ClaudeLogin[], deps: UsageDeps = {}, now = Date.now()): Promise<void> {
-  const own = new Set([...logins.map((l) => l.id), ...setup.connections.flatMap((c) => (c.claude === null || c.signedOut ? [] : [c.claude]))]);
-  const work = Promise.all([
-    ...setup.connections.map((conn) => refreshKey(conn, deps, now)),
-    ...[...own].map((login) => refreshOwnLogin(login, setup, deps, now)),
-    refreshSession(setup, deps, now),
-  ]);
-  await within(deps.usageWaitMs ?? WAIT_MS, work);
+export async function refreshUsage(setup: ModelSetup, deps: UsageDeps = {}, now = Date.now()): Promise<void> {
+  await within(deps.usageWaitMs ?? WAIT_MS, Promise.all(setup.connections.map((conn) => refreshKey(conn, deps, now))));
 }
 
-export function watchFallbackUsage(setup: () => ModelSetup, logins: () => ClaudeLogin[], deps: UsageDeps = {}, every = CREDITS_TTL_MS): void {
+export function watchFallbackUsage(setup: () => ModelSetup, deps: UsageDeps = {}, every = CREDITS_TTL_MS): void {
   const run = (): void => {
     const current = setup();
-    if (!hasFallbacks(current)) return;
-    refreshUsage(current, logins(), deps).catch((err: unknown) => {
+    if (current.fallbacks.length === 0) return;
+    refreshUsage(current, deps).catch((err: unknown) => {
       log.warn({ err: errMsg(err) }, 'model-api: could not refresh the usage of the fallback models');
     });
   };

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

@@ -1,6 +1,3 @@
-import { isRecord } from '@metro-labs/core/is-record';
-import { stringOf } from '@metro-labs/http/api-http';
-
 type Key = string;
 
 export interface UsageWindow {
@@ -31,14 +28,13 @@ const latest = new Map<Key, Reported>();
 const stamps = new Map<Key, Map<string, number>>();
 const tallies = new Map<Key, Tally>();
 const probed = new Map<Key, number>();
-const answers = new Map<Key, Reported>();
 
 export const noteUsage = (key: Key, usage: Reported): void => {
   latest.set(key, usage);
   stamps.set(key, new Map(usage.windows.map((w) => [w.label, Date.parse(usage.at)])));
 };
 
-export function mergeUsage(key: Key, usage: Reported): void {
+function mergeUsage(key: Key, usage: Reported): void {
   const seen = latest.get(key);
   const marks = stamps.get(key);
   if (seen === undefined || marks === undefined) {
@@ -66,25 +62,11 @@ export function usageSeen(): Record<Key, ProviderUsage> {
 
 export const usageOf = (key: Key): Reported | undefined => latest.get(key);
 
-export const forgetOne = (key: Key): void => {
-  latest.delete(key);
-  stamps.delete(key);
-  tallies.delete(key);
-  probed.delete(key);
-};
-
-export const forgetReported = (key: Key): void => {
-  latest.delete(key);
-  stamps.delete(key);
-  probed.delete(key);
-};
-
 export const forgetUsage = (): void => {
   latest.clear();
   stamps.clear();
   tallies.clear();
   probed.clear();
-  answers.clear();
 };
 
 export function mayProbe(key: Key, now: number, every: number): boolean {
@@ -93,12 +75,6 @@ export function mayProbe(key: Key, now: number, every: number): boolean {
   return true;
 }
 
-export const probeAnswer = (key: Key): Reported | undefined => answers.get(key);
-
-export const keepProbeAnswer = (key: Key, usage: Reported): void => {
-  answers.set(key, usage);
-};
-
 export interface Counted {
   input: number;
   output: number;
@@ -265,47 +241,6 @@ export function codexUsage(headers: Headers, now = new Date()): Reported | null
   return { windows, note: reached === null || reached === '' ? null : reached.replaceAll('_', ' '), at: now.toISOString() };
 }
 
-const present = (w: UsageWindow | null): w is UsageWindow => w !== null;
-
-const textOf = (raw: unknown): string | null => (typeof raw === 'number' || typeof raw === 'string' ? String(raw) : null);
-
-const numberOf = (raw: unknown): number | null => (typeof raw === 'number' && Number.isFinite(raw) ? raw : null);
-
-const CLAUDE_WINDOWS: [string, string][] = [
-  ['five_hour', '5-hour window'],
-  ['seven_day', 'Weekly, all models'],
-  ['seven_day_sonnet', 'Weekly, Sonnet'],
-  ['seven_day_opus', 'Weekly, Opus'],
-];
-
-function percentWindow(label: string, raw: unknown, now: Date): UsageWindow | null {
-  if (!isRecord(raw)) return null;
-  const percent = numberOf(raw.utilization) ?? numberOf(raw.percent);
-  if (percent === null) return null;
-  return { label, used: clamp(percent / 100), resetAt: whenFrom(textOf(raw.resets_at), now), detail: null };
-}
-
-function scopedName(entry: Record<string, unknown>): string {
-  if (stringOf(entry.display_name) !== '') return stringOf(entry.display_name);
-  if (entry.kind !== 'weekly_scoped' || !isRecord(entry.scope) || !isRecord(entry.scope.model)) return '';
-  return stringOf(entry.scope.model.display_name);
-}
-
-function scopedWindows(limits: Record<string, unknown>, now: Date): (UsageWindow | null)[] {
-  const listed = [limits.model_scoped, limits.limits].flatMap((list): unknown[] => (Array.isArray(list) ? (list as unknown[]) : []));
-  return listed.map((entry) => {
-    const name = isRecord(entry) ? scopedName(entry) : '';
-    return name === '' ? null : percentWindow(`Weekly, ${name}`, entry, now);
-  });
-}
-
-export function claudeLoginUsage(limits: unknown, now = new Date()): Reported | null {
-  if (!isRecord(limits)) return null;
-  const all = [...CLAUDE_WINDOWS.map(([key, label]) => percentWindow(label, limits[key], now)), ...scopedWindows(limits, now)].filter(present);
-  const windows = all.filter((w, index) => all.findIndex((other) => other.label === w.label) === index);
-  return windows.length === 0 ? null : { windows, note: null, at: now.toISOString() };
-}
-
 export function noteUsageHeaders(kind: 'anthropic' | 'codex', key: Key, headers: Headers, now = new Date()): void {
   const usage = kind === 'anthropic' ? anthropicUsage(headers, now) : codexUsage(headers, now);
   if (usage === null) return;

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.310"
+  "version": "0.1.0-beta.311"
 }

package/runtime/sdk-runner/node_modules/@metro-labs/core/package.json

@@ -18,6 +18,7 @@
     "./train-error": "./src/train-error.ts",
     "./trains/protocol": "./src/protocol.ts",
     "./ids": "./src/ids.ts",
+    "./claude-token": "./src/claude-token.ts",
     "./tickets": "./src/tickets.ts",
     "./station-names": "./src/station-names.ts",
     "./str": "./src/str.ts",

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/claude-token.ts

@@ -0,0 +1,3 @@
+const TOKEN_RE = /^sk-ant-oat01-[A-Za-z0-9_-]{32,512}$/;
+
+export const isClaudeToken = (value: string): boolean => TOKEN_RE.test(value);

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.310",
+  "version": "0.1.0-beta.311",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",

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

@@ -1,243 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import { spawnSync } from 'node:child_process';
-import { markOnboardingDone } from './onboarding.js';
-import { ApiError } from '@metro-labs/http/api-error';
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg, log } from '@metro-labs/core/log';
-import { agentCommand, asAgent, CLAUDE_ENV, claudeBin } from '../agent-user/user.js';
-
-const LOGIN_ARGS = ['auth', 'login', '--claudeai'];
-const STATUS_COMMAND = ['auth', 'status', '--json'];
-const TTL_MS = 10 * 60_000;
-const OUTPUT_MAX = 8_000;
-const COLS = 100;
-const ROWS = 40;
-const ESC = String.fromCharCode(27);
-const CSI = /^\[[0-9;?]*[a-zA-Z]/;
-const URL_RE = /https:\/\/[^\s"'`]+/g;
-
-type LoginState = 'pending' | 'done' | 'failed';
-
-export interface LoginView {
-  id: string;
-  state: LoginState;
-  url: string | null;
-  output: string;
-  error: string | null;
-}
-
-export interface LoginTarget {
-  key: string;
-  env: Record<string, string>;
-  settle: (ok: boolean) => Promise<string | null>;
-}
-
-interface Live {
-  id: string;
-  startedAt: number;
-  state: LoginState;
-  output: string;
-  error: string | null;
-  target: LoginTarget | null;
-  write: (text: string) => void;
-  kill: () => void;
-}
-
-export interface LoginDeps {
-  command?: string[];
-}
-
-let live: Live | null = null;
-
-export function plainText(raw: string): string {
-  return raw
-    .split(ESC)
-    .map((part, index) => (index === 0 ? part : part.replace(CSI, '')))
-    .join('');
-}
-
-export function loginUrlIn(output: string): string | null {
-  const found = output.match(URL_RE) ?? [];
-  const trimmed = found.map((url) => url.replace(/[.,)]+$/, ''));
-  return trimmed.find((url) => url.includes('claude.ai') || url.includes('anthropic.com')) ?? trimmed[0] ?? null;
-}
-
-const view = (session: Live): LoginView => ({
-  id: session.id,
-  state: session.state,
-  url: loginUrlIn(session.output),
-  output: session.output,
-  error: session.error,
-});
-
-function sweep(now: number): void {
-  if (live !== null && live.state !== 'pending') return;
-  if (live !== null && now - live.startedAt > TTL_MS) {
-    live.kill();
-    live = null;
-  }
-}
-
-const CHECK_MS = 30_000;
-
-interface Checked<T> {
-  at: number;
-  value: T;
-}
-
-const checks: { installed?: Checked<boolean>; account?: Checked<ClaudeAccount> } = {};
-
-function remembered<T>(slot: Checked<T> | undefined, read: () => T, keep: (c: Checked<T>) => void): T {
-  const now = Date.now();
-  if (slot !== undefined && now - slot.at < CHECK_MS) return slot.value;
-  const value = read();
-  keep({ at: now, value });
-  return value;
-}
-
-export function forgetClaudeChecks(): void {
-  delete checks.installed;
-  delete checks.account;
-}
-
-export function claudeInstalled(): boolean {
-  return remembered(checks.installed, () => {
-    const run = spawnSync(...asAgent(claudeBin(), ['--version'], CLAUDE_ENV), { stdio: 'ignore', env: { ...process.env, ...CLAUDE_ENV } });
-    return run.error === undefined && run.status === 0;
-  }, (c) => {
-    checks.installed = c;
-  });
-}
-
-export interface ClaudeAccount {
-  signedIn: boolean;
-  account: string | null;
-  plan: string | null;
-}
-
-const SIGNED_OUT: ClaudeAccount = { signedIn: false, account: null, plan: null };
-
-export function claudeAccount(): ClaudeAccount {
-  return remembered(checks.account, () => claudeAccountIn({}), (c) => {
-    checks.account = c;
-  });
-}
-
-const textOf = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
-
-export function claudeAccountIn(extra: Record<string, string>): ClaudeAccount {
-  const env = { ...CLAUDE_ENV, ...extra };
-  const run = spawnSync(...asAgent(claudeBin(), STATUS_COMMAND, env), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], env: { ...process.env, ...env } });
-  if (run.error !== undefined || typeof run.stdout !== 'string') return SIGNED_OUT;
-  try {
-    const parsed: unknown = JSON.parse(run.stdout);
-    if (!isRecord(parsed)) return SIGNED_OUT;
-    const account = textOf(parsed.email) ?? textOf(parsed.organization) ?? textOf(parsed.orgName);
-    return { signedIn: parsed.authenticated === true || parsed.loggedIn === true || account !== null, account, plan: textOf(parsed.subscriptionType) };
-  } catch {
-    return SIGNED_OUT;
-  }
-}
-
-function note(session: Live, chunk: string): void {
-  const next = session.output + plainText(chunk);
-  session.output = next.length > OUTPUT_MAX ? next.slice(next.length - OUTPUT_MAX) : next;
-}
-
-async function verdict(session: Live, code: number): Promise<string | null> {
-  const problem = code === 0 ? null : `the login ended with status ${String(code)}`;
-  if (session.target === null) return problem;
-  try {
-    return (await session.target.settle(problem === null)) ?? problem;
-  } catch (err) {
-    return errMsg(err);
-  }
-}
-
-function runningFor(target: LoginTarget | null): Live | null {
-  if (live === null || live.state !== 'pending') return null;
-  if (live.target?.key === target?.key) return live;
-  live.kill();
-  live = null;
-  return null;
-}
-
-export function startClaudeLogin(deps: LoginDeps = {}, now = Date.now(), target: LoginTarget | null = null): LoginView {
-  sweep(now);
-  const running = runningFor(target);
-  if (running !== null) return view(running);
-  const env = { TERM: 'xterm-256color', ...CLAUDE_ENV, ...target?.env };
-  const command = deps.command ?? agentCommand([claudeBin(), ...LOGIN_ARGS], env);
-  const session: Live = {
-    id: randomBytes(9).toString('base64url'),
-    startedAt: now,
-    state: 'pending',
-    output: '',
-    error: null,
-    target,
-    write: () => undefined,
-    kill: () => undefined,
-  };
-  const terminal = new Bun.Terminal({
-    cols: COLS,
-    rows: ROWS,
-    data: (_term, chunk: Uint8Array) => {
-      note(session, Buffer.from(chunk).toString('utf8'));
-    },
-  });
-  const proc = Bun.spawn(command, { terminal, env: { ...process.env, ...env } });
-  session.write = (text: string) => {
-    terminal.write(Buffer.from(`${text}\r`, 'utf8'));
-  };
-  session.kill = () => {
-    proc.kill();
-    terminal.close();
-  };
-  proc.exited
-    .then(async (code) => {
-      session.write = () => undefined;
-      terminal.close();
-      forgetClaudeChecks();
-      session.error = await verdict(session, code);
-      session.state = session.error === null ? 'done' : 'failed';
-      const onboarding = session.error === null ? markOnboardingDone() : 'skipped';
-      log.info({ state: session.state, onboarding, own: session.target !== null }, 'claude-login: the official login finished');
-    })
-    .catch((err: unknown) => {
-      session.state = 'failed';
-      session.error = errMsg(err);
-    });
-  live = session;
-  log.info({ command: command[0] }, 'claude-login: started');
-  return view(session);
-}
-
-function current(id: string): Live {
-  const session = live;
-  if (session?.id !== id) throw new ApiError('that sign-in is over; start another one', 404);
-  return session;
-}
-
-export function claudeLoginView(id: string, now = Date.now()): LoginView {
-  sweep(now);
-  return view(current(id));
-}
-
-export function answerClaudeLogin(id: string, text: string): LoginView {
-  const session = current(id);
-  if (session.state !== 'pending') throw new ApiError('that sign-in has already finished', 409);
-  session.write(text);
-  return view(session);
-}
-
-export function endClaudeLogin(id: string): { ended: true } {
-  const session = current(id);
-  session.kill();
-  live = null;
-  return { ended: true };
-}
-
-export const forgetClaudeLogin = (): void => {
-  live?.kill();
-  live = null;
-};