X056 Max-Account Failover v1 Implementation Plan

package.json, tsconfig.json          Task 1 (scaffold)
src/types.ts                         Task 1  raw + verdict types
src/detector.ts                      Task 1  classifyEvent (pure)
src/eventlog.ts                      Task 2  append-only jsonl
src/accounts.ts                      Task 2  AccountRegistry (accounts.json)
src/quota.ts                         Task 3  fetchUsage via /api/oauth/usage
src/turn.ts                          Task 4  startTurn: spawn + NDJSON parse + kill/interrupt
src/fake-claude.ts                   Task 5  scenario replay binary
src/failover.ts                      Task 6  runSession state machine
src/cli.ts                           Task 7  x056 run/continue/status/switch
test/*.test.ts                       per task
test/bin/fake-claude                 Task 5  exec wrapper
scripts/setup-accounts.sh            Task 8  post-login verification + symlink
scripts/drill-forced-switch.md       Task 8  live drill procedure

{
  "name": "x056-remote-control",
  "version": "0.1.0",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "vitest run",
    "typecheck": "tsc --noEmit",
    "x056": "tsx src/cli.ts"
  },
  "devDependencies": {
    "@types/node": "^20.14.0",
    "tsx": "^4.16.0",
    "typescript": "^5.5.0",
    "vitest": "^2.0.0"
  }
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "noEmit": true,
    "skipLibCheck": true,
    "types": ["node"]
  },
  "include": ["src", "test"]
}

node_modules/
state/
dist/

import { describe, expect, it } from 'vitest';
import { classifyEvent } from '../src/detector.js';

const rateLimitAllowed = {
  type: 'rate_limit_event',
  rate_limit_info: {
    status: 'allowed', resetsAt: 1783170000, rateLimitType: 'five_hour',
    overageStatus: 'rejected', overageDisabledReason: 'org_level_disabled', isUsingOverage: false,
  },
};

const syntheticLimitEntry = {
  parentUuid: 'bdceb5bc', type: 'assistant',
  message: { model: '<synthetic>', role: 'assistant', content: [{ type: 'text', text: "You've hit your session limit · resets 8:20pm (Asia/Jakarta)" }] },
  error: 'rate_limit', isApiErrorMessage: true, apiErrorStatus: 429,
};

describe('classifyEvent', () => {
  it('passes through an allowed rate_limit_event as ok', () => {
    expect(classifyEvent(rateLimitAllowed)).toEqual({ kind: 'ok', source: 'rate_limit_event' });
  });

  it('flags rejected rate_limit_event as limited with resetsAt', () => {
    const e = { ...rateLimitAllowed, rate_limit_info: { ...rateLimitAllowed.rate_limit_info, status: 'rejected' } };
    expect(classifyEvent(e)).toEqual({ kind: 'limited', resetsAt: 1783170000, source: 'rate_limit_event' });
  });

  it('flags allowed_warning as warning', () => {
    const e = { ...rateLimitAllowed, rate_limit_info: { ...rateLimitAllowed.rate_limit_info, status: 'allowed_warning' } };
    expect(classifyEvent(e)).toEqual({ kind: 'warning', resetsAt: 1783170000, source: 'rate_limit_event' });
  });

  it('flags api_retry with rate_limit as limited (kill-on-first-signal, D3)', () => {
    const e = { type: 'system', subtype: 'api_retry', attempt: 1, max_retries: 10, retry_delay_ms: 1000, error_status: 429, error: 'rate_limit' };
    expect(classifyEvent(e)).toEqual({ kind: 'limited', source: 'api_retry' });
  });

  it('treats api_retry for overloaded as transient (F8)', () => {
    const e = { type: 'system', subtype: 'api_retry', attempt: 2, max_retries: 10, retry_delay_ms: 4000, error_status: 529, error: 'overloaded' };
    expect(classifyEvent(e)).toEqual({ kind: 'transient', source: 'api_retry' });
  });

  it('flags result with api_error_status 429 as limited', () => {
    const e = { type: 'result', subtype: 'success', is_error: true, api_error_status: 429 };
    expect(classifyEvent(e)).toEqual({ kind: 'limited', source: 'result' });
  });

  it('flags the synthetic transcript limit entry as limited', () => {
    expect(classifyEvent(syntheticLimitEntry)).toEqual({ kind: 'limited', source: 'synthetic_message' });
  });

  it('ignores ordinary events', () => {
    expect(classifyEvent({ type: 'assistant', message: { content: [{ type: 'text', text: 'hi' }] } }).kind).toBe('irrelevant');
    expect(classifyEvent({ type: 'result', subtype: 'success', is_error: false, api_error_status: null }).kind).toBe('irrelevant');
  });
});

export type RawEvent = Record<string, unknown>;

export interface Verdict {
  kind: 'limited' | 'transient' | 'warning' | 'ok' | 'irrelevant';
  resetsAt?: number; // unix seconds when known
  source: string;
}

import type { RawEvent, Verdict } from './types.js';

interface RateLimitInfo {
  status?: string;
  resetsAt?: number;
}

export function classifyEvent(e: RawEvent): Verdict {
  if (e.type === 'rate_limit_event') {
    const info = (e.rate_limit_info ?? {}) as RateLimitInfo;
    if (info.status === 'rejected') return { kind: 'limited', resetsAt: info.resetsAt, source: 'rate_limit_event' };
    if (info.status === 'allowed_warning') return { kind: 'warning', resetsAt: info.resetsAt, source: 'rate_limit_event' };
    return { kind: 'ok', source: 'rate_limit_event' };
  }
  if (e.type === 'system' && e.subtype === 'api_retry') {
    if (e.error === 'rate_limit' || e.error_status === 429) return { kind: 'limited', source: 'api_retry' };
    return { kind: 'transient', source: 'api_retry' };
  }
  if (e.type === 'result' && e.api_error_status === 429) return { kind: 'limited', source: 'result' };
  if (e.error === 'rate_limit') return { kind: 'limited', source: 'synthetic_message' };
  return { kind: 'irrelevant', source: 'none' };
}

git add package.json package-lock.json tsconfig.json .gitignore src/types.ts src/detector.ts test/detector.test.ts
git commit -m "feat: scaffold package and add limit detector with real-capture fixtures"

import { mkdtempSync, readFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { describe, expect, it } from 'vitest';
import { AccountRegistry } from '../src/accounts.js';
import { EventLog } from '../src/eventlog.js';

function freshFile(): string {
  return join(mkdtempSync(join(tmpdir(), 'x056-')), 'accounts.json');
}

describe('AccountRegistry', () => {
  const specs = [
    { name: 'a', configDir: '/home/efran/.claude-x056-a' },
    { name: 'b', configDir: '/home/efran/.claude-x056-b' },
  ];

  it('init + load round-trips and picks the active account', () => {
    const file = freshFile();
    AccountRegistry.init(file, specs);
    const reg = AccountRegistry.load(file);
    expect(reg.pickActive(1000)?.name).toBe('a');
  });

  it('markLimited fails over pickActive to the other account and persists', () => {
    const file = freshFile();
    const reg = AccountRegistry.init(file, specs);
    reg.markLimited('a', 5000);
    expect(reg.pickActive(1000)?.name).toBe('b');
    const reloaded = AccountRegistry.load(file);
    expect(reloaded.get('a').state).toEqual({ kind: 'limited', until: 5000 });
  });

  it('a limited account becomes usable again after its reset time', () => {
    const file = freshFile();
    const reg = AccountRegistry.init(file, specs);
    reg.markLimited('a', 5000);
    reg.setActive('a');
    expect(reg.pickActive(6000)?.name).toBe('a');
  });

  it('returns null and earliestReset when both accounts are limited', () => {
    const file = freshFile();
    const reg = AccountRegistry.init(file, specs);
    reg.markLimited('a', 5000);
    reg.markLimited('b', 3000);
    expect(reg.pickActive(1000)).toBeNull();
    expect(reg.earliestReset()).toBe(3000);
  });

  it('load without file throws a setup hint', () => {
    expect(() => AccountRegistry.load(freshFile())).toThrow(/setup/i);
  });
});

describe('EventLog', () => {
  it('appends timestamped jsonl lines and reads them back', () => {
    const file = join(mkdtempSync(join(tmpdir(), 'x056-')), 'nested', 'events.jsonl');
    const log = new EventLog(file);
    log.append({ type: 'failover', from: 'a' });
    log.append({ type: 'parked' });
    const rows = log.read();
    expect(rows).toHaveLength(2);
    expect(rows[0].type).toBe('failover');
    expect(typeof rows[0].ts).toBe('string');
    expect(readFileSync(file, 'utf8').trim().split('\n')).toHaveLength(2);
  });
});

import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
import { dirname } from 'node:path';

export class EventLog {
  constructor(private readonly file: string) {}

  append(event: Record<string, unknown>): void {
    mkdirSync(dirname(this.file), { recursive: true });
    appendFileSync(this.file, `${JSON.stringify({ ts: new Date().toISOString(), ...event })}\n`);
  }

  read(): Record<string, unknown>[] {
    if (!existsSync(this.file)) return [];
    return readFileSync(this.file, 'utf8')
      .split('\n')
      .filter((l) => l.trim() !== '')
      .map((l) => JSON.parse(l) as Record<string, unknown>);
  }
}

import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
import { dirname } from 'node:path';

export type AccountState = { kind: 'unknown' } | { kind: 'ok' } | { kind: 'limited'; until: number };

export interface Account {
  name: string;
  configDir: string;
  state: AccountState;
}

interface RegistryFile {
  active: string;
  accounts: Account[];
}

export class AccountRegistry {
  private constructor(
    private readonly file: string,
    private data: RegistryFile,
  ) {}

  static init(file: string, specs: { name: string; configDir: string }[]): AccountRegistry {
    const data: RegistryFile = {
      active: specs[0].name,
      accounts: specs.map((s) => ({ ...s, state: { kind: 'unknown' } })),
    };
    const reg = new AccountRegistry(file, data);
    reg.save();
    return reg;
  }

  static load(file: string): AccountRegistry {
    if (!existsSync(file)) {
      throw new Error(`${file} not found — run the setup step (scripts/setup-accounts.sh) first.`);
    }
    return new AccountRegistry(file, JSON.parse(readFileSync(file, 'utf8')) as RegistryFile);
  }

  list(): Account[] {
    return this.data.accounts;
  }

  get(name: string): Account {
    const acct = this.data.accounts.find((a) => a.name === name);
    if (!acct) throw new Error(`unknown account: ${name}`);
    return acct;
  }

  private usable(a: Account, now: number): boolean {
    return a.state.kind !== 'limited' || a.state.until <= now;
  }

  pickActive(now: number): Account | null {
    const preferred = this.get(this.data.active);
    if (this.usable(preferred, now)) return preferred;
    const other = this.data.accounts.find((a) => a.name !== preferred.name && this.usable(a, now));
    if (other) {
      this.data.active = other.name;
      this.save();
      return other;
    }
    return null;
  }

  setActive(name: string): void {
    this.get(name);
    this.data.active = name;
    this.save();
  }

  markLimited(name: string, until: number): void {
    this.get(name).state = { kind: 'limited', until };
    this.save();
  }

  markOk(name: string): void {
    this.get(name).state = { kind: 'ok' };
    this.save();
  }

  earliestReset(): number {
    const untils = this.data.accounts
      .map((a) => a.state)
      .filter((s): s is { kind: 'limited'; until: number } => s.kind === 'limited')
      .map((s) => s.until);
    return Math.min(...untils);
  }

  private save(): void {
    mkdirSync(dirname(this.file), { recursive: true });
    const tmp = `${this.file}.tmp`;
    writeFileSync(tmp, JSON.stringify(this.data, null, 2));
    renameSync(tmp, this.file);
  }
}

git add src/eventlog.ts src/accounts.ts test/accounts.test.ts
git commit -m "feat: add event log and account registry with limited-state failover pick"

import { mkdtempSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { describe, expect, it } from 'vitest';
import { TokenExpiredError, fetchUsage } from '../src/quota.js';

function configDirWithToken(token: string): string {
  const dir = mkdtempSync(join(tmpdir(), 'x056-cfg-'));
  writeFileSync(join(dir, '.credentials.json'), JSON.stringify({ claudeAiOauth: { accessToken: token } }));
  return dir;
}

const usageBody = {
  five_hour: { utilization: 62.0, resets_at: '2026-07-04T12:59:59.677980+00:00' },
  seven_day: { utilization: 48.0, resets_at: '2026-07-07T21:00:00.678002+00:00' },
};

describe('fetchUsage', () => {
  it('calls the oauth usage endpoint with the bearer token and maps windows', async () => {
    const dir = configDirWithToken('tok-123');
    let seenUrl = '';
    let seenAuth = '';
    const fakeFetch = (async (url: unknown, init?: RequestInit) => {
      seenUrl = String(url);
      seenAuth = String((init?.headers as Record<string, string>).Authorization);
      return new Response(JSON.stringify(usageBody), { status: 200 });
    }) as typeof fetch;

    const usage = await fetchUsage(dir, fakeFetch);
    expect(seenUrl).toBe('https://api.anthropic.com/api/oauth/usage');
    expect(seenAuth).toBe('Bearer tok-123');
    expect(usage).toEqual({
      fiveHour: { utilization: 62.0, resetsAt: '2026-07-04T12:59:59.677980+00:00' },
      sevenDay: { utilization: 48.0, resetsAt: '2026-07-07T21:00:00.678002+00:00' },
    });
  });

  it('throws TokenExpiredError on 401', async () => {
    const dir = configDirWithToken('stale');
    const fakeFetch = (async () => new Response('unauthorized', { status: 401 })) as typeof fetch;
    await expect(fetchUsage(dir, fakeFetch)).rejects.toBeInstanceOf(TokenExpiredError);
  });

  it('throws a plain error on other failures, without the token in the message', async () => {
    const dir = configDirWithToken('sekret');
    const fakeFetch = (async () => new Response('boom', { status: 500 })) as typeof fetch;
    await expect(fetchUsage(dir, fakeFetch)).rejects.toThrow(/500/);
    await expect(fetchUsage(dir, fakeFetch)).rejects.not.toThrow(/sekret/);
  });
});

import { readFileSync } from 'node:fs';
import { join } from 'node:path';

export interface WindowUsage {
  utilization: number;
  resetsAt: string;
}

export interface Usage {
  fiveHour: WindowUsage;
  sevenDay: WindowUsage;
}

export class TokenExpiredError extends Error {
  constructor() {
    super('OAuth access token expired (401 from usage endpoint)');
  }
}

interface UsageBody {
  five_hour: { utilization: number; resets_at: string };
  seven_day: { utilization: number; resets_at: string };
}

export async function fetchUsage(configDir: string, fetchFn: typeof fetch = fetch): Promise<Usage> {
  const creds = JSON.parse(readFileSync(join(configDir, '.credentials.json'), 'utf8')) as {
    claudeAiOauth?: { accessToken?: string };
  };
  const token = creds.claudeAiOauth?.accessToken;
  if (!token) throw new Error(`no OAuth token in ${configDir}/.credentials.json`);

  const res = await fetchFn('https://api.anthropic.com/api/oauth/usage', {
    headers: {
      Authorization: `Bearer ${token}`,
      'anthropic-beta': 'oauth-2025-04-20',
      'Content-Type': 'application/json',
    },
  });
  if (res.status === 401) throw new TokenExpiredError();
  if (!res.ok) throw new Error(`usage endpoint returned ${res.status}`);
  const body = (await res.json()) as UsageBody;
  return {
    fiveHour: { utilization: body.five_hour.utilization, resetsAt: body.five_hour.resets_at },
    sevenDay: { utilization: body.seven_day.utilization, resetsAt: body.seven_day.resets_at },
  };
}

git add src/quota.ts test/quota.test.ts
git commit -m "feat: add per-account quota fetch via oauth usage endpoint"

#!/usr/bin/env node
// Emits canned NDJSON to exercise startTurn: echoes its argv and config dir
// as events so the test can assert flag construction, then idles 10s so
// kill() is observable. "FAST" in the prompt exits immediately instead.
const args = process.argv.slice(2);
const emit = (o) => process.stdout.write(JSON.stringify(o) + '\n');
emit({ type: 'system', subtype: 'init', argv: args, config_dir: process.env.CLAUDE_CONFIG_DIR });
process.stdout.write('this line is not json\n');
emit({ type: 'assistant', message: { content: [{ type: 'text', text: 'working' }] } });
if (args[args.length - 1].includes('FAST')) {
  emit({ type: 'result', subtype: 'success', is_error: false, api_error_status: null, result: 'done' });
  process.exit(0);
}
setTimeout(() => process.exit(0), 10000);

import { describe, expect, it } from 'vitest';
import { startTurn } from '../src/turn.js';
import type { RawEvent } from '../src/types.js';

const STUB = new URL('./bin/stub-claude', import.meta.url).pathname;

function collect(): { events: RawEvent[]; onEvent: (e: RawEvent) => void } {
  const events: RawEvent[] = [];
  return { events, onEvent: (e) => events.push(e) };
}

describe('startTurn', () => {
  it('builds new-session args, passes CLAUDE_CONFIG_DIR, parses NDJSON, skips junk lines', async () => {
    const { events, onEvent } = collect();
    const h = startTurn({
      claudePath: STUB, configDir: '/tmp/cfg-a', cwd: process.cwd(),
      sessionId: 'sid-1', mode: 'new', prompt: 'FAST task', onEvent,
    });
    const exit = await h.done;
    expect(exit.code).toBe(0);
    const init = events[0] as { argv: string[]; config_dir: string };
    expect(init.config_dir).toBe('/tmp/cfg-a');
    expect(init.argv).toEqual([
      '-p', '--output-format', 'stream-json', '--verbose', '--dangerously-skip-permissions',
      '--session-id', 'sid-1', 'FAST task',
    ]);
    expect(events.map((e) => e.type)).toEqual(['system', 'assistant', 'result']);
  });

  it('builds resume args', async () => {
    const { events, onEvent } = collect();
    const h = startTurn({
      claudePath: STUB, configDir: '/tmp/cfg-b', cwd: process.cwd(),
      sessionId: 'sid-2', mode: 'resume', prompt: 'FAST continue', onEvent,
    });
    await h.done;
    const init = events[0] as { argv: string[] };
    expect(init.argv).toContain('--resume');
    expect(init.argv).toContain('sid-2');
    expect(init.argv).not.toContain('--session-id');
  });

  it('kill() terminates a hanging turn with SIGKILL', async () => {
    const { events, onEvent } = collect();
    const h = startTurn({
      claudePath: STUB, configDir: '/tmp/cfg-a', cwd: process.cwd(),
      sessionId: 'sid-3', mode: 'new', prompt: 'slow task', onEvent,
    });
    // wait until the stub has emitted, then kill mid-"turn"
    await new Promise((r) => setTimeout(r, 300));
    h.kill();
    const exit = await h.done;
    expect(exit.signal).toBe('SIGKILL');
    expect(events.length).toBeGreaterThan(0);
  }, 10000);
});

import { spawn } from 'node:child_process';
import { createInterface } from 'node:readline';
import type { RawEvent } from './types.js';

export interface TurnExit {
  code: number | null;
  signal: NodeJS.Signals | null;
}

export interface TurnHandle {
  kill(): void;
  interrupt(): void;
  done: Promise<TurnExit>;
}

export interface TurnOptions {
  claudePath?: string;
  configDir: string;
  cwd: string;
  sessionId: string;
  mode: 'new' | 'resume';
  prompt: string;
  onEvent: (e: RawEvent) => void;
}

export function startTurn(opts: TurnOptions): TurnHandle {
  const args = [
    '-p',
    '--output-format', 'stream-json',
    '--verbose',
    '--dangerously-skip-permissions',
    ...(opts.mode === 'new' ? ['--session-id', opts.sessionId] : ['--resume', opts.sessionId]),
    opts.prompt,
  ];
  const child = spawn(opts.claudePath ?? 'claude', args, {
    cwd: opts.cwd,
    env: { ...process.env, CLAUDE_CONFIG_DIR: opts.configDir },
    stdio: ['ignore', 'pipe', 'inherit'],
  });

  const rl = createInterface({ input: child.stdout });
  rl.on('line', (line) => {
    if (!line.trim().startsWith('{')) return;
    try {
      opts.onEvent(JSON.parse(line) as RawEvent);
    } catch {
      // partial/garbled line — ignore
    }
  });

  const done = new Promise<TurnExit>((resolve) => {
    child.on('close', (code, signal) => resolve({ code, signal }));
  });

  return {
    kill: () => child.kill('SIGKILL'),
    interrupt: () => child.kill('SIGINT'),
    done,
  };
}

git add src/turn.ts test/turn.test.ts test/bin/stub-claude
git commit -m "feat: add turn runner spawning claude -p with ndjson event parsing"

import { execFileSync } from 'node:child_process';
import { mkdtempSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { describe, expect, it } from 'vitest';

const BIN = new URL('./bin/fake-claude', import.meta.url).pathname;

describe('fake-claude', () => {
  it('replays a scenario file as NDJSON and exits', () => {
    const dir = mkdtempSync(join(tmpdir(), 'x056-fake-'));
    const scenario = join(dir, 's.jsonl');
    writeFileSync(
      scenario,
      [
        JSON.stringify({ event: { type: 'system', subtype: 'init', session_id: 's1' } }),
        JSON.stringify({ delayMs: 10 }),
        JSON.stringify({ event: { type: 'result', subtype: 'success', is_error: false, result: 'ok' } }),
        JSON.stringify({ exit: 0 }),
      ].join('\n'),
    );
    const out = execFileSync(BIN, ['-p', '--session-id', 's1', 'task'], {
      env: { ...process.env, X056_FAKE_SCENARIO: scenario },
      encoding: 'utf8',
    });
    const lines = out.trim().split('\n').map((l) => JSON.parse(l));
    expect(lines.map((l) => l.type)).toEqual(['system', 'result']);
  });

  it('uses the resume scenario when --resume is in argv', () => {
    const dir = mkdtempSync(join(tmpdir(), 'x056-fake-'));
    const resumeScenario = join(dir, 'resume.jsonl');
    writeFileSync(
      resumeScenario,
      [
        JSON.stringify({ event: { type: 'result', subtype: 'success', is_error: false, result: 'resumed' } }),
        JSON.stringify({ exit: 0 }),
      ].join('\n'),
    );
    const out = execFileSync(BIN, ['-p', '--resume', 's1', 'continue'], {
      env: { ...process.env, X056_FAKE_SCENARIO: '/nonexistent', X056_FAKE_SCENARIO_RESUME: resumeScenario },
      encoding: 'utf8',
    });
    expect(JSON.parse(out.trim()).result).toBe('resumed');
  });
});

import { readFileSync } from 'node:fs';

const argv = process.argv.slice(2);
const scenarioPath = argv.includes('--resume')
  ? process.env.X056_FAKE_SCENARIO_RESUME
  : process.env.X056_FAKE_SCENARIO;
if (!scenarioPath) {
  process.stderr.write('fake-claude: no scenario env set\n');
  process.exit(2);
}

interface Directive {
  event?: Record<string, unknown>;
  delayMs?: number;
  exit?: number;
  hang?: boolean;
}

const directives: Directive[] = readFileSync(scenarioPath, 'utf8')
  .split('\n')
  .filter((l) => l.trim() !== '')
  .map((l) => JSON.parse(l) as Directive);

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

for (const d of directives) {
  if (d.event) process.stdout.write(`${JSON.stringify(d.event)}\n`);
  if (d.delayMs) await sleep(d.delayMs);
  if (d.hang) await new Promise(() => {});
  if (d.exit !== undefined) process.exit(d.exit);
}
process.exit(0);

#!/usr/bin/env bash
exec npx tsx "$(dirname "$0")/../../src/fake-claude.ts" "$@"

git add src/fake-claude.ts test/bin/fake-claude test/fake-claude.test.ts
git commit -m "feat: add fake-claude scenario replay binary for deterministic e2e"

import { mkdtempSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { describe, expect, it } from 'vitest';
import { AccountRegistry } from '../src/accounts.js';
import { EventLog } from '../src/eventlog.js';
import { CONTINUE_PROMPT, runSession } from '../src/failover.js';
import type { TurnHandle, TurnOptions } from '../src/turn.js';
import type { RawEvent } from '../src/types.js';

const REJECTED: RawEvent = {
  type: 'rate_limit_event',
  rate_limit_info: { status: 'rejected', resetsAt: 2000, rateLimitType: 'five_hour' },
};
const SUCCESS: RawEvent = { type: 'result', subtype: 'success', is_error: false, api_error_status: null, result: 'task done' };

interface Recorded {
  configDir: string;
  mode: string;
  prompt: string;
}

/** Builds a startTurn stand-in that replays one scripted event list per call. */
function scriptTurns(script: RawEvent[][], recorded: Recorded[]): (opts: TurnOptions) => TurnHandle {
  let call = 0;
  return (opts: TurnOptions) => {
    recorded.push({ configDir: opts.configDir, mode: opts.mode, prompt: opts.prompt });
    const events = script[call];
    call += 1;
    let killed = false;
    const done = (async () => {
      for (const e of events) {
        if (killed) break;
        opts.onEvent(e);
        await new Promise((r) => setTimeout(r, 1));
      }
      return { code: killed ? null : 0, signal: killed ? ('SIGKILL' as const) : null };
    })();
    return { kill: () => { killed = true; }, interrupt: () => { killed = true; }, done };
  };
}

function fixtures() {
  const dir = mkdtempSync(join(tmpdir(), 'x056-fo-'));
  const registry = AccountRegistry.init(join(dir, 'accounts.json'), [
    { name: 'a', configDir: '/cfg/a' },
    { name: 'b', configDir: '/cfg/b' },
  ]);
  const log = new EventLog(join(dir, 'events.jsonl'));
  return { registry, log };
}

const base = { sessionId: 'sid-x', cwd: '/tmp', prompt: 'build the thing', forceSwitchSignal: false };

describe('runSession', () => {
  it('completes on the first account when no limit hits', async () => {
    const { registry, log } = fixtures();
    const recorded: Recorded[] = [];
    const res = await runSession({
      ...base, registry, log, now: () => 100,
      startTurnFn: scriptTurns([[SUCCESS]], recorded),
    });
    expect(res).toMatchObject({ status: 'completed', finalAccount: 'a', failovers: 0, resultText: 'task done' });
    expect(recorded).toHaveLength(1);
    expect(recorded[0]).toMatchObject({ configDir: '/cfg/a', mode: 'new', prompt: 'build the thing' });
  });

  it('fails over to b on a rejected rate_limit_event and resumes with CONTINUE_PROMPT', async () => {
    const { registry, log } = fixtures();
    const recorded: Recorded[] = [];
    const res = await runSession({
      ...base, registry, log, now: () => 100,
      startTurnFn: scriptTurns([[REJECTED], [SUCCESS]], recorded),
    });
    expect(res).toMatchObject({ status: 'completed', finalAccount: 'b', failovers: 1 });
    expect(recorded[1]).toMatchObject({ configDir: '/cfg/b', mode: 'resume', prompt: CONTINUE_PROMPT });
    expect(registry.get('a').state).toEqual({ kind: 'limited', until: 2000 });
    const types = log.read().map((r) => r.type);
    expect(types).toContain('limit_detected');
    expect(types).toContain('failover');
  });

  it('parks when both accounts are limited, with the earliest reset', async () => {
    const { registry, log } = fixtures();
    const res = await runSession({
      ...base, registry, log, now: () => 100,
      startTurnFn: scriptTurns([[REJECTED], [{ ...REJECTED, rate_limit_info: { status: 'rejected', resetsAt: 1500 } }]], []),
    });
    expect(res).toMatchObject({ status: 'parked', parkedUntil: 1500, failovers: 2 });
  });

  it('trips the flap guard after more than 3 failovers in an hour', async () => {
    const { registry, log } = fixtures();
    // accounts recover instantly: resetsAt in the past, so pickActive always finds one
    const INSTANT: RawEvent = { type: 'rate_limit_event', rate_limit_info: { status: 'rejected', resetsAt: 1 } };
    const res = await runSession({
      ...base, registry, log, now: () => 100, maxFailoversPerHour: 3,
      startTurnFn: scriptTurns([[INSTANT], [INSTANT], [INSTANT], [INSTANT], [SUCCESS]], []),
    });
    expect(res.status).toBe('failed');
    expect(res.failovers).toBe(4);
    expect(log.read().map((r) => r.type)).toContain('flap_guard_tripped');
  });

  it('uses now+5h fallback when the limit signal has no resetsAt', async () => {
    const { registry, log } = fixtures();
    const NO_RESET: RawEvent = { type: 'system', subtype: 'api_retry', error: 'rate_limit', error_status: 429 };
    await runSession({
      ...base, registry, log, now: () => 1000,
      startTurnFn: scriptTurns([[NO_RESET], [SUCCESS]], []),
    });
    expect(registry.get('a').state).toEqual({ kind: 'limited', until: 1000 + 5 * 3600 });
  });
});