reverbo 0.1.0

package/src/cli.js

@@ -0,0 +1,641 @@
+// 실제 I/O 는 여기서만 안다. 앞의 모듈은 전부 주입을 받는다.
+
+import { readFile, writeFile, mkdir, rename, readdir, stat, unlink, chmod, open } from 'node:fs/promises'
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { paths } from './paths.js'
+import { loadConfig, saveConfig, modelFor, keyEnvFor, MODELS } from './config.js'
+import { readEntry, writeEntry, acquireLock, prune } from './cache.js'
+import { findPrompt } from './transcript.js'
+import { translate } from './translate.js'
+import { shouldSkip } from './redact.js'
+import { statusline } from './statusline.js'
+import { stringWidth } from './render.js'
+import { planInstall, planUninstall, COMMAND } from './settings.js'
+import { askSecret, askChoice } from './prompt.js'
+import { QUESTIONS, previewOf, applyAnswer, nextValue, currentValue } from './wizard.js'
+import { work } from './worker.js'
+import { login } from './login.js'
+import { startPairing, pollPairing, uploadPrompt, revokeToken, fetchStoring, BASE } from './api.js'
+import { append, appendRaw, drain, lockOutbox, unlockOutbox } from './outbox.js'
+
+const BIN = fileURLToPath(new URL('../bin/reverbo.js', import.meta.url))
+
+const sleep = (ms) => new Promise((res) => setTimeout(res, ms))
+
+// 서버 주소. 시험이 프로덕션을 두들기면 안 돼서 둔 문이다.
+//
+// **루프백만 받는다.** 이 주소로는 프롬프트 원문과 로그인 값이 함께
+// 나가는데(uploadPrompt 가 Authorization 을 싣는다), 열어두면 저장소의
+// `.claude/settings.json` 이 env 한 줄을 심는 것만으로 사람이 친 문장이
+// 남의 서버로 샌다 — 화면엔 아무 표시도 없이. 루프백이 경계인 이유는
+// 거기 서버를 띄우려면 이미 그 기계에서 코드를 돌릴 수 있어야 하고,
+// 그럴 수 있는 상대는 이 문이 없어도 다 할 수 있어서다.
+//
+// 포트 뒤에 `/` 나 문자열 끝을 요구하는 이유 — `http://127.0.0.1:80@evil.example`
+// 처럼 루프백을 사용자 정보 자리에 넣어 진짜 호스트를 뒤에 숨기는 모양과
+// `http://127.0.0.1.evil.example` 처럼 앞부분만 흉내 낸 이름을 막는다.
+const LOOPBACK = /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d+)?(\/|$)/
+export const baseOf = () => {
+  const b = process.env.REVERBO_BASE
+  return b && LOOPBACK.test(b) ? b : BASE
+}
+
+// outbox 파일 하나를 임계구역으로 보는 잠금. 워커는 프롬프트마다 새
+// 프로세스로 뜨므로, 이 배선이 없으면 둘이 서로의 쌓기를 덮어쓴다.
+//
+// 주인 표시(id)를 함께 적는다 — TTL 이 지나 남이 잠금을 치우고 새로 잡은
+// 뒤에 내가 늦게 끝나면서 그 잠금을 지워버리면 안 된다.
+const BUSY = Symbol('busy')
+
+async function withOutbox({ file, tries, run }) {
+  const id = `${process.pid}-${Math.random().toString(36).slice(2)}`
+  const got = await lockOutbox({
+    file, id, tries, now: () => Date.now(), sleep, readFile, writeFile, mkdir, unlink,
+  })
+  if (!got) return BUSY
+  try {
+    return await run()
+  } finally {
+    await unlockOutbox({ file, id, readFile, unlink })
+  }
+}
+
+// stdout/stderr 쓰기 실패(예: 파이프 상대가 먼저 닫힘, EPIPE)는 await 체인 위의
+// 예외가 아니라 기반 소켓의 비동기 'error' 이벤트로 온다. main() 의 try/catch 는
+// 그걸 못 잡는다 — 리스너를 안 달면 여기서 스택 트레이스가 뜨고 종료 코드가
+// 1이 된다. 상태줄 명령에서는 그 자체로 사용자 작업 화면이 깨지는 것이다.
+process.stdout.on('error', () => {})
+process.stderr.on('error', () => {})
+
+async function readStdin() {
+  // 사람이 터미널에서 직접 `reverbo statusline` 을 치면 stdin 이
+  // TTY 라 아무도 안 닫는다 — for-await 가 영원히 멈춘다. Claude Code 는
+  // 항상 파이프로 붙이니 실사용 경로엔 영향이 없다.
+  if (process.stdin.isTTY) return ''
+  const chunks = []
+  for await (const c of process.stdin) chunks.push(c)
+  return Buffer.concat(chunks).toString('utf8')
+}
+
+function parse(raw) {
+  try {
+    const o = JSON.parse(raw)
+    return o && typeof o === 'object' ? o : {}
+  } catch {
+    return {}
+  }
+}
+
+// 사실 ⑤ — Claude Code 가 상태줄 프로세스를 죽일 때 그룹째 죽여도 워커가
+// 살아남아야 한다. detached 로 새 프로세스 그룹에 둔다.
+function spawnWorker(job) {
+  try {
+    const child = spawn(process.execPath, [BIN, '__worker'], {
+      detached: true,
+      stdio: ['pipe', 'ignore', 'ignore'],
+    })
+    // spawn 이 비동기로 실패하면(예: EMFILE) 'error' 이벤트가 뜬다. 리스너가
+    // 없으면 이걸 부른 statusline 까지 죽는다 — 절대 안 된다.
+    child.on('error', () => {})
+    child.stdin.on('error', () => {})
+    child.stdin.end(JSON.stringify(job))
+    child.unref()
+  } catch {}
+}
+
+// I3 — statusline·worker·status·init 이 전부 이 함수 하나를 거쳐야
+// ANTHROPIC_API_KEY 환경변수를 같은 방식으로 본다. 예전엔 status 만 여기서
+// 환경변수를 봐서, 키가 환경변수에만 있는 사용자는 status 가 "있어요"를
+// 찍는데 번역은 하나도 안 뜨는 상황이 됐다(statusline·worker 는 못 봤다).
+// 제공처마다 보는 환경변수와 기본 모델이 다르다. 그 해석도 여기 한 곳에서
+// 끝내야 statusline·worker·status 가 같은 값을 본다.
+const cfgOf = async (file) => {
+  const cfg = await loadConfig({ file, readFile })
+  return {
+    ...cfg,
+    model: modelFor(cfg.provider, cfg.model),
+    apiKey: cfg.apiKey || process.env[keyEnvFor(cfg.provider)] || '',
+  }
+}
+
+// 화면에 쓰는 이름. 설정 파일의 값은 소문자라 그대로 찍으면 읽기 나쁘다.
+const LABELS = { openai: 'OpenAI', anthropic: 'Anthropic' }
+const labelOf = (provider) => LABELS[provider] || provider
+
+async function cmdStatusline() {
+  const out = await statusline({
+    input: parse(await readStdin()),
+    env: process.env,
+    deps: {
+      config: cfgOf,
+      readEntry: ({ dir, promptId }) => readEntry({ dir, promptId, readFile }),
+      acquireLock: ({ dir, promptId, now }) => acquireLock({ dir, promptId, now, readFile, writeFile, mkdir, unlink }),
+      spawnWorker,
+      now: () => Date.now(),
+    },
+  })
+  if (out) process.stdout.write(out)
+
+  // 진단용. REVERBO_TERM_DEBUG 가 켜져 있을 때만, 렌더러가 실제로 받은
+  // 폭과 우리가 낸 행들의 실제 폭을 기록한다. 화면에서 잘리는 자리와
+  // 대조해 여백을 「재서」 정하려는 것이다 — 추측으로 빼면 또 어긋난다.
+  if (process.env.REVERBO_TERM_DEBUG) {
+    try {
+      const widths = out ? out.split('\n').map((l) => stringWidth(l.replace(/\x1b\[[0-9;]*m/g, ''))) : []
+      await writeFile(`${paths(process.env).base}/debug.log`,
+        `${new Date().toISOString()} COLUMNS=${process.env.COLUMNS} LINES=${process.env.LINES} 행폭=[${widths.join(',')}]\n`,
+        { flag: 'a' })
+    } catch {}
+  }
+}
+
+// 워커가 부르는 전송 훅. worker.js 가 넘기는 키를 그대로 받는다 —
+// cfg 통째가 아니다(D2): exclude 는 사람의 디렉터리 경로고 apiKey 는 번역
+// 맡기는 곳의 키라, 여기까지 안 오는 것이 맞다.
+//
+// 순서가 「먼저 쌓고 그다음 비운다」인 이유 — 잠금을 못 잡았을 때 잃는 게
+// 없어야 한다. 보내보고 실패할 때만 쌓으면, 그 쌓는 자리에서 잠금을 못
+// 잡는 순간 프롬프트가 사라진다(캐시는 최신 200개만 남고 다시 올리는
+// 경로가 없다). 먼저 쌓아두면 비우기는 실패해도 다음 워커가 이어서 보낸다.
+//
+// 로그인이 만료된 동안에도 같은 순서가 맞다 — drain 이 첫 줄에서 멈추므로
+// 뒤에 붙은 새 것도 안 나가고, 그 사이 친 것은 파일에 그대로 남는다.
+//
+// `tries` 는 쌓는 자리에서 잠금을 몇 번까지 기다릴지다 — 기본값을 쓰면
+// 되고, 시험에서 「끝내 못 잡았을 때」를 빨리 만들려고만 바꾼다.
+// 구독이 없어서 못 쌓을 때 하는 말. 두 가지를 한 번에 말해야 한다 —
+// 무엇이 막혔는지, 그리고 **무엇은 그대로 되는지**. 「구독이 필요해요」만
+// 던지면 아무것도 못 쓰게 된 것처럼 읽히는데, 번역은 계속 된다.
+export const blockedSay = () => [
+  '구독하면 쌓여요. 쌓아 둔 것은 그대로 있다가 구독하면 한 번에 올라가요.',
+  `구독은 ${baseOf()}/#pricing 에서 해요.`,
+  '번역은 그대로 돼요 — 상태줄은 지금처럼 나와요.',
+].join('\n')
+
+// 마지막 비우기가 구독 때문에 멈췄는지를 파일 하나로 남긴다. `reverbo status`
+// 가 이걸 읽는다 — 상태를 물으려고 서버를 왕복하면, 비행기에서 친 사람이
+// 진단조차 못 한다.
+//
+// 재시도·로그인 문제일 때는 표시를 **그대로 둔다.** 그 둘은 구독에 대해
+// 아무것도 말해주지 않는데, 지워버리면 「모른다」가 「구독 있다」로 보인다.
+async function noteBlocked(file, result) {
+  if (!result || result === BUSY) return
+  try {
+    if (result.stopped === 'blocked') {
+      await writeFile(file, new Date().toISOString() + '\n', { mode: 0o600 })
+    } else if (result.stopped === null || result.sent > 0) {
+      await unlink(file)
+    }
+  } catch {
+    // 못 쓰거나 이미 없다. 표시 하나 때문에 보내기가 죽으면 안 된다.
+  }
+}
+
+// 비우기를 안 돌리고도 알게 된 경우(로그인 직후 한 번 물어본 답)를 같은
+// 표시에 적는다. 모르면(null) 손대지 않는다 — 「모른다」로 옛 표시를 지우면
+// 그게 「구독 있다」로 둔갑한다.
+function markStoring(file, storing) {
+  if (storing === true) return noteBlocked(file, { stopped: null, sent: 0 })
+  if (storing === false) return noteBlocked(file, { stopped: 'blocked', sent: 0 })
+  return Promise.resolve()
+}
+
+export async function uploadEntry({ promptId, source, translated, repo, from, to, token }, { tries } = {}) {
+  // 로그인이 곧 동의다. 안 했으면 아무것도 안 올린다.
+  if (!token) return
+  const p = paths(process.env)
+  const entry = { promptId, source, translated, from, to, repo }
+
+  // ① 쌓는다 — 파일만 만지는 짧은 구간이다.
+  const stacked = await withOutbox({
+    file: p.outbox, tries,
+    run: () => append({ file: p.outbox, entry, readFile, writeFile, rename, unlink }),
+  })
+  if (stacked === BUSY) await appendRaw({ file: p.outbox, entry, writeFile })
+
+  // ② 비운다 — 여기서 못 잡으면 그냥 미룬다. 이미 쌓여 있으니 다음 워커나
+  // `reverbo sync` 가 이어서 보낸다. 기다릴 이유가 없어 한 번만 시도한다.
+  const drained = await withOutbox({
+    file: p.outbox, tries: 1,
+    run: () => drain({
+      file: p.outbox,
+      send: (e) => uploadPrompt({ entry: e, token, fetchImpl: globalThis.fetch, base: baseOf() }),
+      readFile, writeFile, rename, unlink, now: () => Date.now(),
+    }),
+  })
+  // 워커는 아무 말도 안 한다(상태줄이 사람의 화면이다). 대신 여기서 본 것을
+  // 적어 둬야 `reverbo status` 가 왜 안 올라가는지 말할 수 있다.
+  await noteBlocked(p.blocked, drained)
+}
+
+async function cmdWorker() {
+  await work({
+    input: parse(await readStdin()),
+    env: process.env,
+    deps: {
+      config: cfgOf,
+      findPrompt: ({ path, promptId }) => findPrompt({ path, promptId, open }),
+      // 관문 G2 의 실제 배선. home 을 여기서 채운다 — worker.js 는 어느
+      // 계정의 홈인지 몰라도 되고, redact.js 는 process.env 를 직접 안 본다.
+      shouldSkip: (a) => shouldSkip({ ...a, home: process.env.HOME || process.env.USERPROFILE || '' }),
+      translate: (a) => translate({ ...a, fetchImpl: globalThis.fetch }),
+      writeEntry: ({ dir, promptId, entry }) => writeEntry({ dir, promptId, entry, mkdir, writeFile, rename }),
+      prune: ({ dir }) => prune({ dir, now: Date.now(), readdir, stat, unlink }),
+      upload: uploadEntry,
+    },
+  })
+}
+
+async function cmdStatus() {
+  const p = paths(process.env)
+  const raw = await loadConfig({ file: p.configFile, readFile }) // 출처를 가리려면 환경변수 병합 전 값이 필요하다
+  const cfg = await cfgOf(p.configFile)
+  const key = cfg.apiKey
+    ? `있어요 (${raw.apiKey ? '설정 파일' : keyEnvFor(cfg.provider)})`
+    : `없어요 — ${keyEnvFor(cfg.provider)} 를 넣으면 돼요`
+  let cached = 0
+  try { cached = (await readdir(p.cacheDir)).filter((f) => f.endsWith('.json')).length } catch {}
+
+  // 못 보낸 것과 그것이 왜 안 가는지. 서버에는 안 묻는다 — 마지막 비우기가
+  // 남긴 표시를 읽는다.
+  const waiting = String((await readTextOrNull(p.outbox)) || '').split('\n').filter(Boolean).length
+  const blocked = (await readTextOrNull(p.blocked)) !== null
+  // 「로그인했어요」만 있으면, 구독이 끊긴 사람은 다 맞는데 왜 안 쌓이는지
+  // 알 길이 없다. 막힌 이유가 있으면 그 자리에서 말한다.
+  const storing = !cfg.token
+    ? '로그인 안 했어요 — reverbo login'
+    : blocked
+      ? `구독하면 쌓여요 — ${baseOf()}/#pricing`
+      : '로그인했어요'
+
+  // 키 값은 절대 찍지 않는다. 있는지와 출처만 말한다.
+  process.stdout.write([
+    `설정 파일: ${p.configFile}`,
+    `번역을 맡기는 곳: ${labelOf(cfg.provider)}`,
+    `키: ${key}`,
+    `번역: ${cfg.from} → ${cfg.to}`,
+    `모델: ${cfg.model}`,
+    // 있는지만 말한다. 로그인 값 자체는 어느 화면에도 안 찍는다.
+    `쌓기: ${storing}`,
+    `아직 못 보낸 것: ${waiting}개`,
+    `쌓인 번역: ${cached}개`,
+    'Claude Code v2.1.196 이상이 필요해요 — 그보다 낮으면 상태줄이 계속 비어 있어요.',
+    '',
+  ].join('\n'))
+}
+
+// Claude Code 의 설정 파일. 우리 것이 아니라 조심해서 만진다.
+function claudeSettingsFile(env = process.env) {
+  return `${env.HOME || env.USERPROFILE || '.'}/.claude/settings.json`
+}
+
+async function readTextOrNull(file) {
+  try { return await readFile(file, 'utf8') } catch { return null }
+}
+
+// 붙이기·떼기의 실제 쓰기. 판정은 settings.js 가 하고 여기선 그 결과대로
+// 움직이기만 한다. 쓰기 전에 반드시 백업한다 — 남의 설정 파일이다.
+async function applySettings(file, plan) {
+  const existed = plan.status !== 'create'
+  if (existed) {
+    const before = await readTextOrNull(file)
+    if (before !== null) await writeFile(`${file}.bak`, before)
+  }
+  await mkdir(file.slice(0, file.lastIndexOf('/')), { recursive: true })
+  await writeFile(file, JSON.stringify(plan.json, null, 2) + '\n')
+}
+
+const BLOCK = [
+  '  "statusLine": {',
+  '    "type": "command",',
+  `    "command": "${COMMAND}",`,
+  '    "refreshInterval": 5',
+  '  }',
+]
+
+async function cmdInit() {
+  const out = []
+  const p = paths(process.env)
+  const cur = await loadConfig({ file: p.configFile, readFile })
+
+  // ① 키 — 환경 변수에 이미 있으면 사본을 늘리지 않는다.
+  const envName = keyEnvFor(cur.provider)
+  const fromEnv = process.env[envName]
+  let apiKey = cur.apiKey
+  if (fromEnv) {
+    out.push(`키는 ${envName} 에 있어서 그대로 쓸게요 — 설정 파일에 옮겨 적지 않아요.`)
+  } else if (!apiKey) {
+    // 파이프로 부르거나 다른 도구 안에서 부르면 물어볼 상대가 없다.
+    // 「다시 실행해요」는 이때 거짓말이 된다 — 같은 자리에서 다시 해도
+    // 똑같다. 무엇이 막고 있는지 정확히 말한다.
+    if (!process.stdin.isTTY) {
+      out.push(`키가 아직 없어요. 여기서는 물어볼 수 없어서(터미널이 아니에요) 둘 중 하나로 넣어요.`,
+        `  · 터미널 창에서 직접 \`reverbo init\` 을 실행해요`,
+        `  · 또는 셸 설정에 \`export ${envName}=...\` 를 넣어요`)
+    } else {
+      apiKey = await askSecret({
+        input: process.stdin,
+        output: process.stdout,
+        question: `${envName} 값을 붙여넣어요 (화면에 안 보여요): `,
+      })
+      out.push(apiKey ? '키를 설정 파일에 저장했어요.' : `키를 안 넣었어요. ${envName} 를 내보내두거나 init 을 다시 실행해요.`)
+    }
+  } else {
+    out.push('키는 이미 설정 파일에 있어요.')
+  }
+  await saveConfig({ file: p.configFile, config: { ...cur, apiKey }, mkdir, writeFile, chmod })
+
+  // ②-a 보이는 방식을 고르게 한다. 지난 턴에 「원문을 띄울까」를 내가
+  // 정하려다 만 자리다 — 보여주고 고르게 하는 편이 맞다.
+  const picked = await runWizard({ ...cur, apiKey })
+  if (picked.asked) {
+    await saveConfig({ file: p.configFile, config: picked.cfg, mkdir, writeFile, chmod })
+  }
+
+  // ② 어디로 나가는지 — 고르는 게 없어졌어도 이 사실은 남는다.
+  if (cur.provider !== 'anthropic') {
+    out.push('', `─ 번역할 문장은 ${labelOf(cur.provider)} 로 나가요.`,
+      '  코드나 파일 경로가 섞인 프롬프트면 그것도 함께 가요.')
+  }
+
+  // ③ Claude Code 에 붙이기 — 사람이 복사해 넣지 않아도 되게.
+  const sf = claudeSettingsFile(process.env)
+  const plan = planInstall(await readTextOrNull(sf))
+  out.push('')
+  if (plan.status === 'already') {
+    out.push('Claude Code 에는 이미 붙어 있어요.')
+  } else if (plan.status === 'conflict') {
+    out.push(`${sf} 에 다른 상태줄이 이미 있어요 — 건드리지 않았어요.`,
+      `  지금 붙어 있는 것: ${plan.existing}`,
+      '  바꾸려면 그 줄을 지우고 init 을 다시 실행해요.')
+  } else if (plan.status === 'unparsable') {
+    out.push(`${sf} 를 읽을 수 없어서 건드리지 않았어요.`,
+      '  아래를 직접 넣어요.', '', ...BLOCK)
+  } else {
+    await applySettings(sf, plan)
+    out.push(`Claude Code 에 붙였어요 — ${sf}`)
+    if (plan.status === 'add') out.push(`  고치기 전 파일은 ${sf}.bak 에 두었어요.`)
+    out.push('Claude Code 를 새로 열면 상태줄에 떠요.')
+  }
+
+  process.stdout.write(out.join('\n') + '\n')
+}
+
+// 설정 마법사. 말로 설명하지 않고 고른 값이 어떻게 보이는지 그려준다.
+// TTY 가 아니면(파이프·다른 도구 안) 조용히 건너뛰고 지금 설정을 그대로 쓴다.
+async function runWizard(cfg) {
+  if (!process.stdin.isTTY) return { cfg, asked: false }
+  const cols = Number(process.env.COLUMNS) || process.stdout.columns || 80
+  let out = { ...cfg }
+  for (const q of QUESTIONS) {
+    const picked = await askChoice({
+      input: process.stdin,
+      output: process.stdout,
+      title: q.title,
+      note: q.note,
+      options: q.options,
+      current: currentValue(q, out),
+      next: (v) => nextValue(q, v),
+      preview: (v) => previewOf(q, v, out, Math.min(cols, 100)),
+    })
+    if (picked === undefined) return { cfg: out, asked: false } // Ctrl-C
+    out = applyAnswer(out, q.key, picked)
+  }
+  return { cfg: out, asked: true }
+}
+
+async function cmdConfig() {
+  const p = paths(process.env)
+  const cur = await loadConfig({ file: p.configFile, readFile })
+  const { cfg, asked } = await runWizard(cur)
+  if (!asked) {
+    process.stdout.write('바뀐 것 없어요.\n')
+    return
+  }
+  await saveConfig({ file: p.configFile, config: cfg, mkdir, writeFile, chmod })
+  process.stdout.write(`설정을 ${p.configFile} 에 저장했어요. Claude Code 를 새로 열면 적용돼요.\n`)
+}
+
+async function cmdUninstall() {
+  const sf = claudeSettingsFile(process.env)
+  const plan = planUninstall(await readTextOrNull(sf))
+  const say = {
+    nothing: 'Claude Code 에 붙어 있지 않아요.',
+    foreign: `우리가 붙인 게 아니라 건드리지 않았어요 — 지금 붙어 있는 것: ${plan.existing}`,
+    unparsable: `${sf} 를 읽을 수 없어서 건드리지 않았어요.`,
+  }[plan.status]
+  if (say) { process.stdout.write(say + '\n'); return }
+  await applySettings(sf, plan)
+  process.stdout.write([
+    `Claude Code 에서 뗐어요 — ${sf}`,
+    `  고치기 전 파일은 ${sf}.bak 에 두었어요.`,
+    '설정과 쌓인 번역은 그대로 있어요 — 아직 못 보낸 것도 함께요.',
+    // 폴더만 지우면 서버 쪽 연결이 끊을 방법 없이 남는다. 순서를 먼저 말한다.
+    '전부 지울 때는 reverbo logout 을 먼저 해요 — 그래야 서버 쪽 연결도 같이 끊겨요.',
+    `그다음 ${paths(process.env).base} 를 지워요.`,
+    '',
+  ].join('\n'))
+}
+
+
+const say = (s) => process.stdout.write(s + '\n')
+
+async function cmdLogin() {
+  const p = paths(process.env)
+  const cur = await loadConfig({ file: p.configFile, readFile })
+  const r = await login({
+    start: () => startPairing({ fetchImpl: globalThis.fetch, base: baseOf() }),
+    poll: (a) => pollPairing({ ...a, fetchImpl: globalThis.fetch, base: baseOf() }),
+    show: (m) => {
+      // 사람에게는 사용자코드만 보여준다. 기기코드가 화면에 찍히면 둘로
+      // 가른 의미가 없어진다.
+      if (m.kind === 'code') {
+        say(['', `코드: ${m.userCode}`, '', `${baseOf()}/cli/pair 에서 이 코드를 승인하면 이어서 진행돼요.`, ''].join('\n'))
+        return
+      }
+      // 사람이 보는 코드는 짧아서 남이 먼저 승인해버리는 경쟁이 가능하다.
+      // 어느 계정에 이어졌는지 그 자리에서 보여줘야 알아챈다 — 이 줄이
+      // 없으면 서버가 이메일을 함께 실어 보내는 이유가 사라진다.
+      if (m.kind === 'linked') say(`${m.email} 계정에 이어졌어요. 내 계정이 아니면 reverbo logout 으로 끊어요.`)
+    },
+    sleep,
+    now: () => Date.now(),
+  })
+  if (!r.ok) {
+    say({
+      expired: '코드가 만료됐어요. 다시 실행하면 새 코드가 나와요.',
+      unreachable: '서버에 닿지 못했어요. 잠시 뒤 다시 해봐요.',
+      timeout: '기다리다 그만뒀어요. 다시 실행하면 새 코드가 나와요.',
+    }[r.reason] || '로그인하지 못했어요. 다시 실행하면 새 코드가 나와요.')
+    return
+  }
+  await saveConfig({ file: p.configFile, config: { ...cur, token: r.token }, mkdir, writeFile, chmod })
+
+  // 이은 것과 쌓이는 것은 다른 사실이다. 승인은 구독을 안 보므로 여기서 한 번
+  // 물어야 「이제 쌓여요」가 거짓말이 되지 않는다. 못 닿았거나 옛 서버라
+  // 모르겠으면(null) 아무 주장도 안 하고 평소 문구만 낸다.
+  const storing = await fetchStoring({ token: r.token, fetchImpl: globalThis.fetch, base: baseOf() })
+  await markStoring(p.blocked, storing)
+  const said = storing === false
+  say(said ? '로그인했어요.' : '로그인했어요. 이제 번역한 문장이 쌓여요.')
+  if (said) say(blockedSay())
+
+  // 로그인이 죽어 있는 동안 401 로 멈춰 있던 줄이 있으면, 지금이 정확히
+  // 그걸 보낼 순간이다. 안 하면 다음 프롬프트를 칠 때까지 그대로 기다린다.
+  const waiting = String((await readTextOrNull(p.outbox)) || '').split('\n').filter(Boolean)
+  if (!waiting.length) return
+  const d = await withOutbox({
+    file: p.outbox, tries: 4,
+    run: () => drain({
+      file: p.outbox,
+      send: (e) => uploadPrompt({ entry: e, token: r.token, fetchImpl: globalThis.fetch, base: baseOf() }),
+      readFile, writeFile, rename, unlink, now: () => Date.now(),
+    }),
+  })
+  await noteBlocked(p.blocked, d)
+  if (d !== BUSY && d.sent) say(`밀려 있던 ${d.sent}개를 올렸어요.`)
+  // 위에서 이미 말했으면 두 번 말하지 않는다. 안 물어봤거나 못 물어본
+  // 경우(모름)에도 비우기가 402 를 만나면 여기서 알게 된다.
+  if (!said && d !== BUSY && d.stopped === 'blocked') say(blockedSay())
+}
+
+async function cmdLogout() {
+  const p = paths(process.env)
+  const cur = await loadConfig({ file: p.configFile, readFile })
+  const pending = String((await readTextOrNull(p.outbox)) || '').split('\n').filter(Boolean)
+  // 로그인도 안 했고 남은 것도 없으면 할 일이 없다. 남은 것이 있으면
+  // 로그인을 안 했어도 치우고 간다 — 앞선 logout 이 워커와 겹쳐 못 치우고
+  // 「잠시 뒤 다시 해요」라고 말한 뒤라면 여기가 그 「다시」다.
+  if (!cur.token && !pending.length) { say('로그인 안 했어요.'); return }
+
+  // 못 보낸 줄은 **떠나는 계정의 것**이다. 남겨두면 다음에 다른 계정으로
+  // 로그인한 워커가 그 줄들을 새 계정으로 올린다 — 로그인 화면의
+  // 「내 계정이 아니면 logout」 안내가 정확히 이 상황을 상정하고 있어서,
+  // 그 경로가 데이터를 남의 계정으로 보내면 안내가 함정이 된다.
+  //
+  // 그래서 지우기 전에 한 번 올려본다. 로그인 값은 아직 살아 있고(폐기는
+  // 아래다), 성공하면 잃는 것이 0 이 된다.
+  let cleaned = null
+  if (pending.length) {
+    cleaned = await withOutbox({
+      file: p.outbox, tries: 4,
+      run: async () => {
+        const d = cur.token
+          ? await drain({
+              file: p.outbox,
+              send: (e) => uploadPrompt({ entry: e, token: cur.token, fetchImpl: globalThis.fetch, base: baseOf() }),
+              readFile, writeFile, rename, unlink, now: () => Date.now(),
+            })
+          : { sent: 0 }
+        // 반드시 잠금 **안에서** 지운다. 밖에서 지우면, 이미 읽어둔
+        // 나머지를 쥐고 있던 워커의 drain 이 왕복을 마치며 그걸 다시 써서
+        // 지운 파일이 되살아난다.
+        try { await unlink(p.outbox) } catch {}
+        return d.sent
+      },
+    })
+  }
+
+  // 막혔다는 표시는 **떠나는 계정의 것**이다. 남겨두면 다음 계정으로
+  // 로그인한 사람의 status 가 남의 사정을 말한다.
+  try { await unlink(p.blocked) } catch {}
+
+  const out = []
+  let revoked = true
+  if (cur.token) {
+    // 서버 쪽에는 만료가 없어서 이 문이 유일한 폐기 수단이다. 여기서 안
+    // 부르고 로컬만 지우면, 설정 파일이 새는 순간(백업·화면 공유) 창이
+    // 열린 채로 영영 남는다.
+    revoked = (await revokeToken({ token: cur.token, fetchImpl: globalThis.fetch, base: baseOf() })).ok
+    // 서버가 안 닿아도 로컬은 지운다 — 나가려는 사람을 붙잡지 않는다.
+    // 번역 키는 남긴다: 로그아웃은 쌓기를 멈추는 것이지 번역을 끄는 게 아니다.
+    await saveConfig({ file: p.configFile, config: { ...cur, token: '' }, mkdir, writeFile, chmod })
+    out.push('로그아웃했어요. 더는 안 쌓여요. 이미 쌓인 것은 대시보드에서 지울 수 있어요.')
+  } else {
+    out.push('로그인 안 했어요.')
+  }
+
+  const n = pending.length
+  if (cleaned === BUSY) {
+    // 못 치웠으면 지웠다고 말하지 않는다. 다시 부르면 위의 「남은 것이
+    // 있으면」 갈래로 들어와 마저 치운다.
+    out.push(`아직 못 보낸 ${n}개는 지금 정리할 수 없어요. 잠시 뒤 reverbo logout 을 한 번 더 실행해요.`)
+  } else if (cleaned === n && n > 0) {
+    out.push(`못 보낸 것 ${n}개는 마저 올렸어요.`)
+  } else if (cleaned > 0) {
+    out.push(`못 보낸 것 ${n}개 중 ${cleaned}개는 올리고 나머지는 지웠어요 — 떠나는 계정의 것이라 다음 계정으로 올라가면 안 돼요.`)
+  } else if (n > 0) {
+    out.push(`못 보낸 ${n}개는 지웠어요 — 떠나는 계정의 것이라 다음 계정으로 올라가면 안 돼요.`)
+  }
+
+  // 지웠다는 말만 하고 끝내면 서버 쪽이 아직 열려 있는 걸 아무도 모른다.
+  // 여기서는 「다시 실행해요」가 거짓말이 된다 — 이 기계엔 이미 값이 없다.
+  if (cur.token && !revoked) out.push('서버에는 알리지 못했어요 — 이 기계에서는 지웠어요.')
+  say(out.join('\n'))
+}
+
+async function cmdSync(argv) {
+  const p = paths(process.env)
+  const pending = String((await readTextOrNull(p.outbox)) || '').split('\n').filter(Boolean)
+
+  if (argv.includes('--dry-run')) {
+    say(`보낼 것 ${pending.length}개`)
+    for (const line of pending) {
+      try {
+        const first = String(JSON.parse(line).source || '').split('\n')[0]
+        say('  ' + (first.length > 60 ? first.slice(0, 60) + '…' : first))
+      } catch {
+        // 깨진 줄이다 — 개수에는 세되 못 읽는 것을 그리지는 않는다
+      }
+    }
+    return
+  }
+
+  const cfg = await cfgOf(p.configFile)
+  if (!cfg.token) { say('로그인하면 보낼 수 있어요.'); return }
+  if (pending.length === 0) { say('보낼 게 없어요.'); return }
+
+  // 워커가 같은 파일을 비우는 중일 수 있다. 겹치면 서로의 쓰기를 덮어쓴다.
+  const r = await withOutbox({
+    file: p.outbox, tries: 4,
+    run: () => drain({
+      file: p.outbox,
+      send: (e) => uploadPrompt({ entry: e, token: cfg.token, fetchImpl: globalThis.fetch, base: baseOf() }),
+      readFile, writeFile, rename, unlink,
+    }),
+  })
+  if (r === BUSY) {
+    say('지금 다른 데서 보내는 중이에요. 잠시 뒤 다시 해요.')
+    return
+  }
+  await noteBlocked(p.blocked, r)
+  say(`${r.sent}개 보냈어요. ${r.kept}개 남았어요.`)
+  // 왜 멈췄는지 말하지 않으면 「0개 보냈어요. 0개 남았어요.」만 보고 끝난다.
+  if (r.stopped === 'auth') say('로그인이 만료됐어요. reverbo login 하면 이어서 올라가요.')
+  if (r.stopped === 'retry') say('지금은 다 못 보냈어요. 잠시 뒤 다시 해요.')
+  // 구독은 재로그인으로 안 풀린다 — 'auth' 와 같은 말을 하면 될 리 없는
+  // 일을 반복하게 만든다.
+  if (r.stopped === 'blocked') say(blockedSay())
+}
+
+export async function main(argv) {
+  try {
+    switch (argv[0]) {
+      case 'statusline': await cmdStatusline(); break
+      case '__worker': await cmdWorker(); break
+      case 'status': await cmdStatus(); break
+      case 'init': await cmdInit(); break
+      case 'config': await cmdConfig(); break
+      case 'login': await cmdLogin(); break
+      case 'logout': await cmdLogout(); break
+      case 'sync': await cmdSync(argv); break
+      case 'uninstall': await cmdUninstall(); break
+      default:
+        process.stdout.write('쓸 수 있는 명령: init · config · login · logout · sync · status · uninstall\n')
+    }
+  } catch {
+    // 스펙 D8 — 어떤 경우에도 0 으로 끝난다
+  }
+  process.exitCode = 0
+}