elanous 0.2.35 → 0.2.36

package/src/ux-sim/onboarding-first-run-device.ts

@@ -0,0 +1,269 @@
+// ux-sim device: the PRODUCTION first-run menu, driven under a real util-linux PTY.
+//
+// Why this exists: the menu re-ask loop of `src/onboarding/first-run.ts`
+// (`promptProviderMenu` → `parseMenuAnswer`) is only reachable when
+// `process.stdin.isTTY` is true. A plain pipe makes the CLI take the non-TTY
+// `needs-llm` shortcut instead, so the board (how many times the menu comes
+// back, which phrase ends the run, whether `onboarding.ready` is written) is
+// unmeasurable without a TTY. This device allocates one the same way the live
+// seat does — util-linux `script -q -e -c` — so the production entrypoint
+// `bin/elanous.mjs --test` runs its real `src/index.ts` → `runFirstRun` →
+// `promptProviderMenu` path.
+//
+// Isolation (K-MK-03): HOME/XDG/claude dirs are a fresh temp tree and the CLI
+// is spawned with `--test --config-dir <temp>`, so the run cannot touch a real
+// seat's config/state. `script` comes from `fake-bin`'s PTY shim, which records
+// the call — the observation therefore proves the PTY was util-linux, not a
+// hand-rolled pipe.
+import { spawn } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { formatProviderMenu, orderProviderChoices } from '../onboarding/first-run.js';
+import { spawnElanousSync } from '../instance/spawn-elanous.js';
+import { createFakeBins, utilLinuxScript, type FakeBinCall } from './fake-bin.js';
+/**
+ * Text `promptProviderMenu` prints before every re-ask — one occurrence per render.
+ * Every assertion on the re-ask count uses this marker, so it has one source.
+ */
+export const FIRST_RUN_MENU_MARKER = 'Choose LLM';
+/**
+ * Fixed choice line of the first-run menu, taken from the production renderer
+ * itself (`formatProviderMenu` over the default choice order) rather than retyped.
+ * Every assertion that the menu printed the expected wording — here and in
+ * `src/onboarding/first-run.test.ts` — reads this, so production wording drift
+ * turns into a failure instead of a stale expectation.
+ */
+export const FIRST_RUN_MENU_CHOICES = formatProviderMenu(orderProviderChoices());
+/** Line `runFirstRun` prints before a fresh install has to pick a provider. */
+export const FIRST_RUN_SETUP_HINT = 'eln setup llm 으로 고르세요';
+/** Misses the parser must reject and re-ask: out of range, exponent, full-width, then 1. */
+export const FIRST_RUN_MENU_ANSWERS = ['4', '1e0', '１', '1'] as const;
+
+const repoRoot = resolve(import.meta.dir, '../..');
+const cliEntry = join(repoRoot, 'bin', 'elanous.mjs');
+
+export interface FirstRunPtySupport {
+  /** True when this host can run the production CLI under util-linux `script`. */
+  readonly available: boolean;
+  /** Why the stage is unavailable (`null` when available). */
+  readonly reason: string | null;
+  /** Absolute path of the util-linux `script` that would allocate the PTY. */
+  readonly scriptPath: string | null;
+}
+
+/**
+ * Can this host allocate the PTY stage? macOS ships BSD `script`, whose flags are
+ * not `-q -e -c`, so the stage is Linux-only — the two production TTY tests keep
+ * their existing Darwin skip and report this reason instead of silently passing.
+ */
+export function firstRunPtySupport(): FirstRunPtySupport {
+  if (process.platform !== 'linux') {
+    return {
+      available: false,
+      reason: `util-linux \`script -q -e -c\` PTY stage needs Linux (this host is ${process.platform})`,
+      scriptPath: null,
+    };
+  }
+  const scriptPath = utilLinuxScript();
+  if (scriptPath === null) {
+    return { available: false, reason: 'no util-linux `script` on PATH', scriptPath: null };
+  }
+  return { available: true, reason: null, scriptPath };
+}
+
+export interface FirstRunMenuDeviceOptions {
+  /** Answers written to the PTY, one per rendered menu (default `FIRST_RUN_MENU_ANSWERS`). */
+  readonly answers?: readonly string[];
+  /** Hard stop for the child (default 45 s; the caller's own test budget must exceed it). */
+  readonly timeoutMs?: number;
+  /** Delay between «menu seen» and «answer written» so readline is listening (default 300 ms). */
+  readonly answerDelayMs?: number;
+  /** Keep the isolated home/config tree instead of deleting it (default false). */
+  readonly keepRoot?: boolean;
+}
+
+export interface FirstRunMenuObservation {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly status: number | null;
+  readonly timedOut: boolean;
+  /** How many times the menu block was rendered on stdout. */
+  readonly menuRenderCount: number;
+  /** Answers actually written to the PTY, in order. */
+  readonly answersSent: readonly string[];
+  /** `FIRST_RUN_SETUP_HINT` when the run ended on the fresh-install hint, else null. */
+  readonly finalPhrase: string | null;
+  /** True when the isolated config recorded `onboarding.ready`. */
+  readonly readyRecorded: boolean;
+  /** Parsed isolated config at exit (null when unreadable). */
+  readonly config: Record<string, unknown> | null;
+  /** Path of the isolated config file the CLI was pointed at. */
+  readonly configPath: string;
+  /** The exec'd argv (bin, `--test`, `--config-dir`) — the production entrypoint shape. */
+  readonly childCommand: readonly string[];
+  /** The `script` invocation recorded by the fake-bin PTY shim. */
+  readonly scriptCall: FakeBinCall | null;
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * Spawn the production CLI (`bin/elanous.mjs --test --config-dir <temp>`) under a
+ * util-linux `script -q -e -c` PTY, feed `answers` as each menu render appears, and
+ * return what the production path actually did.
+ */
+export async function driveFirstRunMenu(
+  options: FirstRunMenuDeviceOptions = {},
+): Promise<FirstRunMenuObservation> {
+  const support = firstRunPtySupport();
+  if (!support.available) {
+    throw new Error(`first-run device: no PTY stage on this host — ${support.reason ?? 'unknown reason'}`);
+  }
+  const answers = [...(options.answers ?? FIRST_RUN_MENU_ANSWERS)];
+  const timeoutMs = options.timeoutMs ?? 45_000;
+  const answerDelayMs = options.answerDelayMs ?? 300;
+
+  const fakeBins = createFakeBins({ script: { pty: true } });
+  const root = mkdtempSync(join(tmpdir(), 'onb-first-run-device-'));
+  const home = join(root, 'home');
+  const configDir = join(root, 'cfg');
+  const configPath = join(configDir, 'config.json');
+  try {
+    mkdirSync(home, { recursive: true });
+    mkdirSync(configDir, { recursive: true });
+
+    const env: NodeJS.ProcessEnv = {
+      ...process.env,
+      HOME: home,
+      CODEX_HOME: join(home, '.codex'),
+      CLAUDE_CONFIG_DIR: join(home, '.claude'),
+      XDG_CONFIG_HOME: '',
+      PATH: fakeBins.path(),
+      NO_COLOR: '1',
+      FORCE_COLOR: '0',
+      CI: '',
+      TERM: 'xterm-256color',
+    };
+    delete env.ELANOUS_CONFIG_DIR;
+    delete env.ELANOUS_STATE_DIR;
+    // FIRST_RUN_SETUP_HINT and the :253 finalPhrase check are fixed Korean strings:
+    // pin the locale so an en/C runner cannot null out the N08 measurement path.
+    env.ELANOUS_LANG = 'ko';
+    delete env.CLAUDE_CODE_SSE_PORT;
+    // A bare machine has no provider: inherited credentials would change the board
+    // (a usable key makes the run ready instead of landing on the setup hint).
+    for (const key of [
+      'ELANOUS_LLM_PROVIDER',
+      'ELANOUS_ESCALATE_PROVIDER',
+      'ANTHROPIC_API_KEY',
+      'OPENAI_API_KEY',
+      'XAI_API_KEY',
+      'GROK_API_KEY',
+      'GROK_CODE_XAI_API_KEY',
+      'GEMINI_API_KEY',
+      'GOOGLE_API_KEY',
+      'OPENROUTER_API_KEY',
+      'CLAUDE_CODE_OAUTH_TOKEN',
+      'ANTHROPIC_AUTH_TOKEN',
+      'LOCAL_LLM_URL',
+    ]) {
+      env[key] = '';
+    }
+
+    // Warm the bundle cache with a non-TTY call first: the cold compile alone can
+    // outlast the PTY budget, and a timeout would read as a parser defect.
+    spawnElanousSync(['--test', '--config-dir', configDir, '--version'], {
+      cwd: repoRoot,
+      env,
+      stateDir: configDir,
+      stdio: 'ignore',
+      timeout: 180_000,
+    });
+
+    const childCommand = [process.execPath, cliEntry, '--test', '--config-dir', configDir];
+    const childLine = childCommand.map(shellQuote).join(' ');
+    const child = spawn('sh', ['-c', 'script -q -e -c "$1" /dev/null', 'sh', childLine], {
+      cwd: repoRoot,
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      // `script` only allocates a TTY when it is *not* started on one, so it is
+      // deliberately spawned on pipes and the answers are written into its stdin.
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let seen = 0;
+    const answersSent: string[] = [];
+    let closed = false;
+    let timedOut = false;
+
+    const writeNext = (): void => {
+      if (answersSent.length >= answers.length) return;
+      const answer = answers[answersSent.length]!;
+      answersSent.push(answer);
+      child.stdin.write(`${answer}\n`);
+    };
+
+    child.stdout.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString('utf8');
+      const count = stdout.split(FIRST_RUN_MENU_MARKER).length - 1;
+      while (seen < count) {
+        seen += 1;
+        setTimeout(() => {
+          if (!closed) writeNext();
+        }, answerDelayMs);
+      }
+    });
+    child.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString('utf8');
+    });
+
+    const status = await new Promise<number | null>((done) => {
+      const timer = setTimeout(() => {
+        timedOut = true;
+        child.kill('SIGKILL');
+      }, timeoutMs);
+      child.on('close', (code) => {
+        closed = true;
+        clearTimeout(timer);
+        done(code);
+      });
+      child.on('error', () => {
+        closed = true;
+        clearTimeout(timer);
+        done(null);
+      });
+    });
+
+    let config: Record<string, unknown> | null = null;
+    try {
+      config = JSON.parse(readFileSync(configPath, 'utf8')) as Record<string, unknown>;
+    } catch {
+      config = null;
+    }
+    const onboarding = config?.['onboarding'];
+    const readyRecorded = typeof onboarding === 'object' && onboarding !== null
+      && Object.prototype.hasOwnProperty.call(onboarding, 'ready');
+
+    return {
+      stdout,
+      stderr,
+      status,
+      timedOut,
+      menuRenderCount: Math.min(seen, stdout.split(FIRST_RUN_MENU_MARKER).length - 1),
+      answersSent,
+      finalPhrase: stdout.includes(FIRST_RUN_SETUP_HINT) ? FIRST_RUN_SETUP_HINT : null,
+      readyRecorded,
+      config,
+      configPath,
+      childCommand,
+      scriptCall: fakeBins.calls().find((call) => call.name === 'script') ?? null,
+    };
+  } finally {
+    fakeBins.cleanup();
+    if (options.keepRoot !== true) rmSync(root, { recursive: true, force: true });
+  }
+}

package/src/ux-sim/pty-key-modifiers-device.ts

@@ -0,0 +1,85 @@
+// N03 장치 — PTY-KEY-MODIFIERS (0.2.36 · 2026-10-22 · #27585 Shift+Enter 줄바꿈).
+// `elanous pty key <ref> shift+enter` 가 PTY 에 쓰는 바로 그 바이트(생산 `resolvePtySpecialKey`)를 진짜 TUI(classic ·
+// next)에 넣는다 — «한 줄» 입력 → shift+enter → «둘째 줄» → Enter 가 Ctrl+J 대체 없이 두 줄짜리 한 번의 제출이 되나.
+// 판정은 fake LLM 이 받은 마지막 사용자 글(요청 캡처)에 «한 줄\n둘째 줄» 이 그대로 있는가 ⊕ 화면.
+// ⛔ 생산 로직 재구현 0 — 바이트는 resolvePtySpecialKey, 받는 쪽은 진짜 TUI 파서·입력창.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { resolvePtySpecialKey, type PtyKeyEncoding } from '../pty-shell/pty-special-keys.js';
+import { mockSeatPtySequence, type SeatPtySequenceEvidence, type SeatPtyStep } from './mock-seat-pty-sequence.js';
+import { TEST_FAKE_LLM_CAPTURE_ENV, TEST_FAKE_LLM_ENV, TEST_FAKE_LLM_RESPONSE_ENV } from './fake-llm.js';
+
+export interface PtyKeyModifiersSpec {
+  tui: 'classic' | 'next';
+  encoding: PtyKeyEncoding;
+  root: string;
+  executable: string;
+  entry: string;
+}
+
+export interface PtyKeyModifiersResult {
+  spec: PtyKeyModifiersSpec;
+  bytes: string;
+  run: SeatPtySequenceEvidence;
+  lastUser: string;
+  checks: Record<string, boolean>;
+}
+
+const REPLY = '[fake-llm] 두 줄 받았습니다';
+export const PTY_KEY_FIRST = 'modkey-line-one';
+export const PTY_KEY_SECOND = 'modkey-line-two';
+
+export async function runPtyKeyModifiersDevice(spec: PtyKeyModifiersSpec): Promise<PtyKeyModifiersResult> {
+  const root = resolve(spec.root);
+  mkdirSync(root, { recursive: true });
+  writeFileSync(join(root, 'config.json'), JSON.stringify({ onboarding: { completed: true }, errorReports: { enabled: false } }));
+  const capturePath = join(root, 'fake-llm-requests.jsonl');
+  const bytes = resolvePtySpecialKey('shift+enter', { encoding: spec.encoding });
+  const ready = spec.tui === 'next'
+    ? (s: string) => s.includes('elanous next ·') && s.includes('Ctrl+Q 종료')
+    : (s: string) => s.includes('elanous | daemon') && s.includes('❯');
+  const answered = (s: string) => s.includes(REPLY) && (spec.tui === 'next' ? s.includes('응답 완료') : /✔ 완료/.test(s));
+  const steps: SeatPtyStep[] = [
+    { label: 'first line', keys: PTY_KEY_FIRST, until: (s) => s.includes(PTY_KEY_FIRST) },
+    { label: 'shift+enter', keys: bytes, until: () => true },
+    { label: 'second line', keys: PTY_KEY_SECOND, until: (s) => s.includes(PTY_KEY_SECOND) },
+    { label: 'submitted', keys: '\r', until: answered, timeoutMs: 30_000 },
+  ];
+  const run = await mockSeatPtySequence({
+    executable: spec.executable,
+    args: [spec.entry, '--config-dir', '{root}', '--test-state-dir', '{root}', ...(spec.tui === 'next' ? ['--tui', 'next'] : [])],
+    root,
+    rows: 30,
+    cols: 100,
+    env: {
+      ELANOUS_SESSION_ROOT: join(root, 'sessions'),
+      [TEST_FAKE_LLM_ENV]: '1',
+      ELANOUS_TEST_FAKE_LLM_AS_PROVIDER: '1',
+      [TEST_FAKE_LLM_RESPONSE_ENV]: REPLY,
+      [TEST_FAKE_LLM_CAPTURE_ENV]: capturePath,
+    },
+    ready: { label: 'boot', until: ready, timeoutMs: 90_000 },
+    quitKeys: spec.tui === 'next' ? '\x11' : '/exit\r',
+    exitTimeoutMs: 20_000,
+    steps,
+  });
+  const requests = existsSync(capturePath)
+    ? readFileSync(capturePath, 'utf8').split('\n').filter(Boolean).flatMap((l) => { try { return [JSON.parse(l) as { messages: Array<{ role: string; content: unknown }> }]; } catch { return []; } })
+    : [];
+  const content = requests.at(-1)?.messages.filter((m) => m.role === 'user').at(-1)?.content;
+  const lastUser = typeof content === 'string' ? content : JSON.stringify(content ?? '');
+  const beforeSubmit = run.frames.find((f) => f.label === 'second line')?.screen ?? '';
+  return {
+    spec,
+    bytes,
+    run,
+    lastUser,
+    checks: {
+      // One submission with a real newline between the two lines (not two turns, not a literal «^M»/escape residue).
+      oneTurnTwoLines: requests.length === 1 && lastUser.includes(`${PTY_KEY_FIRST}\n${PTY_KEY_SECOND}`),
+      noEscapeResidue: !beforeSubmit.includes('[27;') && !beforeSubmit.includes('[13;') && !beforeSubmit.includes('^M'),
+      answered: answered(run.frames.at(-1)?.screen ?? ''),
+      exitedClean: run.exitCode === 0,
+    },
+  };
+}

package/src/ux-sim/subagent-tools-device.ts

@@ -0,0 +1,81 @@
+// N03 장치 — SUBAGENT-TOOLS-EMPTY (0.2.36 · 2026-10-22 · 대표 P0).
+// 진짜 classic TUI(bare `elanous`) ⊕ fake LLM 이 Agent 도구를 «틀린 이름» tool_filter 로 부른다
+// (10-22 운영 실물: allow 5~12개를 줘도 49→0 · «0 tools · Blocked»). 판정은 같은 바이너리의 `logs --json`:
+//   mismatch  — allow 가 모르는 이름뿐 → tool-filter allowIgnored ⊕ dispatch noTools=false(도구 상속)
+//   deny-all  — 모든 도구를 deny → no-tools-refused(발사 거부 · 빈손 실행 0)
+// ⛔ 생산 로직 재구현 0 — Agent 도구·필터·레지스트리 모두 진짜 TUI 안에서 돈다.
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { mockSeatPtySequence, type SeatPtySequenceEvidence } from './mock-seat-pty-sequence.js';
+import { TEST_FAKE_LLM_ENV, TEST_FAKE_LLM_RESPONSE_ENV, TEST_FAKE_LLM_TOOL_CALL_ENV } from './fake-llm.js';
+import { parseData, readLogs } from './next-tui-seat-scenarios.js';
+
+export type SubagentToolsScenario = 'mismatch' | 'zero-refused';
+
+export interface SubagentToolsSpec { scenario: SubagentToolsScenario; root: string; executable: string; entry: string }
+
+export interface SubagentToolsResult {
+  spec: SubagentToolsSpec;
+  run: SeatPtySequenceEvidence;
+  logs: ReturnType<typeof readLogs>;
+  checks: Record<string, boolean>;
+}
+
+type Row = { category?: string; event?: string; data?: string };
+
+export async function runSubagentToolsDevice(spec: SubagentToolsSpec): Promise<SubagentToolsResult> {
+  const root = resolve(spec.root);
+  mkdirSync(root, { recursive: true });
+  writeFileSync(join(root, 'config.json'), JSON.stringify({ onboarding: { completed: true }, errorReports: { enabled: false } }));
+  // zero-refused: allow [Read] ⊕ deny [Read] leaves exactly 0 whatever the host's other tool names are.
+  const toolFilter = spec.scenario === 'mismatch'
+    ? { allow: ['read_file', 'shell', 'grep_search'] }
+    : { allow: ['Read'], deny: ['Read'] };
+  const run = await mockSeatPtySequence({
+    executable: spec.executable,
+    args: [spec.entry, '--config-dir', '{root}', '--test-state-dir', '{root}'],
+    root,
+    rows: 30,
+    cols: 100,
+    env: {
+      ELANOUS_SESSION_ROOT: join(root, 'sessions'),
+      [TEST_FAKE_LLM_ENV]: '1',
+      ELANOUS_TEST_FAKE_LLM_AS_PROVIDER: '1',
+      [TEST_FAKE_LLM_RESPONSE_ENV]: '[fake-llm] 맡겼습니다',
+      // zero-refused 는 «사람이 좁히기를 켠» 경우의 0-거부 안전망을 잰다(기본은 allow 무시라 0 이 안 생긴다).
+      ...(spec.scenario === 'zero-refused' ? { ELANOUS_SUBAGENT_HONOR_ALLOW: '1' } : {}),
+      [TEST_FAKE_LLM_TOOL_CALL_ENV]: JSON.stringify({ when: '서브에이전트로', name: 'Agent', args: { description: '도구 확인', prompt: '파일 하나 읽어라', tool_filter: toolFilter } }),
+    },
+    ready: { label: 'boot', until: (s: string) => s.includes('elanous | daemon') && s.includes('❯'), timeoutMs: 90_000 },
+    quitKeys: '/exit\r',
+    exitTimeoutMs: 20_000,
+    steps: [{ label: 'delegated', text: '서브에이전트로 확인해줘', until: (s) => /✔ 완료|✘ 실패/.test(s), timeoutMs: 60_000 }],
+  });
+  const logs = readLogs({ root, executable: spec.executable, entry: spec.entry }, 'agent.spawn');
+  const rows: Row[] = logs.lines.map((l) => { try { return JSON.parse(l) as Row; } catch { return {}; } });
+  const ev = (event: string) => rows.filter((r) => r.category === 'agent.spawn' && r.event === event).map((r) => parseData<Record<string, unknown>>(r.data));
+  const filterRows = ev('tool-filter');
+  const dispatch = ev('dispatch');
+  const refused = ev('no-tools-refused');
+  const f0 = filterRows[0] ?? {};
+  const dispatchedTools = Array.isArray(dispatch[0]?.tools) ? (dispatch[0]!.tools as unknown[]).length : -1;
+  const checks: Record<string, boolean> = spec.scenario === 'mismatch'
+    ? {
+        filterObserved: filterRows.length === 1,
+        // SUBAGENT-NO-NARROWING — 모델이 넘긴 allow 는 기본 무시(이름이 맞든 틀리든).
+        allowIgnored: f0.allowIgnored === 'model-allow-ignored',
+        unknownLogged: JSON.stringify(f0.unknownAllow) === JSON.stringify(['read_file', 'shell', 'grep_search']),
+        // Full inheritance, not «some tools»: nothing removed and the child got every available tool.
+        nothingRemoved: typeof f0.available === 'number' && f0.available > 0 && f0.remaining === f0.available && f0.removed === 0,
+        childGotAllTools: dispatch.length === 1 && dispatch[0]?.noTools === false && dispatchedTools === f0.available,
+        noRefusal: refused.length === 0,
+        exitedClean: run.exitCode === 0,
+      }
+    : {
+        filterLeftZero: filterRows.length === 1 && f0.remaining === 0 && typeof f0.available === 'number' && f0.available > 0,
+        refusedOnce: refused.length === 1,
+        noDispatch: dispatch.length === 0,
+        exitedClean: run.exitCode === 0,
+      };
+  return { spec, run, logs, checks };
+}