charge-connect 0.1.3 → 0.1.5

package/cli.js

@@ -2,15 +2,17 @@
 // charge-connect CLI — 앱에서 받은 페어링 코드로 연결하고 자동 수집을 등록한다.
 //
 // 사용법:
-//   npx charge-connect <페어링코드>   # 페어링 + 첫 수집 + 스케줄 등록 (일반 사용자용 원라이너)
+//   npx charge-connect <페어링코드> [--label 이름]  # 페어링 + 첫 수집 + 스케줄 등록 (원라이너)
+//                                    # --label(또는 CHARGE_LABEL)로 앱에 표시될 기기명 지정, 기본은 호스트명
 //   charge-connect run               # 수집 1회 (스케줄러가 호출)
-//   charge-connect unpair            # 페어링 해제
+//   charge-connect unpair            # 페어링 해제 (서버 디바이스 토큰도 폐기)
 //
 // 설정 파일: ~/.charge/config.json (CHARGE_HOME으로 위치 변경 가능)
 
 const fs = require("node:fs");
 const path = require("node:path");
 const { execFileSync } = require("node:child_process");
+const { CCUSAGE_PKG } = require("./collect.js"); // 버전 고정을 한 곳에서 관리
 
 const HOME = process.env.HOME ?? process.env.USERPROFILE;
 const CONF_DIR = process.env.CHARGE_HOME ?? path.join(HOME, ".charge");
@@ -28,6 +30,17 @@ const CLOUD = (() => {
   }
 })();
 
+// 앱 기기 목록에 표시될 이름 — 기본은 호스트명이지만 실명이 든 경우가 흔하므로
+// 최초 페어링 때 --label 또는 CHARGE_LABEL로 덮어쓸 수 있게 하고, 무엇으로 등록되는지 알려준다.
+// 주의: 라벨은 서버가 같은 머신을 알아보는 유일한 키다(중복제거). 이미 페어링된 머신을
+// 다른 라벨로 재페어링하면 새 디바이스로 잡혀 일별 사용량이 이중 집계되므로, 사후 변경은 권하지 않는다.
+function resolveLabel() {
+  const i = process.argv.indexOf("--label");
+  const flag = i > -1 && process.argv[i + 1] && !process.argv[i + 1].startsWith("-") ? process.argv[i + 1] : null;
+  const raw = flag ?? process.env.CHARGE_LABEL ?? require("node:os").hostname();
+  return String(raw).trim().slice(0, 64) || require("node:os").hostname();
+}
+
 async function pair(code) {
   const url = process.env.CHARGE_URL ?? CLOUD.url;
   const anon = process.env.CHARGE_ANON ?? CLOUD.anon;
@@ -35,10 +48,11 @@ async function pair(code) {
     console.error("백엔드 주소가 없습니다 (collector/cloud.json 또는 CHARGE_URL/CHARGE_ANON).");
     process.exit(1);
   }
+  const label = resolveLabel();
   const res = await fetch(`${url}/rest/v1/rpc/charge_claim_pairing_code`, {
     method: "POST",
     headers: { apikey: anon, Authorization: `Bearer ${anon}`, "Content-Type": "application/json" },
-    body: JSON.stringify({ p_code: code, p_label: require("node:os").hostname() }),
+    body: JSON.stringify({ p_code: code, p_label: label }),
     signal: AbortSignal.timeout(15_000),
   });
   const token = res.ok ? await res.json() : null;
@@ -52,7 +66,29 @@ async function pair(code) {
   try { fs.chmodSync(CONF_DIR, 0o700); } catch {}
   fs.writeFileSync(CONF, JSON.stringify({ url, anon, token }, null, 2), { mode: 0o600 });
   try { fs.chmodSync(CONF, 0o600); } catch {}
-  console.log("✓ 페어링 완료");
+  console.log(`✓ 페어링 완료 — 이 컴퓨터가 '${label}'(으)로 등록되었습니다.`);
+}
+
+// 페어링 해제: 서버의 디바이스 토큰까지 폐기한다.
+// 로컬 config만 지우면 그 토큰은 서버에서 계속 유효해, 유출됐을 경우 남이 업로드에 쓸 수 있다.
+async function unpair() {
+  let conf = null;
+  try { conf = JSON.parse(fs.readFileSync(CONF, "utf8")); } catch {}
+  if (conf?.url && conf?.anon && conf?.token) {
+    try {
+      const res = await fetch(`${conf.url}/rest/v1/rpc/charge_revoke_device`, {
+        method: "POST",
+        headers: { apikey: conf.anon, Authorization: `Bearer ${conf.anon}`, "Content-Type": "application/json" },
+        body: JSON.stringify({ p_token: conf.token }),
+        signal: AbortSignal.timeout(15_000),
+      });
+      if (!res.ok) console.error(`서버 디바이스 폐기 실패 (${res.status}) — 앱 설정의 기기 목록에서 직접 제거하세요.`);
+    } catch {
+      console.error("서버 디바이스 폐기 요청에 실패했습니다 — 앱 설정의 기기 목록에서 직접 제거하세요.");
+    }
+  }
+  fs.rmSync(CONF, { force: true });
+  console.log("✓ 페어링 해제 (스케줄 해제는 install.sh/install.ps1 안내 참고)");
 }
 
 // npx 캐시는 언제든 청소될 수 있으므로, 스케줄 등록 전에 런타임을 ~/.charge/app 으로 복사한다
@@ -96,7 +132,7 @@ async function offerCcusageInstall() {
     run("ccusage", ["--version"], { stdio: "ignore", timeout: 15_000 });
     return; // 이미 설치돼 있다
   } catch {}
-  const hint = "'npm i -g ccusage'를 해두면 수집이 빨라집니다";
+  const hint = `'npm i -g ${CCUSAGE_PKG}'를 해두면 수집이 빨라집니다`;
   // 파이프/CI처럼 물어볼 콘솔이 없으면 안내만 하고 넘어간다
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     console.log(`참고: ${hint} (지금은 npx 대체 실행으로 동작).`);
@@ -110,7 +146,8 @@ async function offerCcusageInstall() {
     return;
   }
   try {
-    run("npm", ["install", "-g", "ccusage"], { stdio: "inherit", timeout: 300_000 });
+    // 전역 설치도 버전을 고정한다 — @latest면 설치 시점 최신본의 라이프사이클 스크립트를 그대로 실행한다
+    run("npm", ["install", "-g", CCUSAGE_PKG], { stdio: "inherit", timeout: 300_000 });
     console.log("✓ ccusage 설치 완료");
   } catch {
     console.error(
@@ -131,8 +168,7 @@ async function offerCcusageInstall() {
     return;
   }
   if (arg === "unpair") {
-    fs.rmSync(CONF, { force: true });
-    console.log("✓ 페어링 해제 (스케줄 해제는 install.sh/install.ps1 안내 참고)");
+    await unpair();
     return;
   }
   // 페어링 코드로 간주: 페어링 → 스케줄 등록 → 첫 수집.

package/collect.js

@@ -22,12 +22,14 @@ const HOME = process.env.HOME ?? process.env.USERPROFILE;
 // 5분마다 도는 작업이라 그냥 이어 붙이면 끝없이 자라므로 5MB에서 .old로 민다.
 const logArg = process.argv.indexOf("--log");
 const LOG_FILE = logArg > -1 ? process.argv[logArg + 1] : null;
-if (logArg > -1 && (!LOG_FILE || LOG_FILE.startsWith("-"))) {
+// 아래 로그 리다이렉션·핸들러 등록·process.exit은 스크립트로 직접 실행될 때만 해야 한다.
+// cli.js가 버전 상수를 require할 때 이 부작용이 딸려오면 CLI 콘솔이 파일로 새거나 조기 종료된다.
+if (require.main === module && logArg > -1 && (!LOG_FILE || LOG_FILE.startsWith("-"))) {
   // 값을 안 주면 조용히 로그가 꺼지고, 다음 옵션을 삼키면 "--dry-run"이라는 파일에 쓰게 된다
   console.error("--log 뒤에는 파일 경로가 필요합니다.");
   process.exit(1);
 }
-if (LOG_FILE) {
+if (require.main === module && LOG_FILE) {
   try {
     if (fs.statSync(LOG_FILE).size > 5 * 1024 * 1024) fs.renameSync(LOG_FILE, `${LOG_FILE}.old`);
   } catch {}
@@ -63,6 +65,13 @@ const EXTRA_PATH = WIN
   : ":/opt/homebrew/bin:/usr/local/bin";
 const DEFAULT_CODEXBAR_CLI = "/Applications/CodexBar.app/Contents/Helpers/CodexBarCLI";
 
+// ccusage는 정확한 버전으로 고정한다 — @latest로 5분마다 무인 실행하면 ccusage npm
+// 계정/배포가 탈취됐을 때 별도 조작 없이 악성 코드가 모든 사용자 PC에서 돌게 된다.
+// 이 프로세스는 Claude/Codex 자격증명이 있는 홈에서 사용자 권한으로 실행되므로 위험이 크다.
+// 갱신은 릴리스마다 새 버전을 검토한 뒤 의도적으로만 올린다.
+const CCUSAGE_VERSION = "20.0.19";
+const CCUSAGE_PKG = `ccusage@${CCUSAGE_VERSION}`;
+
 // 모든 외부 명령은 비동기로 실행한다 — 동기(execFileSync)는 이벤트 루프를 세워
 // 진행 중인 fetch(AbortSignal 타이머 포함)를 전부 타임아웃시킨다.
 const execOpts = (timeout) => ({
@@ -93,9 +102,10 @@ async function runCcusage(args) {
   try {
     return JSON.parse(await runAsync("ccusage", args));
   } catch (e) {
-    console.error(`ccusage 직접 실행 실패(${e.code ?? e.message}), npx로 재시도 — 'npm i -g ccusage'를 해두면 빨라집니다`);
+    console.error(`ccusage 직접 실행 실패(${e.code ?? e.message}), npx로 재시도 — 'npm i -g ${CCUSAGE_PKG}'를 해두면 빨라집니다`);
     // --prefer-offline: npx 캐시가 있으면 레지스트리 조회 없이 재사용 (5분마다 재다운로드 방지)
-    return JSON.parse(await runAsync("npx", ["-y", "--prefer-offline", "ccusage@latest", ...args], 300_000));
+    // 버전은 CCUSAGE_PKG로 고정 — @latest 자동 추적은 공급망 탈취를 무인 실행 채널로 만든다.
+    return JSON.parse(await runAsync("npx", ["-y", "--prefer-offline", CCUSAGE_PKG, ...args], 300_000));
   }
 }
 
@@ -114,6 +124,9 @@ function dropExpired(w) {
 
 // 캐시에서 복원한 프로바이더도 신선 수집과 같은 만료 규칙을 적용한다.
 // 안 하면 수집이 실패하는 동안 리셋이 지난 창이 무한 재업로드된다 (유령 게이지).
+// {...prev} 전개가 collected_at을 그대로 보존하는 것이 신선도 규칙의 핵심 —
+// 서버는 collected_at이 더 신선한 행만 덮어쓰므로, 토큰이 만료된 기기의 캐시 폴백이
+// 건강한 기기가 방금 올린 값을 덮어쓰지 못한다. collected_at을 여기서 갱신하면 안 된다.
 function sanitizeCachedProvider(prev) {
   if (!prev || typeof prev !== "object") return null;
   const extras = (prev.extras ?? [])
@@ -251,10 +264,18 @@ async function claudeCredentials() {
   }
 }
 
-// Claude: Claude Code OAuth 세션을 재사용해 공식 usage API 조회
-async function claudeProvider() {
+// Claude: Claude Code OAuth 세션을 재사용해 공식 usage API 조회.
+// 반환: { provider, status } — status "ok" | "auth_expired" | "error",
+// 자격증명 자체가 없으면(미설치) status null이라 collect_status에 항목이 안 생긴다.
+// fetchFn/loadCredentials는 테스트 주입용 — 기본값이면 기존 동작 그대로.
+async function claudeProvider({ fetchFn = fetch, loadCredentials = claudeCredentials } = {}) {
+  let cred;
+  try {
+    cred = await loadCredentials();
+  } catch {
+    return { provider: null, status: null }; // 자격증명 없음 = Claude Code 미설치
+  }
   try {
-    const cred = await claudeCredentials();
     const oauth = cred.claudeAiOauth ?? cred;
     const token = oauth.accessToken;
     // rateLimitTier "default_claude_max_20x" → "Max 20x", 없으면 subscriptionType "max" → "Max"
@@ -264,20 +285,21 @@ async function claudeProvider() {
       : oauth.subscriptionType
         ? oauth.subscriptionType[0].toUpperCase() + oauth.subscriptionType.slice(1)
         : null;
-    const res = await fetch("https://api.anthropic.com/api/oauth/usage", {
+    const res = await fetchFn("https://api.anthropic.com/api/oauth/usage", {
       headers: { Authorization: `Bearer ${token}`, "anthropic-beta": "oauth-2025-04-20" },
       signal: AbortSignal.timeout(10_000),
     });
     if (!res.ok) {
-      // 401 = 토큰 만료 (Claude Code를 한 번 실행하면 갱신됨), 그 외는 일시 장애일 가능성
+      // 401 = 토큰 만료 (Claude Code를 한 번 실행하면 갱신됨), 그 외는 일시 장애일 가능성.
+      // 이 구분이 서버 collect_status로 올라가 앱이 "재로그인 필요"를 안내할 수 있다.
       console.error(`claude usage API ${res.status}${res.status === 401 ? " — 토큰 만료, Claude Code를 실행하면 갱신됩니다" : ""}`);
-      return null;
+      return { provider: null, status: res.status === 401 ? "auth_expired" : "error" };
     }
     const d = await res.json();
     // 계정 UUID → 해시 (프로필 조회 실패 시 null — 캐시 폴백이 채워준다)
     let account = null;
     try {
-      const pr = await fetch("https://api.anthropic.com/api/oauth/profile", {
+      const pr = await fetchFn("https://api.anthropic.com/api/oauth/profile", {
         headers: { Authorization: `Bearer ${token}`, "anthropic-beta": "oauth-2025-04-20" },
         signal: AbortSignal.timeout(10_000),
       });
@@ -298,17 +320,21 @@ async function claudeProvider() {
         },
       }));
     return {
-      id: "claude",
-      name: "Claude",
-      plan,
-      account,
-      session: dropExpired(win(d.five_hour, 300)),
-      weekly: dropExpired(win(d.seven_day, 10080)),
-      extras: extras.length ? extras : null,
+      provider: {
+        id: "claude",
+        name: "Claude",
+        plan,
+        account,
+        session: dropExpired(win(d.five_hour, 300)),
+        weekly: dropExpired(win(d.seven_day, 10080)),
+        extras: extras.length ? extras : null,
+        collected_at: new Date().toISOString(), // usage API 성공 시각
+      },
+      status: "ok",
     };
   } catch (e) {
     console.error(`claude 프로바이더 수집 실패: ${e.message ?? e}`);
-    return null;
+    return { provider: null, status: "error" };
   }
 }
 
@@ -417,26 +443,38 @@ function codexSnapshotWindows() {
           window_minutes: w.window_minutes ?? null,
         }
       : null;
-  return { session: win(rl.primary), weekly: win(rl.secondary) };
+  // collected_at = 로그 파일 mtime — 스냅샷은 "지금"이 아니라 마지막 사용 시점의 값이므로
+  // 수집 시각을 넣으면 다른 기기의 진짜 최신 데이터를 신선도 규칙에서 이겨버린다.
+  return { session: win(rl.primary), weekly: win(rl.secondary), collected_at: new Date(latest.m).toISOString() };
 }
 
+// 반환: { provider, status } — live 성공 "ok", 스냅샷 폴백 "stale",
+// ~/.codex는 있는데 둘 다 실패면 "error", 미설치면 status null(항목 없음).
 async function codexProvider() {
+  if (!fs.existsSync(path.join(HOME, ".codex"))) return { provider: null, status: null }; // Codex 미설치
   try {
     const auth = codexAuth();
-    const windows = (await codexLiveWindows(auth)) ?? codexSnapshotWindows();
-    if (!windows) return null;
+    const live = await codexLiveWindows(auth);
+    const snapshot = live ? null : codexSnapshotWindows();
+    const windows = live ?? snapshot;
+    if (!windows) return { provider: null, status: "error" };
     return {
-      id: "codex",
-      name: "Codex",
-      plan: windows.plan ?? auth?.plan ?? null,
-      account: auth?.account ?? null,
-      session: dropExpired(windows.session),
-      weekly: dropExpired(windows.weekly),
-      extras: null,
+      provider: {
+        id: "codex",
+        name: "Codex",
+        plan: windows.plan ?? auth?.plan ?? null,
+        account: auth?.account ?? null,
+        session: dropExpired(windows.session),
+        weekly: dropExpired(windows.weekly),
+        extras: null,
+        // live면 지금이 관측 시각, 스냅샷 폴백이면 .jsonl mtime이 실제 관측 시각
+        collected_at: live ? new Date().toISOString() : snapshot.collected_at,
+      },
+      status: live ? "ok" : "stale",
     };
   } catch (e) {
     console.error(`codex 프로바이더 수집 실패: ${e.message ?? e}`);
-    return null;
+    return { provider: null, status: "error" };
   }
 }
 
@@ -491,15 +529,18 @@ function codexBarEntryToProvider(entry) {
   });
 
   if (!primary && !secondary && extras.length === 0) return null;
+  // 불투명 식별자(계정 ID·조직)를 이메일보다 먼저 쓴다 — account는 salt 없는 sha256의
+  // 앞 12자(48비트)라, 이메일을 넣으면 DB 유출 시 사전 대입으로 원문이 역산된다.
+  // 고엔트로피 ID는 그 대입이 통하지 않는다. 이메일은 다른 식별자가 전혀 없을 때만 폴백.
   const rawAccount = textValue(
-    identity.accountEmail,
-    identity.email,
-    usage.accountEmail,
-    entry.accountEmail,
     identity.accountId,
     usage.accountId,
     identity.accountOrganization,
-    usage.accountOrganization
+    usage.accountOrganization,
+    identity.accountEmail,
+    identity.email,
+    usage.accountEmail,
+    entry.accountEmail
   );
   const plan = usefulPlan(
     usage.plan,
@@ -520,6 +561,7 @@ function codexBarEntryToProvider(entry) {
     extras: extras.length ? extras : null,
     status: null,
     collector_source: "codexbar",
+    collected_at: new Date().toISOString(), // CodexBar CLI 성공 시각
   };
 }
 
@@ -542,11 +584,11 @@ function parseCodexBarJSON(raw) {
 }
 
 async function collectCodexBarProviders() {
-  if (process.env.CHARGE_DISABLE_CODEXBAR === "1") return { providers: [], complete: false };
+  if (process.env.CHARGE_DISABLE_CODEXBAR === "1") return { providers: [], complete: false, statuses: {} };
   // 따옴표로 감싼 경로(Windows에서 흔한 습관)는 벗겨서 execFile에 그대로 넘긴다
   const cli = process.env.CHARGE_CODEXBAR_CLI?.replace(/^"(.*)"$/s, "$1")
     ?? (!WIN && fs.existsSync(DEFAULT_CODEXBAR_CLI) ? DEFAULT_CODEXBAR_CLI : null);
-  if (!cli) return { providers: [], complete: false };
+  if (!cli) return { providers: [], complete: false, statuses: {} };
 
   let raw = "";
   let commandSucceeded = true;
@@ -559,22 +601,33 @@ async function collectCodexBarProviders() {
     raw = e.stdout?.toString?.() ?? "";
     if (!raw.trim()) {
       console.error(`CodexBar 프로바이더 수집 실패: ${e.message ?? e}`);
-      return { providers: [], complete: false };
+      return { providers: [], complete: false, statuses: {} };
     }
   }
 
   const entries = parseCodexBarJSON(raw);
   if (!entries) {
     console.error("CodexBar 프로바이더 수집 실패: JSON 출력을 해석할 수 없습니다.");
-    return { providers: [], complete: false };
+    return { providers: [], complete: false, statuses: {} };
   }
   const bridgeEntries = entries.filter((entry) => !["claude", "codex"].includes(entry?.provider));
-  const providers = bridgeEntries.map(codexBarEntryToProvider).filter(Boolean);
-  const complete = commandSucceeded && !bridgeEntries.some((entry) => entry?.error);
-  for (const entry of bridgeEntries.filter((item) => item?.error)) {
-    console.error(`CodexBar ${entry.provider ?? "프로바이더"} 수집 실패: ${entry.error.message ?? "알 수 없는 오류"}`);
+  const providers = [];
+  const statuses = {};
+  for (const entry of bridgeEntries) {
+    if (entry?.error) {
+      console.error(`CodexBar ${entry.provider ?? "프로바이더"} 수집 실패: ${entry.error.message ?? "알 수 없는 오류"}`);
+      // claude/codex 상태는 자체 수집기가 판정한다 — entry.id로 새어 들어와도 덮지 않는다
+      const id = textValue(entry.provider, entry.id)?.toLowerCase();
+      if (id && id !== "claude" && id !== "codex") statuses[id] = "error";
+      continue;
+    }
+    const provider = codexBarEntryToProvider(entry);
+    if (!provider) continue; // 창이 하나도 없는 엔트리 — 성공도 실패도 아니라 상태 미기록
+    providers.push(provider);
+    statuses[provider.id] = "ok";
   }
-  return { providers, complete };
+  const complete = commandSucceeded && !bridgeEntries.some((entry) => entry?.error);
+  return { providers, complete, statuses };
 }
 
 // 프로바이더 상태 페이지 (Statuspage 공용 API)
@@ -597,11 +650,16 @@ async function collectProviders() {
     statusOf("https://status.openai.com/api/v2/status.json"),
     collectCodexBarProviders(),
   ]);
-  if (claude) claude.status = claudeStatus;
-  if (codex) codex.status = codexStatus;
+  if (claude.provider) claude.provider.status = claudeStatus;
+  if (codex.provider) codex.provider.status = codexStatus;
+  // collect_status: 미설치(status null)는 항목을 만들지 않는다 — 설치된 소스만 정직하게 보고
+  const statuses = { ...codexBar.statuses };
+  if (claude.status) statuses.claude = claude.status;
+  if (codex.status) statuses.codex = codex.status;
   return {
-    providers: [claude, codex, ...codexBar.providers].filter(Boolean),
+    providers: [claude.provider, codex.provider, ...codexBar.providers].filter(Boolean),
     codexBarComplete: codexBar.complete,
+    statuses,
   };
 }
 
@@ -619,18 +677,33 @@ function resolveMode() {
 }
 
 // 디바이스 토큰으로 charge_upload RPC 호출 (서버가 본인 행에만 기록)
-async function pairedUpload(mode, daily, live, providers) {
-  const res = await fetch(`${mode.url}/rest/v1/rpc/charge_upload`, {
-    method: "POST",
-    headers: {
-      apikey: mode.anon,
-      Authorization: `Bearer ${mode.anon}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ p_token: mode.token, p_daily: daily, p_live: live, p_providers: providers }),
-    signal: AbortSignal.timeout(30_000),
-  });
-  if (!res.ok) throw new Error(`업로드 실패 (${res.status}): ${await res.text()}`);
+async function pairedUpload(mode, daily, live, providers, collectStatus = null) {
+  const post = (body) =>
+    fetch(`${mode.url}/rest/v1/rpc/charge_upload`, {
+      method: "POST",
+      headers: {
+        apikey: mode.anon,
+        Authorization: `Bearer ${mode.anon}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(30_000),
+    });
+  const body = { p_token: mode.token, p_daily: daily, p_live: live, p_providers: providers, p_collect_status: collectStatus };
+  let res = await post(body);
+  if (res.ok) return;
+  const text = await res.text();
+  // 서버에 5번째 파라미터(p_collect_status)가 아직 배포 전이면 PostgREST가 함수
+  // 시그니처를 못 찾아 404/PGRST202를 낸다 — 수집기가 먼저 업데이트된 배포 순서
+  // 역전 대비로, 구버전 시그니처(파라미터 제외)로 1회만 재시도한다.
+  if (res.status === 404 || text.includes("PGRST202")) {
+    console.error("charge_upload 구버전 서버 감지(404/PGRST202) — p_collect_status 없이 재시도합니다");
+    const { p_collect_status: _omitted, ...legacyBody } = body;
+    res = await post(legacyBody);
+    if (res.ok) return;
+    throw new Error(`업로드 실패 (${res.status}): ${await res.text()}`);
+  }
+  throw new Error(`업로드 실패 (${res.status}): ${text}`);
 }
 
 async function main() {
@@ -666,16 +739,25 @@ async function main() {
     providerCollection = providersR.value;
   } else {
     console.error(`프로바이더 수집 실패, 이전 값 유지: ${providersR.reason?.message ?? providersR.reason}`);
-    providerCollection = { providers: [], codexBarComplete: false };
+    // 수집이 통째로 죽으면 상태를 알 수 없다 — null로 보내 정직한 미상 처리 (서버도 null로 덮음)
+    providerCollection = { providers: [], codexBarComplete: false, statuses: null };
   }
   providers = providerCollection.providers;
-  // 일부 프로바이더만 실패해도 목록에서 사라지지 않게 이전 값으로 채운다 (앱 설정 토글 유지)
+  // 일부 프로바이더만 실패해도 목록에서 사라지지 않게 이전 값으로 채운다 (앱 설정 토글 유지).
+  // 이렇게 캐시로 채운 프로바이더의 상태는 statuses에 이미 실패(auth_expired/error 등)로
+  // 기록돼 있다 — 캐시 복원이 성공처럼 보이면 안 되므로 여기서 덮지 않는다.
   for (const prev of cache.providers ?? []) {
     if (providers.some((p) => p.id === prev.id)) continue;
     // CodexBar가 정상 완료된 경우, 거기서 더 이상 반환하지 않는 항목은 사용자가 끈 것으로 본다.
     if (providerCollection.codexBarComplete && prev.collector_source === "codexbar") continue;
     const sanitized = sanitizeCachedProvider(prev);
-    if (sanitized) providers.push(sanitized);
+    if (sanitized) {
+      // 0.1.4 이전 캐시엔 collected_at이 없다. 그대로 보내면 서버가 now()로 취급해
+      // 나이 미상의 캐시가 건강한 기기의 진짜 최신 데이터를 이겨버린다 — epoch로 스탬프해
+      // "언제 것인지 모르는 데이터는 항상 진다"로 만든다 (행 유지에는 지장 없음).
+      if (!sanitized.collected_at) sanitized.collected_at = new Date(0).toISOString();
+      providers.push(sanitized);
+    }
   }
   // 계정 식별 실패 시 마지막으로 알려진 계정 해시 유지 (계정 미상('')과 실제 계정 행이 갈라지는 것 방지)
   for (const p of providers) {
@@ -683,7 +765,7 @@ async function main() {
   }
 
   if (DRY_RUN) {
-    console.log(JSON.stringify({ daily: daily.slice(-1), live, providers }, null, 2));
+    console.log(JSON.stringify({ daily: daily.slice(-1), live, providers, collect_status: providerCollection.statuses }, null, 2));
     console.log(`\n[dry-run] daily ${daily.length}행 + live + providers ${providers.length}개 업로드 예정`);
     return;
   }
@@ -695,7 +777,7 @@ async function main() {
   }
 
   const now = new Date().toISOString();
-  await pairedUpload(mode, daily, live, providers);
+  await pairedUpload(mode, daily, live, providers, providerCollection.statuses);
 
   fs.writeFileSync(CACHE_FILE, JSON.stringify({ daily, live, providers }));
   console.log(`[${now}] daily ${daily.length}행 + live + providers ${providers.length}개 업로드 완료`);
@@ -709,7 +791,9 @@ if (require.main === module) {
 }
 
 module.exports = {
+  CCUSAGE_PKG,
   accountHash,
+  claudeProvider,
   codexBarEntryToProvider,
   collectCodexBarProviders,
   dropExpired,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "charge-connect",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Connects your computer to the Charge iPhone app and uploads AI coding usage",
   "bin": {
     "charge-connect": "cli.js"