lostvibe 0.0.0-stage → 0.8.0

package/bin/lostvibe.mjs

@@ -0,0 +1,753 @@
+#!/usr/bin/env node
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync, spawn } from 'node:child_process';
+import { scanAll, stripLocal, readJson, scanEntry } from '../src/scan.mjs';
+import { landTable, projectTable } from '../src/table.mjs';
+import { askReported } from '../src/reported.mjs';
+import { resolveCwd, sha, projectIdentity } from '../src/gitinfo.mjs';
+import { push } from '../src/push.mjs';
+import {
+  registerCurrent,
+  registerProject,
+  setMerge,
+  mergeMap,
+  activeConnection,
+  selectedProjects,
+  siteOf,
+  request,
+  sendStatus,
+  saveJson,
+  currentIdentity,
+} from '../src/connections.mjs';
+import { addCollector, removeCollector, collect, testCollector, collectorCwd } from '../src/collectors.mjs';
+import { installHooks, removeHooks, hookStatus, statusLines, installLines } from '../src/hooks.mjs';
+
+const DEFAULT_SITE = 'https://lostvibesociety.com';
+
+function parse(argv) {
+  const o = { _: [], root: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--all') o.all = true;
+    else if (a === '--ask') o.ask = true;
+    else if (a === '--yes' || a === '-y') o.yes = true;
+    else if (a === '--quiet' || a === '-q') o.quiet = true;
+    else if (a === '--detail') o.detail = true;
+    else if (a === '--out') o.out = argv[++i];
+    else if (a === '--root') o.root.push(argv[++i]);
+    else if (a === '--token') o.token = argv[++i];
+    else if (a === '--site') o.site = argv[++i];
+    else if (a === '--project') o.project = argv[++i];
+    else if (a === '--file') o.file = argv[++i];
+    else if (a === '--slot') o.slot = argv[++i];
+    else if (a === '--command-json') o.commandJson = argv[++i];
+    else if (a === '--client') o.client = argv[++i];
+    else if (a === '--no-hooks') o.noHooks = true;
+    else if (a === '--only') o.only = argv[++i];
+    else if (a === '--json') o.json = true;
+    else if (a === '--source') o.source = argv[++i];
+    else if (a === '--merge') o.merge = argv[++i];
+    else if (a === '--of') o.of = argv[++i];
+    else if (a === '--from') o.from = argv[++i];
+    else if (a === '--cwd') o.cwd = argv[++i];
+    else if (a === '-h' || a === '--help') o.help = true;
+    else o._.push(a);
+  }
+  return o;
+}
+
+const HELP = `lostvibe - 프로젝트의 객관 지표를 뽑는다
+
+  lostvibe scan [폴더]       폴더 하나를 읽어 그 폴더에 lostvibe.json 저장
+  lostvibe scan --all        로그 전체에서 내 프로젝트를 전부 찾아 표로 출력
+  lostvibe scan --all --json 같은 목록을 JSON 하나로만 출력 (~/.lostvibe/scan-all.json 에도 저장)
+  lostvibe login --token T   이 컴퓨터를 내 땅에 연결한다
+  lostvibe setup             현재 폴더의 프로젝트를 비공개로 등록하고 이 컴퓨터와 연결 (git 없어도 돼요)
+  lostvibe setup --source ID 폴더 없이 로그만 남은 프로젝트를 등록 (scan --all 의 id, 어느 폴더에서나)
+  lostvibe setup --merge ID[,ID]
+                            scan --all 의 다른 프로젝트를 이 프로젝트 기록에 합친다
+  lostvibe draft --file F [--of N] [--project ID]
+                            AI가 만든 JSON을 검토할 초안으로 보낸다 (--of: 가져오는 프로젝트 수)
+  lostvibe sync              등록한 프로젝트의 바뀐 기록만 올린다
+  lostvibe hooks install     기존 훅을 보존하며 자동 갱신 연결 (Stop, SessionEnd)
+  lostvibe hooks status      클라이언트별 상태: 미설치 / 설치됨·승인 전 / 승인됨·실행 기록 없음 / 실행됨
+  lostvibe hooks remove      Lostvibe 훅만 제거
+  lostvibe collector add --project ID --slot result --command-json '["node","script.mjs"]' [--cwd 폴더]
+                            프로젝트 성과 조회 명령을 등록 (--cwd 는 프로젝트 폴더 안)
+  lostvibe collector test --command-json '[...]' [--cwd 폴더] [--project ID]
+                            보내지 않고 실행만 해서 값을 확인
+  lostvibe collector remove --project ID --slot result
+  lostvibe collect            연결한 성과를 읽어 갱신
+  lostvibe push              --all 결과를 확인하고 올린다
+  lostvibe hook              세션 종료 훅에서 동기화를 백그라운드로 실행한다
+  lostvibe metrics-token --project ID --file .lostvibe/metrics-token
+                            지표 전용 키를 출력 없이 저장한다
+
+옵션
+  --ask          사람 입력 항목을 다시 묻는다
+  --out 폴더     --all 결과 저장 위치 (기본 ~/.lostvibe)
+  --root 폴더    이 폴더 바로 아래 레포도 후보에 넣는다 (--all)
+  --detail       프로젝트별 상세 표도 출력 (--all)
+  --only a,b     등록한 프로젝트 중 선택 (이름 또는 ID)
+  --no-hooks     setup 에서 훅 설치를 건너뛴다
+  --yes          push 확인을 건너뛴다
+  --quiet        출력 없이 돈다 (sync)
+  --site URL     push 대상 (기본 ${DEFAULT_SITE})
+
+환경변수 GITHUB_TOKEN, VERCEL_TOKEN 은 선택이다. 없으면 로그인된 gh, vercel 을 쓰고, 그것도 없으면 건너뛴다.`;
+
+const progress = (m) => {
+  if (process.stderr.isTTY) process.stderr.write(`\r\x1b[K${m}`);
+};
+const doneProgress = () => {
+  if (process.stderr.isTTY) process.stderr.write('\r\x1b[K');
+};
+
+function logRetentionHint(land) {
+  try {
+    const f = path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'), 'settings.json');
+    const s = readJson(f);
+    if (!s || s.cleanupPeriodDays === undefined) {
+      console.log('\n주의: Claude Code는 기본 설정이면 오래된 로그를 지운다. 사라진 토큰은 복구할 수 없다.');
+      console.log('      ~/.claude/settings.json 의 cleanupPeriodDays 를 크게 늘려 두는 편이 안전하다.');
+    }
+  } catch {
+    /* hint only */
+  }
+  if (land.log_coverage_from) console.log(`로그가 남아 있는 가장 오래된 날: ${land.log_coverage_from}`);
+}
+
+async function scanMany(o) {
+  const out = path.resolve(o.out || process.env.LOSTVIBE_DIR || path.join(os.homedir(), '.lostvibe'));
+  fs.mkdirSync(out, { recursive: true });
+  const landFile = path.join(out, 'land.json');
+  const prevById = previousReported(out);
+  const land = await scanAll({
+    extraRoots: o.root,
+    onProgress: o.json ? () => {} : progress,
+    cacheDir: homeDir(o),
+    reportedFor: (id) => prevById.get(id),
+  });
+  doneProgress();
+  if (o.ask && !o.json) {
+    for (const p of land.projects) p.reported = await askReported(p.project.name, p.reported);
+  }
+  const clean = { ...land, projects: land.projects.map(stripLocal) };
+  fs.writeFileSync(landFile, `${JSON.stringify(clean, null, 2)}\n`);
+  // The full list with local paths stays on this computer. setup --source / --merge read it.
+  const entries = land.projects.map(scanEntry);
+  const scanFile = path.join(out, 'scan-all.json');
+  saveJson(scanFile, {
+    scanned_at: land.scanned_at,
+    projects: entries.map((e, i) => ({
+      ...e,
+      folder: land.projects[i]._local?.folder || null,
+      cwds: land.projects[i]._local?.cwds || [],
+    })),
+  });
+  if (o.json) {
+    process.stdout.write(`${JSON.stringify({ projects: entries })}\n`);
+    return;
+  }
+  console.log(landTable(land));
+  if (o.detail) for (const p of land.projects) console.log(projectTable(p));
+  console.log(`\n프로젝트 ${land.projects.length}개. 어느 프로젝트에도 속하지 않는 임시 폴더 토큰은 뺐다.`);
+  logRetentionHint(land);
+  console.log(`저장: ${landFile}`);
+}
+
+// reported answers from the last scan --all and the last sync, sync winning.
+function previousReported(dir) {
+  const map = new Map();
+  for (const f of ['land.json', 'sync-land.json'])
+    for (const p of readJson(path.join(dir, f))?.projects || []) if (p?.project?.id) map.set(p.project.id, p.reported);
+  return map;
+}
+
+function readScanAll(o) {
+  const scan = readJson(path.join(homeDir(o), 'scan-all.json'));
+  if (!scan?.projects) throw new Error('먼저 scan --all 을 실행해 주세요.');
+  return scan.projects;
+}
+const rootsOf = (e) => (e.folder ? [path.dirname(e.folder)] : []);
+
+async function scanOne(o) {
+  const dir = path.resolve(o._[1] || '.');
+  const file = path.join(dir, 'lostvibe.json');
+  const prev = readJson(file);
+  const target = resolveCwd(dir);
+  const land = await scanAll({
+    extraRoots: [path.dirname(dir)],
+    onProgress: progress,
+    cacheDir: homeDir(o),
+    reportedFor: () => prev?.reported,
+  });
+  doneProgress();
+  const id = projectIdentity(target.repoPath, target.key);
+  let p = land.projects.find((x) => x.project.id === id);
+  if (!p) {
+    console.error('이 폴더에서 읽을 수 있는 git 기록과 AI 로그를 찾지 못했다.');
+    process.exit(1);
+  }
+  const shouldAsk = o.ask || (!prev?.reported?.answered_at && process.stdin.isTTY);
+  if (shouldAsk) {
+    p.reported = await askReported(p.project.name, p.reported);
+    if (p.verified.ai && p.reported.launch_date) {
+      let before = 0;
+      let after = 0;
+      for (const d of p.verified.ai.daily_tokens) {
+        if (d.date < p.reported.launch_date) before += d.tokens;
+        else after += d.tokens;
+      }
+      p.verified.ai.before_launch_tokens = before;
+      p.verified.ai.after_launch_tokens = after;
+    }
+  }
+  p = stripLocal(p);
+  fs.writeFileSync(file, `${JSON.stringify(p, null, 2)}\n`);
+  console.log(projectTable(p));
+  console.log(`\n저장: ${file}`);
+  try {
+    execFileSync('git', ['-C', dir, 'check-ignore', '-q', 'lostvibe.json'], { stdio: 'ignore' });
+  } catch {
+    console.log('이 파일은 .gitignore 에 없다. 올리지 않으려면 추가해 두는 편이 낫다.');
+  }
+}
+
+const homeDir = (o) =>
+  path.resolve(o.out || process.env.LOSTVIBE_DIR || path.join(os.homedir(), '.lostvibe'));
+
+function savedToken(o) {
+  if (o.token || process.env.LOSTVIBE_TOKEN) return o.token || process.env.LOSTVIBE_TOKEN;
+  try {
+    return fs.readFileSync(path.join(homeDir(o), 'token'), 'utf8').trim();
+  } catch {
+    return null;
+  }
+}
+
+const NO_TOKEN =
+  '연결되어 있지 않다. 사이트 You 탭의 연결 설정에서 "다른 컴퓨터용 토큰 받기"를 눌러 받은 명령을 실행한다.';
+
+function loginCmd(o) {
+  if (!o.token) {
+    console.error('--token 이 필요하다.');
+    process.exit(1);
+  }
+  const dir = homeDir(o);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'token'), o.token, { mode: 0o600 });
+  fs.chmodSync(path.join(dir, 'token'), 0o600);
+  console.log('이 컴퓨터를 연결했다. 이제 lostvibe sync 로 올린다.');
+}
+
+// Fingerprints upload payloads; unchanged data is omitted, while connection/status checks still run.
+function fingerprint(p) {
+  const { scanned_at: _ignored, ...rest } = p;
+  return crypto.createHash('sha256').update(JSON.stringify(rest)).digest('hex').slice(0, 24);
+}
+
+function writeAtomic(file, data) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(data), { mode: 0o600 });
+  fs.renameSync(tmp, file);
+}
+function deviceId(dir) {
+  const file = path.join(dir, 'device-id');
+  try {
+    return fs.readFileSync(file, 'utf8').trim();
+  } catch {
+    /* first connection */
+  }
+  const id = crypto.randomBytes(16).toString('hex');
+  try {
+    fs.writeFileSync(file, id, { mode: 0o600, flag: 'wx' });
+  } catch {
+    return fs.readFileSync(file, 'utf8').trim();
+  }
+  return id;
+}
+async function syncCmd(o) {
+  const token = savedToken(o);
+  if (!token) throw new Error(NO_TOKEN);
+  const linked = selectedProjects(o);
+  if (!linked.length) {
+    if (!o.quiet) console.log('먼저 이 프로젝트 폴더에서 lostvibe setup을 실행해 주세요.');
+    return;
+  }
+  const site = siteOf(o);
+  const connection = await request(site, token, '/api/me/connection');
+  const remoteIds = new Set(connection.projects.map((p) => p.id));
+  const skipped = new Set((connection.skipped || []).map((p) => p.sourceId));
+  const allowed = linked.filter((p) => remoteIds.has(p.id) && !skipped.has(p.sourceId));
+  if (!allowed.length) return;
+  const dir = homeDir(o);
+  fs.mkdirSync(dir, { recursive: true });
+  const lock = path.join(dir, 'sync.lock');
+  try {
+    fs.writeFileSync(lock, String(process.pid), { flag: 'wx' });
+  } catch {
+    let running = false;
+    try {
+      process.kill(Number(fs.readFileSync(lock, 'utf8')), 0);
+      running = true;
+    } catch {
+      /* stale lock */
+    }
+    if (running) {
+      for (const p of allowed) fs.writeFileSync(path.join(dir, `sync-pending-${p.id}`), '1', { mode: 0o600 });
+      if (!o.quiet) console.log('실행 중인 동기화 뒤에 다시 갱신해요.');
+      return;
+    }
+    fs.rmSync(lock, { force: true });
+    fs.writeFileSync(lock, String(process.pid), { flag: 'wx' });
+  }
+  try {
+    const namespace = sha(`${site}:${token}`);
+    const sentFile = path.join(dir, `sent-v4-${namespace}.json`);
+    const sent = readJson(sentFile) || {};
+    const prevById = previousReported(dir);
+    const merge = mergeMap(allowed);
+    const land = await scanAll({
+      // Folders without git are placed by their parent folder, so every known parent is a root.
+      extraRoots: [
+        ...o.root,
+        ...allowed.filter((p) => p.cwd).map((p) => path.dirname(p.cwd)),
+        ...allowed.flatMap((p) => p.roots || []),
+      ],
+      cacheDir: dir,
+      only: new Set([...allowed.map((p) => p.sourceId), ...merge.keys()]),
+      merge,
+      onProgress: o.quiet ? () => {} : progress,
+      reportedFor: (id) => prevById.get(id),
+    });
+    doneProgress();
+    const clean = { ...land, projects: land.projects.map(stripLocal) };
+    // Kept apart from land.json so a sync never wipes the scan --all result.
+    writeAtomic(path.join(dir, 'sync-land.json'), clean);
+    if (!clean.projects.length) {
+      if (!o.quiet)
+        console.log(
+          '프로젝트를 찾지 못했다. 프로젝트 폴더에서 다시 실행하거나 --root 로 작업 폴더를 지정해 줘.',
+        );
+      return;
+    }
+    const allowedIds = new Set(allowed.map((p) => p.sourceId));
+    const selected = clean.projects.filter((p) => allowedIds.has(p.project.id));
+    const changed = [];
+    const rowKey = (r) => `${r.date}|${r.tool}|${r.model}`;
+    const metaOf = (p) => {
+      const { usage_days: _rows, ...metadata } = p;
+      return fingerprint({ ...metadata, verified: { ...metadata.verified, ai: null } });
+    };
+    for (const p of selected) {
+      const previous = sent[p.project.id] || {};
+      const rows = p.usage_days.filter((r) => previous.rows?.[rowKey(r)] !== fingerprint(r));
+      if (rows.length || previous.meta !== metaOf(p)) changed.push({ ...p, usage_days: rows });
+    }
+    if (!changed.length) {
+      for (const p of allowed) await sendStatus(site, token, p.id, 'records', true);
+      if (!o.quiet) console.log('바뀐 것이 없다. 보내지 않았다.');
+      return;
+    }
+    await push({
+      projects: changed,
+      token,
+      site,
+      yes: true,
+      quiet: o.quiet,
+      deviceId: deviceId(dir),
+      onAccepted: async (p) => {
+        const record = sent[p.project.id] || { rows: {} };
+        record.meta = metaOf(p);
+        for (const r of p.usage_days || []) record.rows[rowKey(r)] = fingerprint(r);
+        sent[p.project.id] = record;
+        writeAtomic(sentFile, sent);
+        const linkedProject = allowed.find((x) => x.sourceId === p.project.id);
+        if (linkedProject) await sendStatus(site, token, linkedProject.id, 'records', true);
+      },
+    });
+  } finally {
+    fs.rmSync(lock, { force: true });
+    for (const file of fs.readdirSync(dir).filter((n) => /^sync-pending-[a-f0-9]{12,32}$/.test(n))) {
+      fs.rmSync(path.join(dir, file), { force: true });
+      const id = file.slice('sync-pending-'.length);
+      const p = selectedProjects({ ...o, project: undefined, only: undefined }).find((p) => p.id === id);
+      if (!p) continue;
+      const log = fs.openSync(path.join(dir, 'sync.log'), 'a', 0o600);
+      const child = spawn(
+        process.execPath,
+        [process.argv[1], 'worker', '--quiet', '--out', dir, '--site', site, '--project', p.id],
+        { cwd: p.cwd && fs.existsSync(p.cwd) ? p.cwd : dir, detached: true, stdio: ['ignore', log, log], windowsHide: true },
+      );
+      child.unref();
+      fs.closeSync(log);
+    }
+  }
+}
+// The registered project a session folder belongs to: its own id, a merged id, or (without git) a parent folder.
+function linkedFor(cwd, projects) {
+  const target = resolveCwd(cwd);
+  const ids = [projectIdentity(target.repoPath, target.key)];
+  if (!target.repoPath)
+    for (let d = path.dirname(cwd); d !== path.dirname(d) && d !== os.homedir(); d = path.dirname(d))
+      ids.push(projectIdentity(null, `folder:${path.basename(d).toLowerCase()}`));
+  for (const id of ids) {
+    const p = projects.find((x) => x.sourceId === id) || projects.find((x) => (x.merge || []).includes(id));
+    if (p) return p;
+  }
+  return null;
+}
+const STOP_GAP_MS = 10 * 60 * 1000;
+function hookCmd(o) {
+  // Detached child survives the short SessionEnd deadline on both clients.
+  let cwd = process.cwd();
+  let event = null;
+  try {
+    const payload = o._[1]
+      ? JSON.parse(o._[1])
+      : !process.stdin.isTTY
+        ? JSON.parse(fs.readFileSync(0, 'utf8'))
+        : {};
+    if (payload.cwd && fs.existsSync(payload.cwd)) cwd = payload.cwd;
+    if (typeof payload.hook_event_name === 'string') event = payload.hook_event_name.slice(0, 40);
+  } catch {
+    /* no notification payload */
+  }
+  const dir = homeDir(o);
+  fs.mkdirSync(dir, { recursive: true });
+  const from = ['claude', 'codex'].includes(o.from) ? o.from : null;
+  const at = new Date().toISOString();
+  try {
+    const last = readJson(path.join(dir, 'hook-last.json')) || {};
+    const clients = { ...(last.clients || {}), ...(from ? { [from]: { event, at } } : {}) };
+    saveJson(path.join(dir, 'hook-last.json'), { from, event, at, clients });
+  } catch {
+    /* a record must not stop the sync */
+  }
+  const linked = linkedFor(cwd, selectedProjects(o));
+  if (!linked) return;
+  // Stop fires after every turn; one sync per 10 minutes is enough. SessionEnd always syncs.
+  const stamp = path.join(dir, `hook-spawn-${linked.id}`);
+  if (event === 'Stop') {
+    const prev = Number(readJson(stamp)?.at) || 0;
+    if (Date.now() - prev < STOP_GAP_MS) return;
+  }
+  fs.writeFileSync(stamp, JSON.stringify({ at: Date.now() }), { mode: 0o600 });
+  const log = fs.openSync(path.join(dir, 'sync.log'), 'a', 0o600);
+  const args = [process.argv[1], 'worker', '--quiet', '--project', linked.id];
+  if (o.site) args.push('--site', o.site);
+  if (o.out) args.push('--out', o.out);
+  if (o.only) args.push('--only', o.only);
+  const child = spawn(process.execPath, args, {
+    cwd,
+    detached: true,
+    stdio: ['ignore', log, log],
+    windowsHide: true,
+  });
+  child.unref();
+  fs.closeSync(log);
+}
+
+async function metricsTokenCmd(o) {
+  if (!/^[a-f0-9]{12,32}$/.test(o.project || '')) throw new Error('--project 에 프로젝트 ID가 필요하다.');
+  const token = savedToken(o);
+  if (!token) throw new Error(NO_TOKEN);
+  const file = path.resolve(o.file || '.lostvibe/metrics-token');
+  const relative = path.relative(process.cwd(), file);
+  if (relative.startsWith('..') || path.isAbsolute(relative) || /[\r\n]/.test(relative))
+    throw new Error('지표 토큰 파일은 현재 프로젝트 안에 저장해야 한다.');
+  try {
+    if (fs.lstatSync(file).isSymbolicLink()) throw new Error('토큰 파일에는 심볼릭 링크를 쓸 수 없다.');
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e;
+  }
+  let inGit = false;
+  try {
+    execFileSync('git', ['rev-parse', '--show-toplevel'], { stdio: 'ignore' });
+    inGit = true;
+  } catch {
+    /* no git */
+  }
+  if (inGit) {
+    let tracked = false;
+    try {
+      execFileSync('git', ['ls-files', '--error-unmatch', relative], { stdio: 'ignore' });
+      tracked = true;
+    } catch {
+      /* untracked */
+    }
+    if (tracked) throw new Error('git에 올라가는 파일에는 토큰을 저장하지 않는다. 다른 파일을 지정해 줘.');
+    try {
+      execFileSync('git', ['check-ignore', '-q', relative], { stdio: 'ignore' });
+    } catch {
+      fs.appendFileSync(
+        '.gitignore',
+        `\n/${relative
+          .split(path.sep)
+          .join('/')
+          .replace(/([*?\[\]\\!# ])/g, '\\$1')}\n`,
+      );
+    }
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const parent = fs.realpathSync(path.dirname(file));
+  const cwd = fs.realpathSync(process.cwd());
+  if (parent !== cwd && !parent.startsWith(cwd + path.sep))
+    throw new Error('프로젝트 밖을 가리키는 폴더에는 토큰을 저장하지 않는다.');
+  const site = siteOf(o);
+  if (fs.existsSync(file)) {
+    const current = fs.readFileSync(file, 'utf8').trim();
+    const check = await fetch(`${site}/api/projects/${o.project}`, {
+      headers: { Authorization: `Bearer ${current}` },
+      signal: AbortSignal.timeout(15000),
+    });
+    if (
+      check.ok &&
+      (check.headers.get('x-lostvibe-token-scope') !== 'metrics' ||
+        check.headers.get('x-lostvibe-token-project') !== o.project)
+    )
+      throw new Error('기존 파일은 이 프로젝트의 지표 전용 토큰이 아니다. 다른 파일을 지정해 줘.');
+    if (check.ok) {
+      fs.chmodSync(file, 0o600);
+      console.log('기존 지표 전용 토큰을 재사용한다. 값은 출력하지 않았다.');
+      return;
+    }
+    if (check.status !== 401) throw new Error('기존 토큰 상태를 확인하지 못했다. 덮어쓰지 않았다.');
+  }
+  let res;
+  for (let retry = 0; ; retry++) {
+    res = await fetch(`${site}/api/me/token`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ projectId: o.project }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (res.status !== 429 || retry >= 3) break;
+    await new Promise((r) =>
+      setTimeout(r, Math.max(1, Math.min(30, Number(res.headers.get('retry-after')) || 2)) * 1000),
+    );
+  }
+  if (!res.ok) throw new Error(`지표 전용 토큰 발급 실패 (${res.status}). 응답 본문은 출력하지 않았다.`);
+  const body = await res.json();
+  if (typeof body.token !== 'string' || !/^lv_[A-Za-z0-9_-]+$/.test(body.token))
+    throw new Error('발급 응답을 읽지 못했다.');
+  fs.writeFileSync(file, body.token, {
+    mode: 0o600,
+    flag:
+      fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_TRUNC | (fs.constants.O_NOFOLLOW || 0),
+  });
+  fs.chmodSync(file, 0o600);
+  console.log('이 프로젝트의 지표 전용 토큰을 권한 600으로 저장했다. 값은 출력하지 않았다.');
+}
+
+async function pushCmd(o) {
+  const token = savedToken(o);
+  if (!token) {
+    console.error(NO_TOKEN);
+    process.exit(1);
+  }
+  const out = homeDir(o);
+  const land = readJson(path.join(out, 'land.json'));
+  if (!land) {
+    console.error('먼저 lostvibe scan --all 을 실행해야 한다.');
+    process.exit(1);
+  }
+  const names = o.only ? new Set(o.only.split(',').map((s) => s.trim().toLowerCase())) : null;
+  const projects = land.projects.filter((p) => !names || names.has(p.project.name.toLowerCase()));
+  if (!projects.length) {
+    console.error('보낼 프로젝트가 없다.');
+    process.exit(1);
+  }
+  await push({
+    projects,
+    token,
+    deviceId: deviceId(out),
+    site: o.site || process.env.LOSTVIBE_SITE || DEFAULT_SITE,
+    yes: o.yes,
+  });
+}
+
+async function setupCmd(o) {
+  const token = savedToken(o);
+  if (!token) throw new Error(NO_TOKEN);
+  const ids = (o.merge || '')
+    .split(',')
+    .map((x) => x.trim())
+    .filter(Boolean);
+  // Read the scan list before touching anything, so a wrong id changes nothing.
+  const scan = o.source || ids.length ? readScanAll(o) : [];
+  let entry = null;
+  if (o.source) {
+    entry = scan.find((e) => e.id === o.source);
+    if (!entry) throw new Error('scan --all 목록에 없는 id예요. scan --all --json 을 다시 실행해 확인해 주세요.');
+    if (entry.setup === 'folder' && entry.path)
+      throw new Error(`이 프로젝트는 폴더가 있어요. 그 폴더에서 setup을 실행해 주세요: ${entry.path}`);
+  }
+  const merged = ids.map((id) => {
+    const e = scan.find((x) => x.id === id);
+    if (!e) throw new Error(`scan --all 목록에 없는 id예요: ${id}`);
+    return e;
+  });
+  // Validate the account before replacing a saved key.
+  await request(siteOf(o), token, '/api/me/connection');
+  if (o.token) loginCmd(o);
+  let p = entry
+    ? await registerProject(o, token, { sourceId: entry.id, name: entry.name, cwd: null, roots: rootsOf(entry) })
+    : await registerCurrent(o, token);
+  if (merged.length) {
+    const own = selectedProjects({ ...o, project: undefined, only: undefined });
+    for (const e of merged) {
+      if (e.id === p.sourceId) throw new Error('자기 자신은 합칠 수 없어요.');
+      const other = own.find((x) => x.sourceId === e.id);
+      if (other) throw new Error(`이미 따로 연결한 프로젝트는 합칠 수 없어요: ${other.name}`);
+    }
+    p = setMerge(o, p.sourceId, merged.map((e) => e.id), merged.flatMap(rootsOf));
+    console.log(`합친 프로젝트: ${merged.map((e) => e.name).join(', ')}`);
+  }
+  await syncCmd({ ...o, project: p.id });
+  if (!o.noHooks) {
+    try {
+      for (const line of installLines(o, installHooks(o))) console.log(line);
+    } catch (e) {
+      console.log(`자동 갱신 설정 필요: ${e.message}`);
+    }
+  }
+  console.log(`프로젝트 연결됨 (id ${p.id}) · 공개 범위는 사이트에서 직접 선택해 주세요. ${siteOf(o)}/?p=${p.id}`);
+}
+async function draftCmd(o) {
+  if (!o.file) throw new Error('--file 에 프로젝트 JSON 파일을 지정해 주세요.');
+  const source = fs.readFileSync(path.resolve(o.file), 'utf8');
+  if (Buffer.byteLength(source) > 64000) throw new Error('파일은 64KB까지예요.');
+  const data = JSON.parse(source);
+  if (!data || typeof data !== 'object' || Array.isArray(data)) throw new Error('프로젝트 JSON이 필요해요.');
+  const validOf = (v) => Number.isInteger(v) && v >= 1 && v <= 200;
+  let importOf = data.importOf;
+  if (o.of !== undefined) {
+    importOf = /^\d+$/.test(o.of) ? Number(o.of) : NaN;
+    if (!validOf(importOf)) throw new Error('--of 에는 1부터 200까지의 정수를 넣어 주세요.');
+  } else if (importOf !== undefined && !validOf(importOf)) throw new Error('importOf 는 1부터 200까지의 정수예요.');
+  // --project picks a linked project by id from any folder (needed for setup --source projects).
+  const p = o.project
+    ? selectedProjects(o).find((x) => x.id === o.project)
+    : selectedProjects(o).find((x) => x.sourceId === currentIdentity().sourceId);
+  if (!p) throw new Error(o.project ? '연결한 프로젝트 중에 이 id가 없어요.' : '이 폴더에서 먼저 setup을 실행해 주세요.');
+  // Never send file-provided publication settings or arbitrary fields.
+  const keys = [
+    'version',
+    'name',
+    'oneLiner',
+    'tags',
+    'idea',
+    'design',
+    'texts',
+    'url',
+    'kind',
+    'look',
+    'launchDate',
+    'launched',
+    'resultName',
+    'resultValue',
+    'resultGoal',
+    'result2Name',
+    'result2Value',
+    'result2Goal',
+  ];
+  const safe = Object.fromEntries(keys.filter((k) => k in data).map((k) => [k, data[k]]));
+  if (importOf !== undefined) safe.importOf = importOf;
+  await request(siteOf(o), savedToken(o), `/api/me/projects/${p.id}`, 'PATCH', safe);
+  console.log(`비공개 검토 초안을 보냈어요 (id ${p.id}). ${siteOf(o)}/?p=${p.id}`);
+}
+async function collectorCmd(o) {
+  if (o._[1] === 'remove') {
+    removeCollector(o);
+    console.log('성과 자동 갱신 연결을 해제했어요.');
+    return;
+  }
+  if (o._[1] === 'test') {
+    await testCollector(o);
+    return;
+  }
+  if (o._[1] !== 'add') throw new Error('collector add, test 또는 remove를 지정해 주세요.');
+  if (!['result', 'result2'].includes(o.slot)) throw new Error('--slot result 또는 result2가 필요해요.');
+  const p = selectedProjects(o).find((p) => p.id === o.project);
+  if (!p) throw new Error('먼저 프로젝트를 연결해 주세요.');
+  collectorCwd(p.cwd, o.cwd);
+  const info = await request(siteOf(o), savedToken(o), `/api/projects/${p.id}`);
+  const nameKey = o.slot === 'result' ? 'resultName' : 'result2Name';
+  if (!(info[o.slot]?.name || info.pendingDraft?.[nameKey]))
+    throw new Error(`성과 이름이 아직 없어요. project.json에 ${nameKey}을 넣고 draft를 먼저 실행해 주세요.`);
+  const previous = process.cwd();
+  try {
+    process.chdir(p.cwd);
+    await metricsTokenCmd({ ...o, file: `.lostvibe/metrics-token-${p.id}` });
+  } finally {
+    process.chdir(previous);
+  }
+  addCollector(o);
+  console.log('성과 조회 명령을 등록했어요. collect로 실제 값을 확인할 수 있어요.');
+}
+async function workerCmd(o) {
+  let failed = false;
+  let recordsOk = true;
+  try {
+    await syncCmd(o);
+  } catch {
+    failed = true;
+    recordsOk = false;
+    console.error(`${new Date().toISOString()} 작업 기록 갱신 실패`);
+    for (const p of selectedProjects(o)) await sendStatus(siteOf(o), savedToken(o), p.id, 'records', false);
+  }
+  try {
+    await collect(o, savedToken(o));
+  } catch {
+    failed = true;
+    console.error(`${new Date().toISOString()} 성과 갱신 실패 · 이전 값 유지`);
+  }
+  console.log(`${new Date().toISOString()} 자동 갱신 ${failed ? '일부 실패' : '완료'}`);
+  try {
+    const file = path.join(homeDir(o), 'last-sync.json');
+    const at = new Date().toISOString();
+    // lastOkAt: the last time records reached the site.
+    saveJson(file, { at, ok: !failed, lastOkAt: recordsOk ? at : readJson(file)?.lastOkAt || null });
+  } catch {
+    /* status file only */
+  }
+  if (failed) process.exitCode = 1;
+}
+
+const o = parse(process.argv.slice(2));
+const cmd = o._[0];
+try {
+  if (o.help || !cmd) console.log(HELP);
+  else if (cmd === 'scan' && o.all) await scanMany(o);
+  else if (cmd === 'scan') await scanOne(o);
+  else if (cmd === 'push') await pushCmd(o);
+  else if (cmd === 'login') loginCmd(o);
+  else if (cmd === 'sync') await syncCmd(o);
+  else if (cmd === 'hook') hookCmd(o);
+  else if (cmd === 'metrics-token') await metricsTokenCmd(o);
+  else if (cmd === 'setup') await setupCmd(o);
+  else if (cmd === 'draft') await draftCmd(o);
+  else if (cmd === 'collect') await collect(o, savedToken(o));
+  else if (cmd === 'collector') await collectorCmd(o);
+  else if (cmd === 'worker') await workerCmd(o);
+  else if (cmd === 'hooks') {
+    if (o._[1] === 'install') for (const line of installLines(o, installHooks(o))) console.log(line);
+    else if (o._[1] === 'remove') {
+      removeHooks(o);
+      console.log('Lostvibe 훅만 제거했어요. 다른 훅은 그대로예요.');
+    } else if (o._[1] === 'status') for (const line of statusLines(hookStatus(o))) console.log(line);
+    else throw new Error('hooks install / status / remove');
+  } else {
+    console.log(HELP);
+    process.exit(1);
+  }
+} catch (e) {
+  doneProgress();
+  console.error(e.message);
+  process.exit(1);
+}