elanous 0.2.0 → 0.2.4

package/src/cli/leader-cli.ts

@@ -1,170 +1,21 @@
-// ── `elanous leader` CLI (P1 · 2026-07-26) ──────────────────────────────────
-//
-// `status` — 권위(leader.json) ⊗ 관측 축(bun link · launchd plist · 31415 실프로세스 · self)
-//            대조. READ-ONLY. `running` 축은 lsof 라 여기서만 조회(부팅 경로 무영향).
-// `claim`  — 이 트리를 운영 리더로 승격: **bun link → leader.json** 순서(link 실패 시 권위를
-//            기록하지 않아 부분 적용을 막는다).
-//
-// ⚠️ `claim` 은 outward-facing(머신 전역 운영 지정) → 기본 dry-run, `--yes` 로만 실행.
-// ⚠️ **launchd plist 는 이 명령이 옮기지 않는다** — 운영 데몬 재기동을 유발하는 별개 행위이고,
-//    미구현을 플래그로 약속하지 않기 위해 리더 트리에서 `elanous nexus install` 로 분리한다.
-//    (status/claim 이 어긋남을 감지하면 그 명령을 안내한다.)
-
+// Retired command: preserve an actionable diagnostic without granting source-tree authority.
 import type { Command } from 'commander';
-import { execFileSync } from 'node:child_process';
-import {
-  leaderFilePath,
-  leaderRefusalFilePath,
-  observeLeaderAxes,
-  readLeader,
-  readLeaderRefusal,
-  writeLeader,
-  normalizeTree,
-  type LeaderRecord,
-  type LeaderRefusalRecord,
-  resolveRunningScript,
-  treeFromScriptPath,
-  installedCopyRoot,
-} from '../instance/leader.js';
 
 export interface LeaderCliDeps {
   out?: { log: (s: string) => void; error: (s: string) => void };
-  now?: () => string;
-  runBunLink?: (tree: string) => void;
-  write?: (r: LeaderRecord) => void;
-}
-
-const liveDeps: Required<LeaderCliDeps> = {
-  out: { log: (s) => console.log(s), error: (s) => console.error(s) },
-  now: () => new Date().toISOString(),
-  runBunLink: (tree) => { execFileSync('bun', ['link'], { cwd: tree, stdio: 'inherit' }); },
-  write: writeLeader,
-};
-
-/** 순수 렌더 — 테스트가 문자열로 계약을 고정할 수 있게 분리. */
-export function renderLeaderStatus(
-  axes: ReturnType<typeof observeLeaderAxes>,
-  rec: LeaderRecord | null,
-  /** P4 완화 ② — 최근 거부 기록. 데몬이 안 뜨는 이유를 **여기서 즉시** 답할 수 있게 한다. */
-  refusal: LeaderRefusalRecord | null = null,
-): string {
-  const installedAxes = axes.installed ?? {};
-  const mark = (v: string | null, name?: string) => {
-    if (!v && name && installedAxes[name]) return `설치본 (${installedAxes[name]})`;
-    if (!v) return '(해석 불가)';
-    if (!axes.authority) return v;
-    return v === axes.authority ? `${v}  ✓` : `${v}  ⚠️ 드리프트`;
-  };
-  const L: string[] = [];
-  L.push('━━ 운영 리더 ━━');
-  L.push(`  권위 (leader.json) : ${axes.authority ?? '(미지정 — 3축 추론 대기)'}`);
-  if (rec) {
-    L.push(`    승격  : ${rec.promotedAt}${rec.promotedBy ? ` · ${rec.promotedBy}` : ''}${rec.bootstrapped ? ' · 자동추론' : ''}`);
-    if (rec.reason) L.push(`    사유  : ${rec.reason}`);
-    if (rec.previous) L.push(`    직전  : ${rec.previous.tree} (until ${rec.previous.until})`);
-  }
-  L.push('  ── 관측 축 ──');
-  L.push(`  bun link           : ${mark(axes.bunLink, 'bun-link')}`);
-  L.push(`  launchd plist      : ${mark(axes.launchd, 'launchd')}`);
-  L.push(`  31415 실프로세스   : ${axes.running || installedAxes.running ? mark(axes.running, 'running') : '(미가동/미조회)'}`);
-  L.push(`  이 프로세스 트리   : ${axes.self}${axes.authority ? (axes.self === axes.authority ? '  ✓ 리더' : '  · 비-리더') : ''}`);
-  L.push('');
-  // ⚠️ '정합' 과 '확인 불가' 를 섞지 않는다 — 축이 없어서 조용한 것과 일치해서 조용한 것은 다르다.
-  if (!axes.coherent) {
-    L.push(`  ⚠️ 드리프트(${axes.drift.join(', ')}) — 'elanous leader claim --yes' 로 권위+bun link 이동`);
-    if (axes.drift.includes('launchd')) L.push("     launchd 는 별도: 리더 트리에서 'elanous nexus install' (데몬 재기동)");
-  } else if (axes.unresolved.length > 0) {
-    L.push(`  ⚠️ 해석 불가 축: ${axes.unresolved.join(', ')} — 나머지는 일치하나 **정합을 확인할 수 없습니다**.`);
-  } else if (!axes.authority) {
-    L.push('  · 권위 미지정 — 리더 트리에서 부팅하거나 `elanous leader claim --yes` 로 지정하세요.');
-  } else {
-    const installedNames = Object.keys(installedAxes);
-    L.push(installedNames.length > 0
-      ? `  ✅ 정합 — 트리 축은 권위와 같고, 설치본 축(${installedNames.join(', ')})은 운영 코드(설치본)를 가리킵니다.`
-      : '  ✅ 정합 — 해석된 모든 축이 권위와 같은 트리를 가리킵니다.');
-  }
-  // ★ P4 완화 ② — 거부가 있었으면 **가장 눈에 띄는 자리**에 싣는다. launchd KeepAlive 가 재기동을
-  //   반복하면 사람은 "데몬이 안 뜬다"만 보이고 이유를 모른다. 그 유일한 단서가 이 줄이다.
-  if (refusal) {
-    L.push('');
-    L.push(`  ⛔ 최근 거부 (${refusal.refusedAt}) — ${refusal.why}`);
-    L.push(`     거부된 트리: ${refusal.selfTree}${refusal.depth > 0 ? ` · 중첩 depth ${refusal.depth}` : ''}`);
-    L.push(`     기록: ${leaderRefusalFilePath()}`);
-  }
-  return L.join('\n');
 }
 
 export function registerLeaderCommands(program: Command, deps: LeaderCliDeps = {}): void {
-  const d = { ...liveDeps, ...deps };
-  const cmd = program.command('leader').description('운영 리더(머신 전역 prod 지정) 조회·승격 — 동일 레포 다중 체크아웃에서 "어디가 운영인가"의 단일 권위');
-
+  const out = deps.out ?? { log: (s: string) => console.log(s), error: (s: string) => console.error(s) };
+  const message = '리더 트리 지정은 폐기되었습니다. 운영 명령은 전역 elanous 로 실행하세요.';
+  const cmd = program.command('leader').description('은퇴한 리더 트리 명령');
   cmd.command('status', { isDefault: true })
-    .description('권위(leader.json) ⊗ 관측 축(bun link·launchd·31415 실프로세스·self) 대조 (READ-ONLY)')
+    .description('리더 권위 폐기 안내 (READ-ONLY)')
     .option('--json', 'JSON 출력')
-    .action((o: { json?: boolean }) => {
-      // running 축은 lsof 서브프로세스라 **status 에서만** 조회한다(부팅 경로 무영향).
-      const runningScript = resolveRunningScript();
-      const axes = observeLeaderAxes({
-        running: runningScript ? treeFromScriptPath(runningScript) : null,
-        installed: { running: runningScript ? installedCopyRoot(runningScript) : null },
-      });
-      const rec = readLeader();
-      const refusal = readLeaderRefusal();
-      if (o.json) {
-        d.out.log(JSON.stringify({
-          ...axes, record: rec, recentRefusal: refusal,
-          path: leaderFilePath(), refusalPath: leaderRefusalFilePath(),
-        }, null, 2));
-        return;
-      }
-      d.out.log(renderLeaderStatus(axes, rec, refusal));
-    });
-
+    .action((o: { json?: boolean }) => out.log(o.json ? JSON.stringify({ retired: true, message }) : message));
   cmd.command('claim')
-    .description('이 트리를 운영 리더로 승격 — bun link + leader.json (launchd plist 는 별도: nexus install). 기본 dry-run.')
-    .option('--yes', '실제 적용 (기본 dry-run)')
-    .option('--reason <text>', '승격 사유(기록에 남는다)')
-    .action((o: { yes?: boolean; reason?: string }) => {
-      const axes = observeLeaderAxes();
-      const target = axes.self;
-      const prev = readLeader();
-      // ⚠️ 조기 종료는 **권위가 이 트리이고 드리프트도 미해석 축도 없을 때만** — 누락 축을
-      //    복구하지 않고 빠져나가면 'claim 했는데 여전히 어긋남' 이 된다.
-      if (prev && normalizeTree(prev.tree) === target && axes.coherent && axes.unresolved.length === 0) {
-        d.out.log(`이미 운영 리더이고 해석된 모든 축이 정합합니다: ${target}`);
-        return;
-      }
-      // 이 명령이 **실제로** 옮기는 것만 계획에 적는다(미구현을 약속하지 않는다).
-      const plan: string[] = [
-        `  1) bun link    → ${target}  (먼저 — 실패하면 권위를 기록하지 않는다)`,
-        `  2) leader.json → ${target}`,
-        `  ·  launchd plist는 이 명령이 옮기지 않습니다 → 리더 트리에서 'elanous nexus install' (데몬 재기동)`,
-      ];
-      if (!o.yes) {
-        d.out.log(`[dry-run] 운영 리더 승격 계획:\n${plan.join('\n')}\n\n적용하려면 --yes 를 붙이세요.`);
-        if (axes.launchd && axes.launchd !== target) {
-          d.out.error(`⚠️ launchd 는 여전히 ${axes.launchd} — 데몬은 옛 트리 코드로 뜹니다. 리더 트리에서 'elanous nexus install' 을 실행하세요.`);
-        }
-        return;
-      }
-      const rec: LeaderRecord = {
-        tree: target,
-        promotedAt: d.now(),
-        promotedBy: process.env.USER ?? 'unknown',
-        ...(o.reason ? { reason: o.reason } : {}),
-        ...(prev ? { previous: { tree: normalizeTree(prev.tree), until: d.now() } } : {}),
-      };
-      // ★ 순서 — bun link 를 **먼저**. 실패하면 권위를 기록하지 않아 '권위만 옮겨간 부분 적용'
-      //   상태를 만들지 않는다(리뷰 should-fix).
-      try { d.runBunLink(target); d.out.log(`✓ bun link → ${target}`); }
-      catch (e) {
-        d.out.error(`✗ bun link 실패 — 권위를 기록하지 않고 중단합니다(부분 적용 방지): ${e instanceof Error ? e.message : String(e)}`);
-        return;
-      }
-      d.write(rec);
-      d.out.log(`✓ leader.json → ${target}`);
-      if (axes.launchd && axes.launchd !== target) {
-        d.out.error(`⚠️ launchd 는 여전히 ${axes.launchd} — 데몬은 옛 트리 코드로 뜹니다. 이 트리에서 'elanous nexus install' 을 실행하세요.`);
-      }
-    });
+    .description('은퇴한 리더 승격 명령')
+    .option('--yes', 'legacy option (ignored)')
+    .option('--reason <text>', 'legacy option (ignored)')
+    .action(() => out.error(message));
 }

package/src/cli/live-cli.ts

@@ -0,0 +1,48 @@
+// `elanous live detail` — 현재 우주에만 쓰고 운영 폴백은 읽기만 한다.
+import type { Command } from 'commander';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { prodInstanceRoot } from '../instance/resolve.js';
+import {
+  LIVE_DETAIL_DEFAULT_TTL_MIN, LIVE_DETAIL_MAX_TTL_MIN,
+  liveDetailPath, selectLiveDetail, writeLiveDetail,
+} from '../live/detail-switch.js';
+
+export interface LiveCliDeps {
+  readonly localRoot?: () => string;
+  readonly productionRoot?: () => string;
+  readonly now?: () => number;
+  readonly out?: { log: (line: string) => void; error: (line: string) => void };
+}
+
+export function registerLiveCommands(program: Command, deps: LiveCliDeps = {}): void {
+  const out = deps.out ?? console;
+  const localRoot = deps.localRoot ?? elanousStateRoot;
+  const productionRoot = deps.productionRoot ?? prodInstanceRoot;
+  const now = deps.now ?? Date.now;
+  const detail = program.command('live').description('Live 상세 관측 스위치').command('detail').description('화려함 MAX 상세 판단 이벤트');
+  for (const action of ['on', 'off', 'status'] as const) {
+    detail.command(action)
+      .description(action === 'on' ? '상세 관측 켜기' : action === 'off' ? '현재 우주에서 끄기' : '현재 상태 보기')
+      .option('--scope <all|runId>', '적용 런 (기본 all)')
+      .option('--ttl <minutes>', '켜 둘 분 (기본 30 · 최대 240)')
+      .option('--json', 'JSON 출력')
+      .action((opts: { scope?: string; ttl?: string; json?: boolean }) => {
+        const scope = opts.scope ?? 'all';
+        if (!/^(all|[\w.:-]{1,128})$/.test(scope)) { out.error('⛔ --scope 는 all 또는 유효한 runId'); process.exitCode = 2; return; }
+        const ttl = opts.ttl === undefined ? LIVE_DETAIL_DEFAULT_TTL_MIN : Number(opts.ttl);
+        if (opts.ttl !== undefined && (!Number.isFinite(ttl) || ttl < 0 || ttl > LIVE_DETAIL_MAX_TTL_MIN || opts.ttl.trim() === '')) {
+          out.error(`⛔ --ttl 은 0~${LIVE_DETAIL_MAX_TTL_MIN}분`); process.exitCode = 2; return;
+        }
+        if (action !== 'on' && opts.ttl !== undefined) { out.error('⛔ --ttl 은 on 에만 사용'); process.exitCode = 2; return; }
+        const localPath = liveDetailPath(localRoot());
+        const productionPath = liveDetailPath(productionRoot());
+        const time = now();
+        if (action !== 'status') writeLiveDetail({ scope, ttlMin: action === 'off' ? 0 : ttl, by: 'cli' }, { path: localPath, now: time });
+        const { state, source, path } = selectLiveDetail({ path: localPath, prodPath: productionPath, now: time });
+        const on = !!state && (opts.scope === undefined || state.scope === 'all' || state.scope === scope);
+        const report = { on, scope: state?.scope ?? null, remainingMin: state ? Math.max(0, (state.until - time) / 60_000) : 0, source, path };
+        if (opts.json) out.log(JSON.stringify(report));
+        else out.log(`Live detail: ${on ? 'on' : 'off'} · 남은 분: ${Math.round(report.remainingMin)} · 출처: ${source === 'local' ? '자기 우주' : source === 'production' ? '운영 폴백' : '없음'}${path ? ` (${path})` : ''}`);
+      });
+  }
+}

package/src/cli/llm-detect-cli.ts

@@ -0,0 +1,130 @@
+import type { Command } from 'commander';
+import type { LLMProvider } from '../llm.js';
+import { detectProviders, type DetectedProvider } from '../llm/provider-detect.js';
+import { probeProvider, type ProviderProbeResult } from '../llm/provider-probe.js';
+import {
+  getUserConfig, reloadUserConfig, saveUserConfig, userConfigPath,
+  type UserConfig,
+} from '../user-config.js';
+
+export interface LlmDetectOptions {
+  json?: boolean;
+  probe?: boolean;
+  apply?: boolean;
+}
+
+export interface LlmDetectDeps {
+  detect?: () => Promise<DetectedProvider[]>;
+  resolve?: (candidate: DetectedProvider, config: UserConfig) => LLMProvider;
+  probeProvider?: (provider: LLMProvider) => Promise<ProviderProbeResult>;
+  config?: () => UserConfig;
+  save?: (config: UserConfig) => void;
+  output?: (line: string) => void;
+}
+
+export interface LlmDetectResult {
+  candidates: Array<DetectedProvider & { probe?: ProviderProbeResult; command?: string }>;
+  selected: string | null;
+  applied: boolean;
+  /** Why a selected provider was not written (an explicit llm.provider is never overwritten). */
+  notApplied?: string;
+  error?: string;
+}
+
+/** Discovery alone cannot validate credentials. Only a successful probe can select a provider. */
+export async function runLlmDetect(
+  options: LlmDetectOptions = {}, deps: LlmDetectDeps = {},
+): Promise<LlmDetectResult> {
+  const output = deps.output ?? console.log;
+  if (options.apply && !options.probe) {
+    const result: LlmDetectResult = { candidates: [], selected: null, applied: false, error: '--apply requires --probe' };
+    output(options.json ? JSON.stringify(result) : result.error!);
+    return result;
+  }
+
+  const config = (deps.config ?? getUserConfig)();
+  const candidates = (await (deps.detect ?? detectProviders)())
+    .sort((a, b) => a.rank - b.rank)
+    .map(({ provider, auth, source, available, rank, agent }) => ({
+      provider, auth, source, available, rank, ...(agent ? {
+        agent, command: `elanous agent-mission … --backend ${agent.cli === 'claude' ? 'claude' : 'gemini'}`,
+      } : {}),
+    }));
+  const rows: LlmDetectResult['candidates'] = candidates;
+  let selected: string | null = null;
+  if (options.probe) {
+    for (const candidate of rows) {
+      if (!candidate.available || candidate.auth === 'agent-cli') continue;
+      try {
+        const provider = await (deps.resolve ?? (async (entry, cfg) => {
+          const { getProviderForConfig } = await import('../llm.js');
+          return getProviderForConfig({
+            ...cfg,
+            llm: { ...cfg.llm, provider: entry.provider as UserConfig['llm']['provider'] },
+          });
+        }))(candidate, config);
+        if (provider.name !== candidate.provider || !provider.available()) continue;
+        const outcome = await (deps.probeProvider ?? probeProvider)(provider);
+        candidate.probe = {
+          success: outcome.success, durationMs: outcome.durationMs, model: outcome.model,
+          ...(outcome.error ? { error: ['timeout', 'empty response', 'probe failed'].includes(outcome.error) ? outcome.error : 'probe failed' } : {}),
+        };
+        if (outcome.success) { selected = candidate.provider; break; }
+      } catch {
+        candidate.probe = { success: false, durationMs: 0, model: '', error: 'probe failed' };
+      }
+    }
+  }
+
+  let applied = false;
+  let notApplied: string | undefined;
+  const previous = config.llm?.provider ?? 'auto';
+  if (options.apply && selected && previous !== 'auto') {
+    notApplied = `llm.provider is already ${previous} — left unchanged`;
+  } else if (options.apply && selected) {
+    const next = { ...config, llm: { ...config.llm, provider: selected as UserConfig['llm']['provider'] } };
+    if (deps.save) deps.save(next);
+    else {
+      const path = userConfigPath();
+      saveUserConfig(next, path);
+      reloadUserConfig(path);
+    }
+    applied = true;
+  }
+  const result: LlmDetectResult = { candidates: rows, selected, applied, ...(notApplied ? { notApplied } : {}) };
+  if (options.json) output(JSON.stringify(result));
+  else {
+    if (rows.length === 0) output('No LLM providers detected.');
+    for (const row of rows) {
+      if (row.auth === 'agent-cli') {
+        const claude = row.agent?.cli === 'claude';
+        const stored = claude && row.agent?.loggedIn === true && row.agent.storedLoggedIn === true;
+        const sessionOnly = claude && row.agent?.loggedIn === true && row.agent.storedLoggedIn === false;
+        const status = stored ? 'logged-in (stored)'
+          : sessionOnly ? 'session token only — run `claude` then `/login` in a normal terminal for unattended use'
+          : row.agent?.loggedIn === true ? 'logged-in' : row.agent?.loggedIn === false ? 'logged-out' : 'login unknown';
+        const method = !stored && !sessionOnly && row.agent?.method
+          ? ` (${row.agent.method === 'claude.ai' || row.agent.method === 'oauth_token' ? 'oauth' : row.agent.method})` : '';
+        output(`agent  ${row.provider}  ${status}${method}  → ${row.command}`);
+      } else {
+        output(`${row.provider}  ${row.auth}  ${row.source}  ${row.probe ? (row.probe.success ? `probe passed (${row.probe.model})` : `probe ${row.probe.error ?? 'failed'}`) : 'not probed'}`);
+      }
+    }
+    if (options.probe && !selected) output('No provider passed the probe; configuration unchanged.');
+    if (applied) output(`Applied llm.provider=${selected} — revert: elanous config set llm.provider auto`);
+    if (notApplied) output(notApplied);
+  }
+  return result;
+}
+
+export function registerLlmDetectCommand(program: Command): void {
+  program.command('llm').description('LLM 공급자')
+    .command('detect').description('이 기계에 이미 있는 구독·키를 찾아 순위대로 보여 준다 (--probe 한 턴 검증 · --apply 는 llm.provider 가 auto 일 때만 쓴다)')
+    .option('--probe', '위에서부터 한 턴(«OK») 검증해 첫 통과를 고른다')
+    .option('--apply', '검증을 통과한 공급자를 llm.provider 로 저장 (--probe 필요 · 이미 명시돼 있으면 안 바꾼다)')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: LlmDetectOptions) => {
+      const result = await runLlmDetect(opts);
+      if (result.error) process.exitCode = 2;
+    });
+}