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

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;
-};

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

@@ -1,38 +0,0 @@
-import { existsSync, readFileSync } from '../agent-user/agent-fs.js';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { isRecord } from '@metro-labs/core/is-record';
-import { writeHomeText } from '../agent-user/home-fs.js';
-import { agentUser } from '../agent-user/user.js';
-
-const FILE = '.claude.json';
-const FLAG = 'hasCompletedOnboarding';
-
-export type OnboardingMark = 'marked' | 'already' | 'unreadable';
-
-const given = (value: string | undefined): string | undefined =>
-  value !== undefined && value.trim() !== '' ? value.trim() : undefined;
-
-export function claudeConfigPath(env: NodeJS.ProcessEnv = process.env): string {
-  const user = agentUser();
-  if (user !== null) return join(user.home, FILE);
-  return join(given(env.CLAUDE_CONFIG_DIR) ?? given(env.HOME) ?? homedir(), FILE);
-}
-
-function readConfig(path: string): Record<string, unknown> | null {
-  if (!existsSync(path)) return {};
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
-    return isRecord(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-export function markOnboardingDone(path = claudeConfigPath()): OnboardingMark {
-  const config = readConfig(path);
-  if (config === null) return 'unreadable';
-  if (config[FLAG] === true) return 'already';
-  writeHomeText(path, `${JSON.stringify({ ...config, [FLAG]: true }, null, 2)}\n`, 0o600);
-  return 'marked';
-}

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

@@ -1,128 +0,0 @@
-import { spawn } from 'node:child_process';
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg, log } from '@metro-labs/core/log';
-import { agentCommand, agentUser, agentUserExpected, CLAUDE_ENV, claudeBin } from '../agent-user/user.js';
-import { runningAsRoot } from '../metro-user/privilege.js';
-import { PRIVACY_ENV } from './setup.js';
-
-const REQUEST_ID = 'metro-usage';
-const REQUEST = `${JSON.stringify({ type: 'control_request', request_id: REQUEST_ID, request: { subtype: 'get_usage', skip_behaviors: true } })}\n`;
-const ARGS = [
-  '-p',
-  '--setting-sources',
-  'project',
-  '--strict-mcp-config',
-  '--mcp-config',
-  '{"mcpServers":{}}',
-  '--no-session-persistence',
-  '--input-format',
-  'stream-json',
-  '--output-format',
-  'stream-json',
-  '--verbose',
-];
-const BLOCKS_USAGE = 'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC';
-const PROBE_ENV: Record<string, string> = {
-  ...Object.fromEntries(Object.entries(PRIVACY_ENV).filter(([name]) => name !== BLOCKS_USAGE)),
-  ...CLAUDE_ENV,
-  DISABLE_BUG_COMMAND: '1',
-  ENABLE_CLAUDEAI_MCP_SERVERS: 'false',
-};
-const TIMEOUT_MS = 20_000;
-const KILL_GRACE_MS = 2_000;
-const LINE_MAX = 1024 * 1024;
-
-export interface UsageProbeDeps {
-  command?: string[];
-  timeoutMs?: number;
-  env?: Record<string, string>;
-}
-
-export function usageProbeCommand(env: Record<string, string> = {}): string[] | null {
-  if (runningAsRoot() || (agentUserExpected() && agentUser() === null)) return null;
-  return agentCommand([claudeBin(), ...ARGS], { ...PROBE_ENV, ...env });
-}
-
-function answerOf(line: string): Record<string, unknown> | null {
-  try {
-    const parsed: unknown = JSON.parse(line);
-    if (!isRecord(parsed) || parsed.type !== 'control_response' || !isRecord(parsed.response)) return null;
-    return parsed.response.request_id === REQUEST_ID ? parsed.response : null;
-  } catch {
-    return null;
-  }
-}
-
-function limitsOf(answer: Record<string, unknown>): unknown {
-  if (answer.subtype !== 'success') throw new Error(`Claude Code refused the usage request: ${typeof answer.error === 'string' ? answer.error : 'no reason given'}`);
-  return isRecord(answer.response) ? (answer.response.rate_limits ?? null) : null;
-}
-
-export function usageIn(output: string): unknown {
-  const answer = output
-    .split('\n')
-    .map(answerOf)
-    .find((found) => found !== null);
-  if (answer === undefined || answer === null) throw new Error('Claude Code gave no usage answer');
-  return limitsOf(answer);
-}
-
-export function readClaudeUsage(deps: UsageProbeDeps = {}): Promise<unknown> {
-  const command = deps.command ?? usageProbeCommand(deps.env);
-  if (command === null) return Promise.reject(new Error('Claude Code runs only as the agent user, and this box has none'));
-  const [file = '', ...args] = command;
-  return new Promise((resolve, reject) => {
-    const child = spawn(file, args, { cwd: '/', stdio: ['pipe', 'pipe', 'ignore'], env: { ...process.env, ...PROBE_ENV, ...deps.env } });
-    let carry = '';
-    let settled = false;
-    let hardKill: ReturnType<typeof setTimeout> | undefined;
-    const settle = (run: () => void): void => {
-      if (settled) return;
-      settled = true;
-      run();
-    };
-    const overdue = setTimeout(() => {
-      settle(() => {
-        reject(new Error('Claude Code did not report the usage in time'));
-      });
-      child.stdout.destroy();
-      child.kill('SIGTERM');
-      hardKill = setTimeout(() => child.kill('SIGKILL'), KILL_GRACE_MS);
-    }, deps.timeoutMs ?? TIMEOUT_MS);
-    const take = (line: string): void => {
-      const answer = answerOf(line);
-      if (answer === null) return;
-      settle(() => {
-        try {
-          resolve(limitsOf(answer));
-        } catch (err) {
-          reject(err instanceof Error ? err : new Error(errMsg(err)));
-        }
-      });
-    };
-    child.stdout.on('data', (chunk: Buffer) => {
-      const lines = (carry + chunk.toString('utf8')).split('\n');
-      carry = lines.pop() ?? '';
-      if (carry.length > LINE_MAX) carry = '';
-      lines.forEach(take);
-    });
-    child.stdin.on('error', (err) => {
-      log.debug({ err: errMsg(err) }, 'claude-usage: Claude Code closed its input early');
-    });
-    child.on('error', (err) => {
-      clearTimeout(overdue);
-      settle(() => {
-        reject(err);
-      });
-    });
-    child.on('close', () => {
-      clearTimeout(overdue);
-      clearTimeout(hardKill);
-      take(carry);
-      settle(() => {
-        reject(new Error('Claude Code gave no usage answer'));
-      });
-    });
-    child.stdin.end(REQUEST);
-  });
-}

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

@@ -1,192 +0,0 @@
-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 { moveHome, 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 { forgetOne, forgetReported } from './usage.js';
-import { readClaudeLogins, writeClaudeLogins, type ClaudeLogin } from './claude-store.js';
-import { loginRef } 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;
-  dir?: string;
-}
-
-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),
-  );
-}
-
-const folderOf = (login: string, deps: ClaudeLoginDeps): string => claudeLoginEnv(login, deps).CLAUDE_CONFIG_DIR ?? '';
-
-function forgetTokens(login: string): void {
-  seen.delete(login);
-  state.delete(login);
-}
-
-function dropFolder(login: string, deps: ClaudeLoginDeps): void {
-  forgetTokens(login);
-  try {
-    removeHome(folderOf(login, deps), true);
-  } catch (err) {
-    log.warn({ err: errMsg(err) }, 'claude-logins: could not remove the folder of a Claude login that is no longer used');
-  }
-}
-
-export function removeClaudeLogin(login: string, deps: ClaudeLoginDeps = {}): void {
-  const logins = readClaudeLogins(deps.dir);
-  if (!logins.some((l) => l.id === login)) throw new ApiError('no such Claude login on this box', 404);
-  writeClaudeLogins(logins.filter((l) => l.id !== login), deps.dir);
-  dropFolder(login, deps);
-  forgetOne(loginRef(login));
-  log.info({ login }, 'claude-logins: a Claude login was removed from this box');
-}
-
-function takeOver(fresh: string, replaced: string, deps: ClaudeLoginDeps): void {
-  const aside = `${folderOf(replaced, deps)}.old-${newId()}`;
-  moveHome(folderOf(replaced, deps), aside);
-  try {
-    moveHome(folderOf(fresh, deps), folderOf(replaced, deps));
-  } catch (err) {
-    moveHome(aside, folderOf(replaced, deps));
-    throw err;
-  }
-  forgetTokens(replaced);
-  try {
-    removeHome(aside, true);
-  } catch (err) {
-    log.warn({ err: errMsg(err) }, 'claude-logins: could not remove the folder of the login that was signed in again');
-  }
-}
-
-function keep(login: string, replacing: string | null, account: ClaudeAccount, deps: ClaudeLoginDeps): string | null {
-  const logins = readClaudeLogins(deps.dir);
-  if (replacing !== null && !logins.some((l) => l.id === replacing)) return 'that Claude login was removed during the sign-in';
-  if (replacing !== null) takeOver(login, replacing, deps);
-  const entry: ClaudeLogin = { id: replacing ?? login, email: account.account, plan: account.plan, savedAt: new Date().toISOString() };
-  writeClaudeLogins(replacing === null ? [...logins, entry] : logins.map((l) => (l.id === replacing ? entry : l)), deps.dir);
-  forgetReported(loginRef(entry.id));
-  log.info({ login: entry.id, plan: account.plan, added: replacing === null }, 'claude-logins: the Claude login was kept on this box');
-  return null;
-}
-
-function settle(ok: boolean, login: string, replacing: string | null, deps: ClaudeLoginDeps): Promise<string | null> {
-  if (!ok) {
-    dropFolder(login, deps);
-    return Promise.resolve(null);
-  }
-  let problem: string | null;
-  try {
-    const account = (deps.account ?? claudeAccountIn)(claudeLoginEnv(login, deps));
-    problem = account.signedIn ? keep(login, replacing, account, deps) : 'the sign-in finished but Claude Code holds no login; try again';
-  } catch (err) {
-    problem = errMsg(err);
-  }
-  if (problem !== null) dropFolder(login, deps);
-  return Promise.resolve(problem);
-}
-
-export function claudeLoginTarget(asked: string, deps: ClaudeLoginDeps = {}): LoginTarget {
-  const replacing = asked === NEW ? null : asked;
-  if (replacing !== null && !readClaudeLogins(deps.dir).some((l) => l.id === replacing)) throw new ApiError('no such Claude login on this box', 404);
-  const login = newId();
-  return { key: asked, env: claudeLoginEnv(login, deps), settle: (ok) => settle(ok, login, replacing, deps) };
-}
-
-export function forgetClaudeTokens(): void {
-  seen.clear();
-  state.clear();
-}

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

@@ -1,59 +0,0 @@
-import { join } from 'node:path';
-import { ID_RE } from '@metro-labs/core/ids';
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg, log } from '@metro-labs/core/log';
-import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
-import { agentsDir } from '../agents/files.js';
-
-export interface ClaudeLogin {
-  id: string;
-  email: string | null;
-  plan: string | null;
-  savedAt: string;
-}
-
-const MODEL_FILE = 'model.json';
-
-const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
-const maybe = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
-
-function claudeLoginOf(raw: unknown): ClaudeLogin | null {
-  if (!isRecord(raw) || !ID_RE.test(text(raw.id))) return null;
-  return { id: text(raw.id), email: maybe(raw.email), plan: maybe(raw.plan), savedAt: text(raw.savedAt) };
-}
-
-const modelPath = (dir: string): string => join(dir, MODEL_FILE);
-
-const readModelFile = (dir: string): unknown =>
-  readJson<unknown>(modelPath(dir), null, { warn: 'model.json is unreadable, so the Claude logins of this box are not seen until it is fixed' });
-
-const isV2 = (raw: unknown): raw is Record<string, unknown> & { connections: unknown[] } =>
-  isRecord(raw) && raw.version !== 3 && Array.isArray(raw.connections);
-
-const unique = (logins: ClaudeLogin[]): ClaudeLogin[] => logins.filter((l, at) => logins.findIndex((o) => o.id === l.id) === at);
-
-function claudeLoginsIn(raw: unknown): ClaudeLogin[] {
-  if (isV2(raw)) return unique(raw.connections.flatMap((c: unknown) => (isRecord(c) && c.provider === 'anthropic' ? (claudeLoginOf(c.claude) ?? []) : [])));
-  if (!isRecord(raw) || !Array.isArray(raw.claude)) return [];
-  return unique(raw.claude.flatMap((c: unknown) => claudeLoginOf(c) ?? []));
-}
-
-export const readClaudeLogins = (dir = agentsDir()): ClaudeLogin[] => claudeLoginsIn(readModelFile(dir));
-
-export function writeClaudeLogins(logins: ClaudeLogin[], dir = agentsDir()): void {
-  writeSecure(modelPath(dir), JSON.stringify({ version: 3, claude: logins }, null, 2));
-}
-
-export function retireV2ModelFile(dir = agentsDir()): boolean {
-  try {
-    const raw = readModelFile(dir);
-    if (!isV2(raw)) return false;
-    const logins = claudeLoginsIn(raw);
-    writeClaudeLogins(logins, dir);
-    log.warn({ claudeLogins: logins.length, connections: raw.connections.length }, 'org-models: model.json was still the old version 2; it keeps only its Claude logins now, and its connections are never served');
-    return true;
-  } catch (err) {
-    log.warn({ err: errMsg(err) }, 'org-models: the old version 2 model.json could not be rewritten; its connections are never served');
-    return false;
-  }
-}