charge-connect 0.1.6 → 0.1.8

package/cli.js

@@ -13,14 +13,122 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { execFileSync } = require("node:child_process");
 const { CCUSAGE_PKG } = require("./collect.js"); // 버전 고정을 한 곳에서 관리
+const { resolveInstallationID } = require("./identity.js");
+
+const PACKAGE_NAME = "charge-connect";
+const CURRENT_VERSION = (() => {
+  try { return require("./package.json").version; } catch { return null; }
+})();
 
 const HOME = process.env.HOME ?? process.env.USERPROFILE;
 const CONF_DIR = process.env.CHARGE_HOME ?? path.join(HOME, ".charge");
 const CONF = path.join(CONF_DIR, "config.json");
+const DEVICE = path.join(CONF_DIR, "device.json");
 const WIN = process.platform === "win32";
 const LINUX = process.platform === "linux";
 const INSTALLER = WIN ? "install.ps1" : LINUX ? "install.linux.sh" : "install.sh";
 
+function parseVersion(value) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(String(value ?? ""));
+  return match ? { numbers: match.slice(1, 4).map(Number), prerelease: match[4] ?? null } : null;
+}
+
+function isNewerVersion(current, candidate) {
+  const a = parseVersion(current);
+  const b = parseVersion(candidate);
+  if (!a || !b) return false;
+  for (let i = 0; i < 3; i += 1) {
+    if (a.numbers[i] !== b.numbers[i]) return b.numbers[i] > a.numbers[i];
+  }
+  return a.prerelease !== null && b.prerelease === null;
+}
+
+function resolveNpmCLI() {
+  const candidates = [
+    process.env.npm_execpath,
+    path.join(path.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"),
+    path.resolve(path.dirname(process.execPath), "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+  ].filter(Boolean);
+  return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+}
+
+function launchUpdatedVersion(version) {
+  const npmCLI = resolveNpmCLI();
+  if (!npmCLI) throw new Error("npm 실행 파일을 찾을 수 없어 자동 업데이트할 수 없습니다.");
+  const npmArgs = path.basename(npmCLI) === "npx-cli.js"
+    ? [npmCLI, "--yes", `${PACKAGE_NAME}@${version}`, ...process.argv.slice(2)]
+    : [
+        npmCLI,
+        "exec",
+        "--yes",
+        `--package=${PACKAGE_NAME}@${version}`,
+        "--",
+        PACKAGE_NAME,
+        ...process.argv.slice(2),
+      ];
+  execFileSync(process.execPath, npmArgs, {
+    stdio: "inherit",
+    env: { ...process.env, CHARGE_UPDATE_CHECKED: "1" },
+  });
+}
+
+async function maybeUpdateBeforePairing({
+  currentVersion = CURRENT_VERSION,
+  fetchFn = globalThis.fetch,
+  interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY),
+  ask = null,
+  launch = launchUpdatedVersion,
+  env = process.env,
+  log = console.log,
+} = {}) {
+  if (!currentVersion || env.CHARGE_UPDATE_CHECKED === "1" || env.CHARGE_SKIP_UPDATE === "1") return false;
+
+  let latest;
+  try {
+    const response = await fetchFn(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      headers: { Accept: "application/json", "User-Agent": `${PACKAGE_NAME}/${currentVersion}` },
+      signal: AbortSignal.timeout(8_000),
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    latest = (await response.json())?.version;
+  } catch (error) {
+    log(`업데이트 확인을 건너뜁니다 (${error?.message ?? error}). 현재 ${currentVersion}로 계속합니다.`);
+    return false;
+  }
+
+  if (!isNewerVersion(currentVersion, latest)) return false;
+  log(`charge-connect 새 버전 ${latest}이 있습니다 (현재 ${currentVersion}).`);
+  if (!interactive) {
+    log(`자동 업데이트하려면 'npx ${PACKAGE_NAME}@${latest} <페어링코드>'로 다시 실행하세요.`);
+    return false;
+  }
+
+  let answer;
+  if (ask) {
+    answer = await ask(`먼저 ${latest}(으)로 업데이트한 뒤 연동할까요? (Y/n) `);
+  } else {
+    const rl = require("node:readline/promises").createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      answer = await rl.question(`먼저 ${latest}(으)로 업데이트한 뒤 연동할까요? (Y/n) `);
+    } finally {
+      rl.close();
+    }
+  }
+  const normalized = String(answer ?? "").trim().toLowerCase();
+  if (["n", "no", "아니오"].includes(normalized)) {
+    log(`업데이트를 건너뛰고 ${currentVersion}로 연동합니다.`);
+    return false;
+  }
+  if (!["", "y", "yes", "ok", "네"].includes(normalized)) {
+    log(`응답을 확인하지 못해 업데이트를 건너뛰고 ${currentVersion}로 연동합니다.`);
+    return false;
+  }
+
+  log(`charge-connect ${latest}(으)로 업데이트한 뒤 연동을 계속합니다…`);
+  launch(latest);
+  return true;
+}
+
 // 백엔드 주소 — collector/cloud.json (출시 시 charge 전용 프로젝트로 교체, npm 패키지에 포함)
 const CLOUD = (() => {
   try {
@@ -32,8 +140,7 @@ const CLOUD = (() => {
 
 // 앱 기기 목록에 표시될 이름 — 기본은 호스트명이지만 실명이 든 경우가 흔하므로
 // 최초 페어링 때 --label 또는 CHARGE_LABEL로 덮어쓸 수 있게 하고, 무엇으로 등록되는지 알려준다.
-// 주의: 라벨은 서버가 같은 머신을 알아보는 유일한 키다(중복제거). 이미 페어링된 머신을
-// 다른 라벨로 재페어링하면 새 디바이스로 잡혀 일별 사용량이 이중 집계되므로, 사후 변경은 권하지 않는다.
+// 기기 식별은 별도 installation id가 담당하므로 라벨이 같거나 나중에 바뀌어도 충돌하지 않는다.
 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;
@@ -49,12 +156,30 @@ async function pair(code) {
     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: label }),
-    signal: AbortSignal.timeout(15_000),
-  });
+  const installationID = resolveInstallationID(DEVICE);
+  const claim = (includeInstallationID) => 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: label,
+        ...(includeInstallationID ? { p_install_id: installationID } : {}),
+      }),
+      signal: AbortSignal.timeout(15_000),
+    });
+  let res = await claim(true);
+  if (!res.ok) {
+    const body = await res.text();
+    // 수집기부터 배포된 경우 구버전 DB에는 세 번째 인자가 없다. 함수가 실행되지 않은
+    // PGRST202/404에만 두 인자 호출로 재시도하므로 일회용 코드를 두 번 소비하지 않는다.
+    if (res.status === 404 || body.includes("PGRST202")) {
+      res = await claim(false);
+    } else {
+      console.error(`페어링 실패 (${res.status}): ${body}`);
+      console.error("앱에서 새 코드를 발급받아 다시 시도하세요 (코드는 10분간 유효).");
+      process.exit(1);
+    }
+  }
   const token = res.ok ? await res.json() : null;
   if (!token || typeof token !== "string") {
     console.error(res.ok ? "잘못됐거나 만료된 페어링 코드입니다." : `페어링 실패 (${res.status}): ${await res.text()}`);
@@ -64,7 +189,7 @@ async function pair(code) {
   // 디바이스 토큰은 본인만 읽을 수 있게 저장 (0700/0600)
   fs.mkdirSync(CONF_DIR, { recursive: true, mode: 0o700 });
   try { fs.chmodSync(CONF_DIR, 0o700); } catch {}
-  fs.writeFileSync(CONF, JSON.stringify({ url, anon, token }, null, 2), { mode: 0o600 });
+  fs.writeFileSync(CONF, JSON.stringify({ url, anon, token, install_id: installationID }, null, 2), { mode: 0o600 });
   try { fs.chmodSync(CONF, 0o600); } catch {}
   console.log(`✓ 페어링 완료 — 이 컴퓨터가 '${label}'(으)로 등록되었습니다.`);
 }
@@ -95,7 +220,7 @@ async function unpair() {
 function installRuntime() {
   const dest = path.join(CONF_DIR, "app");
   fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
-  const files = ["cli.js", "collect.js", "install.sh", "install.linux.sh", "install.ps1", "cloud.json", "package.json"];
+  const files = ["cli.js", "collect.js", "identity.js", "install.sh", "install.linux.sh", "install.ps1", "cloud.json", "package.json"];
   for (const f of files) {
     const src = path.join(__dirname, f);
     if (fs.existsSync(src)) fs.copyFileSync(src, path.join(dest, f));
@@ -157,7 +282,7 @@ async function offerCcusageInstall() {
   }
 }
 
-(async () => {
+async function main() {
   const arg = process.argv[2];
   if (!arg) {
     console.error("사용법: npx charge-connect <페어링코드>  (앱 온보딩에서 코드 발급)");
@@ -171,6 +296,9 @@ async function offerCcusageInstall() {
     await unpair();
     return;
   }
+  // 페어링 코드를 소비하기 전에 최신 버전으로 넘긴다. 새 프로세스에는 표시를 남겨
+  // 재귀 업데이트 확인 없이 곧바로 같은 코드와 옵션으로 페어링하게 한다.
+  if (await maybeUpdateBeforePairing()) return;
   // 페어링 코드로 간주: 페어링 → 스케줄 등록 → 첫 수집.
   // 스케줄을 먼저 등록한다 — 첫 수집이 실패해도(네트워크가 잠깐 끊기는 등) 자동 수집은
   // 살아 있어야 한다. 페어링 코드는 이미 소모돼서 같은 코드로 재시도할 수 없기 때문이다.
@@ -216,7 +344,21 @@ async function offerCcusageInstall() {
     return;
   }
   console.log("✓ 설정 끝! 이제 앱에서 데이터가 보입니다.");
-})().catch((e) => {
-  console.error(e.message ?? e);
-  process.exit(1);
-});
+}
+
+if (require.main === module) {
+  main().catch((e) => {
+    console.error(e.message ?? e);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  installRuntime,
+  isNewerVersion,
+  main,
+  maybeUpdateBeforePairing,
+  pair,
+  resolveLabel,
+  resolveNpmCLI,
+};

package/collect.js

@@ -7,6 +7,7 @@ const { execFile } = require("node:child_process");
 const { promisify } = require("node:util");
 const fs = require("node:fs");
 const path = require("node:path");
+const { unknownAccountKey } = require("./identity.js");
 
 const execFileAsync = promisify(execFile);
 
@@ -115,6 +116,18 @@ function accountHash(id) {
   return require("node:crypto").createHash("sha256").update(String(id)).digest("hex").slice(0, 12);
 }
 
+// 퍼센트 수치 파싱, 값이 있을 때만 숫자를 돌려주고, 비었으면 null.
+// Number()에 맡기면 안 된다: Number(null), Number(""), Number(false), Number([])는 전부 0이고
+// finite라, "수치가 비었다"와 "진짜 0%(정상 사용 0)"가 구분되지 않는다. 빈 값이 0%로 올라가면
+// 서버 입장에선 멀쩡한 값이라(빈 창 가드는 JSON null만 보존한다) 다른 기기가 올린 게이지를 0으로 덮는다.
+// 숫자이거나 공백 아닌 숫자 문자열일 때만 값으로 인정한다.
+function percentValue(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v !== "string" || !v.trim()) return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+
 /// 리셋 시각이 이미 지난 창은 무효 처리 (리셋 후 100% 박제 방지)
 function dropExpired(w) {
   if (!w) return null;
@@ -132,10 +145,18 @@ function sanitizeCachedProvider(prev) {
   const extras = (prev.extras ?? [])
     .map((extra) => ({ ...extra, window: dropExpired(extra.window) }))
     .filter((extra) => extra.window);
+  const session = dropExpired(prev.session);
+  const weekly = dropExpired(prev.weekly);
+  // 만료를 걷어내고 표시할 창이 하나도 안 남으면 복원 대상에서 뺀다(null).
+  // 전부 null인 껍데기를 며칠 묵은 collected_at과 함께 올리면 앱엔 빈 카드가 뜨고,
+  // 서버 행의 나이가 그 옛 시각으로 되감겨 다른 기기의 묵은 업로드까지 신선도 가드를 통과한다.
+  // 결과적으로 그 프로바이더는 이번 페이로드에서 통째로 빠진다, 서버의 은퇴 delete에는
+  // 20분 유예가 있어, 한두 사이클 빠졌다가 다시 관측되면 카드가 사라지지 않는다.
+  if (!session && !weekly && !extras.length) return null;
   return {
     ...prev,
-    session: dropExpired(prev.session),
-    weekly: dropExpired(prev.weekly),
+    session,
+    weekly,
     extras: extras.length ? extras : null,
   };
 }
@@ -191,8 +212,14 @@ function explicitWindowLabel(window) {
 
 function normalizeRateWindow(window, slot, duplicateDuration = false, forcedLabel = null) {
   if (!window || typeof window !== "object") return null;
-  const percent = Number(window.usedPercent ?? window.percent ?? window.utilization);
-  if (!Number.isFinite(percent)) return null;
+  // 후보마다 percentValue를 적용해 '유효한' 첫 값을 고른다. ?? 체인은 null/undefined만
+  // 건너뛰므로 "", false, []가 앞자리에 있으면 Number()에서 0으로 둔갑해 그대로 굳었다 , 
+  // 즉 이 폴백의 의미가 "null/undefined 건너뛰기"에서 "유효하지 않은 값 건너뛰기"로 바뀐다.
+  // 빈 수치를 0%로 올리면 서버의 빈 창 가드를 통과해 다른 기기의 멀쩡한 게이지를 덮는다.
+  const percent = [window.usedPercent, window.percent, window.utilization]
+    .map(percentValue)
+    .find((value) => value !== null);
+  if (percent === undefined) return null;
   const rawMinutes = window.windowMinutes ?? window.window_minutes ?? window.durationMinutes;
   const parsedMinutes = rawMinutes == null ? null : Number(rawMinutes);
   const minutes = Number.isFinite(parsedMinutes) && parsedMinutes > 0 ? parsedMinutes : null;
@@ -250,9 +277,33 @@ async function collectDaily() {
   return [...byDay.values()].sort((a, b) => a.period.localeCompare(b.period));
 }
 
-async function collectLive() {
-  const data = await runCcusage(["blocks", "--active", "--json"]);
-  return (data.blocks ?? []).find((b) => b.isActive) ?? null;
+// run은 테스트 주입용, 기본값이면 기존 동작 그대로.
+async function collectLive({ run = runCcusage } = {}) {
+  const data = await run(["blocks", "--active", "--json"]);
+  const block = (data.blocks ?? []).find((b) => b.isActive) ?? null;
+  // collected_at = 이 블록을 실제로 관측한 시각. 서버가 charge_live 신선도 판정에 쓴다 , 
+  // 수집이 깨진 기기가 캐시된 옛 블록을 5분마다 재업로드해도 최신 블록을 덮지 못한다.
+  // 캐시 폴백은 cache.live를 통째로 재사용하므로 이 값이 갱신되지 않고 나이가 보존된다.
+  return block ? { ...block, collected_at: new Date().toISOString() } : null;
+}
+
+// 잠에서 깬 직후에는 스케줄러가 Wi-Fi보다 먼저 돌아 fetch가 즉시 "fetch failed"로 죽는다.
+// 그 사이클을 통째로 버리면 다음 5분까지 묵은 캐시가 올라가므로, 네트워크 계층 실패(HTTP
+// 응답을 못 받은 경우)만 짧게 한 번 더 시도한다. 상태 코드가 온 요청은 재시도하지 않는다
+// (401을 두 번 물어봐야 답이 같고, 5분마다 도는 작업이라 재시도는 최소로).
+// 타임아웃 시그널은 반드시 시도마다 새로 만든다, 호출자가 만든 signal을 두 시도가 나눠 쓰면
+// 1차가 예산 후반에 죽었을 때 2차는 대기 시간만큼 이미 지난 예산을 물려받아 즉시 abort된다.
+// 재시도가 무의미해지는 것도 문제지만, 로그에 남는 원인이 "fetch failed"에서
+// "This operation was aborted"로 바뀌어 진짜 원인(네트워크 미연결)을 가린다.
+async function fetchOnceRetried(fetchFn, url, options, { timeoutMs = 10_000, delayMs = 4000 } = {}) {
+  const attempt = () => fetchFn(url, { ...options, signal: AbortSignal.timeout(timeoutMs) });
+  try {
+    return await attempt();
+  } catch (e) {
+    if (e?.name === "AbortError" || e?.name === "TimeoutError") throw e;
+    await new Promise((r) => setTimeout(r, delayMs));
+    return attempt();
+  }
 }
 
 // Claude Code 자격증명: macOS는 Keychain, Windows/Linux는 ~/.claude/.credentials.json.
@@ -296,10 +347,10 @@ async function claudeProvider({ fetchFn = fetch, loadCredentials = claudeCredent
       : oauth.subscriptionType
         ? oauth.subscriptionType[0].toUpperCase() + oauth.subscriptionType.slice(1)
         : null;
-    const res = await fetchFn("https://api.anthropic.com/api/oauth/usage", {
+    // signal은 넘기지 않는다, fetchOnceRetried가 시도마다 새 10초 예산을 만들어 붙인다
+    const res = await fetchOnceRetried(fetchFn, "https://api.anthropic.com/api/oauth/usage", {
       headers: { Authorization: `Bearer ${token}`, "anthropic-beta": "oauth-2025-04-20" },
-      signal: AbortSignal.timeout(10_000),
-    });
+    }, { timeoutMs: 10_000 });
     if (!res.ok) {
       // 401 = 토큰 만료 (Claude Code를 한 번 실행하면 갱신됨), 그 외는 일시 장애일 가능성.
       // 이 구분이 서버 collect_status로 올라가 앱이 "재로그인 필요"를 안내할 수 있다.
@@ -316,28 +367,41 @@ async function claudeProvider({ fetchFn = fetch, loadCredentials = claudeCredent
       });
       if (pr.ok) account = accountHash((await pr.json()).account?.uuid);
     } catch {}
-    const win = (w, mins) =>
-      w ? { percent: w.utilization ?? 0, resets_at: w.resets_at ?? null, window_minutes: mins } : null;
+    // 200인데 수치가 비어 있으면 창을 버린다. 0%로 대신 채우면 그건 서버의 빈 창 가드를
+    // 통과하는 "정상 값"이라, 다른 기기가 올린 멀쩡한 게이지를 0으로 덮어버린다.
+    const win = (w, mins) => {
+      const percent = percentValue(w?.utilization);
+      return percent === null ? null : { percent, resets_at: w.resets_at ?? null, window_minutes: mins };
+    };
     // limits 배열의 weekly_scoped 항목 = 모델별 주간 한도 (예: "Fable only")
-    const extras = (d.limits ?? [])
-      .filter((l) => l.kind === "weekly_scoped" && l.scope?.model?.display_name)
-      .map((l) => ({
-        name: l.scope.model.display_name,
+    const extras = (d.limits ?? []).flatMap((l) => {
+      const name = l?.kind === "weekly_scoped" ? l.scope?.model?.display_name : null;
+      const percent = percentValue(l?.percent);
+      if (!name || percent === null) return [];
+      return [{
+        name,
         window: {
-          percent: l.percent ?? 0,
+          percent,
           resets_at: l.resets_at ?? null,
           window_minutes: 10080,
-          label: `${l.scope.model.display_name} weekly`,
+          label: `${name} weekly`,
         },
-      }));
+      }];
+    });
+    const session = dropExpired(win(d.five_hour, 300));
+    const weekly = dropExpired(win(d.seven_day, 10080));
+    // codexProvider와 같은 규칙: 올릴 창이 하나도 없으면 프로바이더 자체를 올리지 않는다.
+    // percentValue 도입 후 이 경로가 실제로 생긴다 (200 응답인데 utilization이 비어 있는 경우).
+    // 전부 null인 행을 신선한 스탬프로 올리면 서버에서 빈 카드가 이긴다.
+    if (!session && !weekly && !extras.length) return { provider: null, status: "stale" };
     return {
       provider: {
         id: "claude",
         name: "Claude",
         plan,
         account,
-        session: dropExpired(win(d.five_hour, 300)),
-        weekly: dropExpired(win(d.seven_day, 10080)),
+        session,
+        weekly,
         extras: extras.length ? extras : null,
         collected_at: new Date().toISOString(), // usage API 성공 시각
       },
@@ -378,29 +442,33 @@ function codexAuth() {
 // Codex 실시간 조회: Codex CLI 자신이 60초마다 폴링하는 것과 같은 엔드포인트를
 // 로컬 OAuth 토큰으로 호출한다. 토큰 갱신은 하지 않는다 — 만료됐으면 null을 반환하고
 // 스냅샷 폴백에 맡긴다 (CLI가 다음 실행 때 알아서 갱신해 둔다).
-async function codexLiveWindows(auth) {
+// fetchFn은 테스트 주입용, 기본값이면 기존 동작 그대로.
+async function codexLiveWindows(auth, { fetchFn = fetch } = {}) {
   if (!auth?.accessToken || !auth?.accountId) return null;
   try {
-    const res = await fetch("https://chatgpt.com/backend-api/wham/usage", {
+    // signal은 넘기지 않는다, fetchOnceRetried가 시도마다 새 10초 예산을 만들어 붙인다
+    const res = await fetchOnceRetried(fetchFn, "https://chatgpt.com/backend-api/wham/usage", {
       headers: {
         Authorization: `Bearer ${auth.accessToken}`,
         "chatgpt-account-id": auth.accountId,
         "User-Agent": "charge-connect",
       },
-      signal: AbortSignal.timeout(10_000),
-    });
+    }, { timeoutMs: 10_000 });
     if (!res.ok) return null;
     const d = await res.json();
-    const win = (w) =>
-      w && Number.isFinite(Number(w.used_percent))
-        ? {
-            percent: Number(w.used_percent),
+    // 수치가 비면 0%가 아니라 창 없음, 0%는 서버의 빈 창 가드를 통과해 게이지를 덮는다
+    const win = (w) => {
+      const percent = percentValue(w?.used_percent);
+      return percent === null
+        ? null
+        : {
+            percent,
             resets_at: w.reset_at ? new Date(w.reset_at * 1000).toISOString() : null,
             window_minutes: Number.isFinite(Number(w.limit_window_seconds))
               ? Math.round(Number(w.limit_window_seconds) / 60)
               : null,
-          }
-        : null;
+          };
+    };
     const session = win(d.rate_limit?.primary_window);
     const weekly = win(d.rate_limit?.secondary_window);
     if (!session && !weekly) return null;
@@ -411,23 +479,36 @@ async function codexLiveWindows(auth) {
   }
 }
 
-// Codex 스냅샷 폴백: 가장 최근 세션 로그(.jsonl)에 기록된 마지막 rate_limits —
-// 마지막으로 Codex를 실제 사용한 시점의 값이라 실시간 조회가 실패했을 때만 쓴다
-function codexSnapshotWindows() {
-  const dir = path.join(HOME, ".codex", "sessions");
+// 최신 .jsonl에 rate_limits가 없는 경우가 흔하다(막 연 세션, 한도 응답 전에 끝난 세션).
+// 그렇다고 전부 훑으면 세션 로그가 수천 개인 사용자에서 5분 주기를 넘기므로 최근 몇 개만 본다.
+// 5개는 너무 빡빡했다, 짧은 세션이 연달아 다섯 번이면 여섯 번째의 멀쩡한 스냅샷을 놓치고
+// "관측 실패(error)"로 보고해 앱에 경고가 뜬다. 파일당 읽기는 개별 try로 감싸져 있다.
+const SNAPSHOT_SCAN_FILES = 20;
+// 파일당 읽는 꼬리 크기, 마지막 rate_limits는 파일 끝에 있다 (전체를 읽으면 수십 MB를 파싱하게 된다)
+const SNAPSHOT_TAIL_BYTES = 2 * 1024 * 1024;
+
+// Codex 스냅샷 폴백: 최근 세션 로그(.jsonl)에 기록된 마지막 rate_limits , 
+// 마지막으로 Codex를 실제 사용한 시점의 값이라 실시간 조회가 실패했을 때만 쓴다.
+// 반환: null = 볼 스냅샷이 아예 없음(미설치, 최근 로그에 rate_limits 없음),
+// { session, weekly, collected_at } = 스냅샷은 있었음. 만료 창은 여기서 이미 걸러지므로
+// 둘 다 null일 수 있고, 그건 "관측은 했는데 리셋이 다 지났다"는 뜻이다(호출자가 stale로 판정).
+// dir은 테스트 주입용, 기본값이면 기존 동작 그대로.
+async function codexSnapshotWindows(dir = path.join(HOME, ".codex", "sessions")) {
   if (!fs.existsSync(dir)) return null; // Codex 미설치
-  let latest = null;
+  const files = [];
   (function walk(d) {
     for (const e of fs.readdirSync(d, { withFileTypes: true })) {
       const p = path.join(d, e.name);
       if (e.isDirectory()) walk(p);
       else if (e.name.endsWith(".jsonl")) {
-        const m = fs.statSync(p).mtimeMs;
-        if (!latest || m > latest.m) latest = { p, m };
+        try {
+          files.push({ p, m: fs.statSync(p).mtimeMs });
+        } catch {}
       }
     }
   })(dir);
-  if (!latest) return null;
+  if (!files.length) return null;
+  files.sort((a, b) => b.m - a.m);
 
   const findRL = (o) => {
     if (!o || typeof o !== "object") return null;
@@ -438,45 +519,96 @@ function codexSnapshotWindows() {
     }
     return null;
   };
-  let rl = null;
-  for (const line of fs.readFileSync(latest.p, "utf8").split("\n")) {
-    if (!line.includes('"rate_limits"')) continue;
+  // 세션 로그는 수십 MB까지 자란다(실측 최대 43MB). 통째로 동기 읽기를 하면 그동안 이벤트 루프가
+  // 멈춰 진행 중인 fetch의 AbortSignal 타이머가 전부 터진다, 이 파일 맨 위에서 금지한 바로 그 패턴이다.
+  // 그래서 비동기로, 그것도 꼬리 SNAPSHOT_TAIL_BYTES만 읽는다. 우리가 찾는 건 "마지막" rate_limits라
+  // 꼬리에 없으면 그 파일의 값은 어차피 낡은 것이고, 더 최근 파일이 우선순위를 갖는다.
+  const lastRateLimits = async (file) => {
+    let handle = null;
     try {
-      rl = findRL(JSON.parse(line)) ?? rl;
-    } catch {}
+      handle = await fs.promises.open(file, "r");
+      const { size } = await handle.stat();
+      const start = Math.max(0, size - SNAPSHOT_TAIL_BYTES);
+      const buf = Buffer.alloc(Math.min(size, SNAPSHOT_TAIL_BYTES));
+      await handle.read(buf, 0, buf.length, start);
+      let rl = null;
+      for (const line of buf.toString("utf8").split("\n")) {
+        if (!line.includes('"rate_limits"')) continue;
+        try {
+          // 꼬리를 자른 지점의 첫 줄은 조각날 수 있다, 파싱 실패는 그냥 건너뛴다
+          rl = findRL(JSON.parse(line)) ?? rl;
+        } catch {}
+      }
+      return rl;
+    } catch {
+      return null;
+    } finally {
+      await handle?.close().catch(() => {});
+    }
+  };
+  let found = null;
+  for (const f of files.slice(0, SNAPSHOT_SCAN_FILES)) {
+    const rl = await lastRateLimits(f.p);
+    if (rl) {
+      found = { rl, m: f.m };
+      break;
+    }
   }
-  if (!rl) return null;
-  const win = (w) =>
-    w
-      ? {
-          percent: w.used_percent ?? 0,
+  if (!found) return null;
+  // 수치가 비면 0%가 아니라 창 없음, 0%는 서버의 빈 창 가드를 통과해 게이지를 덮는다
+  const win = (w) => {
+    const percent = percentValue(w?.used_percent);
+    return percent === null
+      ? null
+      : {
+          percent,
           resets_at: w.resets_at ? new Date(w.resets_at * 1000).toISOString() : null,
           window_minutes: w.window_minutes ?? null,
-        }
-      : null;
-  // collected_at = 로그 파일 mtime — 스냅샷은 "지금"이 아니라 마지막 사용 시점의 값이므로
-  // 수집 시각을 넣으면 다른 기기의 진짜 최신 데이터를 신선도 규칙에서 이겨버린다.
-  return { session: win(rl.primary), weekly: win(rl.secondary), collected_at: new Date(latest.m).toISOString() };
+        };
+  };
+  // 만료 판정을 여기서 끝낸다, 예전엔 dropExpired가 codexProvider에서야 돌아, 리셋이 다 지난
+  // 3일 묵은 스냅샷도 "창이 있다"고 통과한 뒤 그 창이 뒤늦게 전부 null이 됐다.
+  const session = dropExpired(win(found.rl.primary));
+  const weekly = dropExpired(win(found.rl.secondary));
+  // collected_at = 그 스냅샷이 들어 있던 파일의 mtime, 스냅샷은 "지금"이 아니라 마지막
+  // 사용 시점의 값이므로, 수집 시각을 넣으면 다른 기기의 진짜 최신 값을 신선도 규칙에서 이긴다.
+  return { session, weekly, collected_at: new Date(found.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 미설치
+// ~/.codex는 있는데 아무것도 관측 못 하면 "error", 미설치면 status null(항목 없음).
+// loadAuth/liveWindows/snapshotWindows/hasCodex는 테스트 주입용, 기본값이면 기존 동작 그대로.
+async function codexProvider({
+  loadAuth = codexAuth,
+  liveWindows = codexLiveWindows,
+  snapshotWindows = codexSnapshotWindows,
+  hasCodex = () => fs.existsSync(path.join(HOME, ".codex")),
+} = {}) {
+  if (!hasCodex()) return { provider: null, status: null }; // Codex 미설치
   try {
-    const auth = codexAuth();
-    const live = await codexLiveWindows(auth);
-    const snapshot = live ? null : codexSnapshotWindows();
+    const auth = loadAuth();
+    const live = await liveWindows(auth);
+    const snapshot = live ? null : await snapshotWindows();
     const windows = live ?? snapshot;
-    if (!windows) return { provider: null, status: "error" };
+    if (!windows) return { provider: null, status: "error" }; // 실시간, 스냅샷 둘 다 관측 실패
+    const session = dropExpired(windows.session);
+    const weekly = dropExpired(windows.weekly);
+    // 리셋이 다 지나 남는 창이 하나도 없으면 프로바이더 자체를 올리지 않는다. 전부 null인 행을
+    // 올리면 앱엔 빈 카드가 뜨고, 서버 행의 collected_at이 스냅샷 mtime(며칠 전)으로 되감겨
+    // 다른 기기의 묵은 업로드까지 신선도 가드를 통과한다. 대신 캐시 폴백이 마지막 값을 유지한다.
+    // 상태는 "error"가 아니다, 수집은 정상이고 데이터가 낡았을 뿐인데 error로 보고하면
+    // 앱이 "재로그인/수집 실패" 경고를 띄운다(앱은 error, auth_expired만 경고로 친다).
+    // live 조회에 성공했더라도 여기까지 왔다면 올릴 창이 없으니 "ok"가 아니라 "stale"이다 , 
+    // "ok"는 이번 사이클에 쓸 수 있는 값을 올렸다는 뜻인데, 실제로 올라가는 건 캐시 폴백뿐이다.
+    if (!session && !weekly) return { provider: null, status: "stale" };
     return {
       provider: {
         id: "codex",
         name: "Codex",
         plan: windows.plan ?? auth?.plan ?? null,
         account: auth?.account ?? null,
-        session: dropExpired(windows.session),
-        weekly: dropExpired(windows.weekly),
+        session,
+        weekly,
         extras: null,
         // live면 지금이 관측 시각, 스냅샷 폴백이면 .jsonl mtime이 실제 관측 시각
         collected_at: live ? new Date().toISOString() : snapshot.collected_at,
@@ -674,10 +806,66 @@ async function collectProviders() {
   };
 }
 
+// 서버는 (user_id, id, account) 한 행을 업서트하므로, 같은 키를 한 페이로드에 두 번 실으면
+// 한 문장 안에서 같은 행을 두 번 건드려 어느 쪽이 남을지가 배열 순서에 달린다.
+// 더 신선한 쪽만 남긴다, collected_at이 없으면 나이 미상이라 스탬프가 있는 쪽에 진다.
+function dedupeProviders(providers) {
+  const stamp = (p) => {
+    const t = Date.parse(p?.collected_at ?? "");
+    return Number.isFinite(t) ? t : -Infinity;
+  };
+  const byKey = new Map();
+  for (const p of providers) {
+    // 구분자는 NUL 이스케이프, id, account 어디에도 못 들어가는 문자여야 키가 안 겹친다
+    const key = `${p.id}\u0000${p.account ?? ""}`;
+    const prev = byKey.get(key);
+    // 동률(둘 다 미상 포함)이면 뒤엣것, 이번 사이클 수집분이 캐시 복원분보다 뒤에 온다
+    if (!prev || stamp(p) >= stamp(prev)) byKey.set(key, p);
+  }
+  return [...byKey.values()];
+}
+
+// 이번 사이클 수집 결과에 캐시 복원분을 얹고 업로드 계약(키 유일성)에 맞춰 정리한다.
+function mergeCachedProviders({ providers, cached = [], codexBarComplete = false, statuses = null }) {
+  const merged = [...providers];
+  // statuses가 null이면 수집이 통째로 죽어 아무것도 판정할 수 없는 경우, 미상 그대로 둔다
+  const nextStatuses = statuses ? { ...statuses } : statuses;
+  for (const prev of cached) {
+    if (merged.some((p) => p.id === prev.id)) continue;
+    // CodexBar가 정상 완료된 경우, 거기서 더 이상 반환하지 않는 항목은 사용자가 끈 것으로 본다.
+    if (codexBarComplete && prev.collector_source === "codexbar") continue;
+    const sanitized = sanitizeCachedProvider(prev);
+    if (!sanitized) continue;
+    // 0.1.4 이전 캐시엔 collected_at이 없다, 없는 채로 보낸다. 서버는 스탬프 없는 업로드를
+    // "최신"이 아니라 "나이 미상"으로 보고 기존 행이 충분히 묵었을 때만 받아준다.
+    // (예전엔 epoch로 찍어 지게 만들었는데, 그 값이 앱까지 새어 "56년 전"으로 보였다.)
+    merged.push(sanitized);
+    // CodexBar CLI가 통째로 실패/미검출/타임아웃이면 statuses가 비어 있어 아무도 실패로
+    // 기록되지 않는다, 판정이 없는 복원 항목만 'stale'로 채운다.
+    // 정상 수집이 남긴 판정(auth_expired/error 등)은 덮지 않는다.
+    if (nextStatuses && !nextStatuses[sanitized.id]) nextStatuses[sanitized.id] = "stale";
+  }
+  return { providers: dedupeProviders(merged), statuses: nextStatuses };
+}
+
+function namespaceUnknownAccounts(providers, installationID) {
+  if (!installationID) return providers;
+  // 프로필 조회 실패 직전에 사용자가 계정을 바꿨을 수 있으므로 캐시의 예전 account를
+  // 추정해 붙이지 않는다. 확인되지 않은 값은 이 기기 전용 키로 보낸 뒤 서버에서 격리한다.
+  return dedupeProviders(providers.map((p) => p.account
+    ? p
+    : { ...p, account: unknownAccountKey(installationID, p.id) }));
+}
+
 // 업로드 설정 — 우선순위: CHARGE_* 환경변수(테스트용) → ~/.charge/config.json(페어링)
 function resolveMode() {
   if (process.env.CHARGE_TOKEN && process.env.CHARGE_URL && process.env.CHARGE_ANON) {
-    return { url: process.env.CHARGE_URL, anon: process.env.CHARGE_ANON, token: process.env.CHARGE_TOKEN };
+    return {
+      url: process.env.CHARGE_URL,
+      anon: process.env.CHARGE_ANON,
+      token: process.env.CHARGE_TOKEN,
+      install_id: process.env.CHARGE_INSTALL_ID ?? null,
+    };
   }
   const conf = path.join(process.env.CHARGE_HOME ?? path.join(HOME, ".charge"), "config.json");
   try {
@@ -688,9 +876,10 @@ function resolveMode() {
 }
 
 // 디바이스 토큰으로 charge_upload RPC 호출 (서버가 본인 행에만 기록)
-async function pairedUpload(mode, daily, live, providers, collectStatus = null) {
+// fetchFn은 테스트 주입용, 기본값이면 기존 동작 그대로.
+async function pairedUpload(mode, daily, live, providers, collectStatus = null, { fetchFn = fetch } = {}) {
   const post = (body) =>
-    fetch(`${mode.url}/rest/v1/rpc/charge_upload`, {
+    fetchFn(`${mode.url}/rest/v1/rpc/charge_upload`, {
       method: "POST",
       headers: {
         apikey: mode.anon,
@@ -711,7 +900,13 @@ async function pairedUpload(mode, daily, live, providers, collectStatus = null)
     console.error("charge_upload 구버전 서버 감지(404/PGRST202) — p_collect_status 없이 재시도합니다");
     const { p_collect_status: _omitted, ...legacyBody } = body;
     res = await post(legacyBody);
-    if (res.ok) return;
+    if (res.ok) {
+      // 이 경로로 올라간 사이클은 collect_status가 서버에 반영되지 않는다(파라미터 자체가 없다).
+      // 상태는 매 사이클 통째로 다시 보내므로 서버가 갱신되면 다음 5분에 저절로 복구된다 , 
+      // 다만 "왜 상태가 비었나"를 로그 없이는 알 수 없어 흔적을 남긴다.
+      console.error("구버전 시그니처로 업로드 성공, collect_status는 이번 사이클 미반영(다음 사이클에 복구)");
+      return;
+    }
     throw new Error(`업로드 실패 (${res.status}): ${await res.text()}`);
   }
   throw new Error(`업로드 실패 (${res.status}): ${text}`);
@@ -743,6 +938,8 @@ async function main() {
     live = liveR.value;
   } else {
     console.error(`live 수집 실패, 이전 값 유지: ${liveR.reason?.message ?? liveR.reason}`);
+    // 캐시 블록은 collected_at을 갱신하지 않고 통째로 재사용한다, 갱신하면 수집이 깨진
+    // 기기의 옛 블록이 다른 기기의 진짜 활성 블록을 서버 신선도 규칙에서 이겨버린다.
     live = cache.live ?? null;
   }
   let providerCollection;
@@ -753,42 +950,31 @@ async function main() {
     // 수집이 통째로 죽으면 상태를 알 수 없다 — 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) {
-      // 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) {
-    if (!p.account) p.account = (cache.providers ?? []).find((c) => c.id === p.id)?.account ?? null;
-  }
+  // 일부 프로바이더만 실패해도 목록에서 사라지지 않게 이전 값으로 채운다 (앱 설정 토글 유지)
+  let statuses;
+  ({ providers, statuses } = mergeCachedProviders({
+    providers: providerCollection.providers,
+    cached: cache.providers ?? [],
+    codexBarComplete: providerCollection.codexBarComplete,
+    statuses: providerCollection.statuses,
+  }));
+
+  const mode = resolveMode();
+  providers = namespaceUnknownAccounts(providers, mode?.install_id);
 
   if (DRY_RUN) {
-    console.log(JSON.stringify({ daily: daily.slice(-1), live, providers, collect_status: providerCollection.statuses }, null, 2));
+    console.log(JSON.stringify({ daily: daily.slice(-1), live, providers, collect_status: statuses }, null, 2));
     console.log(`\n[dry-run] daily ${daily.length}행 + live + providers ${providers.length}개 업로드 예정`);
     return;
   }
 
-  const mode = resolveMode();
   if (!mode) {
     console.error("페어링이 안 돼 있습니다. 앱에서 코드를 발급받아 `npx charge-connect <코드>`를 실행하세요.");
     process.exit(1);
   }
 
   const now = new Date().toISOString();
-  await pairedUpload(mode, daily, live, providers, providerCollection.statuses);
+  await pairedUpload(mode, daily, live, providers, statuses);
 
   fs.writeFileSync(CACHE_FILE, JSON.stringify({ daily, live, providers }));
   console.log(`[${now}] daily ${daily.length}행 + live + providers ${providers.length}개 업로드 완료`);
@@ -806,13 +992,23 @@ module.exports = {
   accountHash,
   claudeProvider,
   codexBarEntryToProvider,
+  codexLiveWindows,
+  codexProvider,
+  codexSnapshotWindows,
   collectCodexBarProviders,
+  collectLive,
+  dedupeProviders,
   dropExpired,
   durationLabel,
+  fetchOnceRetried,
   freshestCredentials,
+  mergeCachedProviders,
+  namespaceUnknownAccounts,
   normalizeRateWindow,
   normalizeResetAt,
+  pairedUpload,
   parseCodexBarJSON,
+  percentValue,
   resolveMode,
   runAsync,
   sanitizeCachedProvider,

package/identity.js

@@ -0,0 +1,57 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+
+const INSTALLATION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function parseInstallationID(raw) {
+  try {
+    const parsed = JSON.parse(String(raw));
+    const id = typeof parsed === "string" ? parsed : parsed?.installation_id;
+    return typeof id === "string" && INSTALLATION_ID_RE.test(id) ? id.toLowerCase() : null;
+  } catch {
+    const id = String(raw).trim();
+    return INSTALLATION_ID_RE.test(id) ? id.toLowerCase() : null;
+  }
+}
+
+// 페어링 토큰(config.json)과 분리해 보관한다. unpair/re-pair나 토큰 회전 뒤에도 같은
+// 설치를 같은 기기로 알아봐야 하고, 호스트명은 표시 이름일 뿐 식별자가 아니기 때문이다.
+function resolveInstallationID(file, { randomUUID = crypto.randomUUID } = {}) {
+  try {
+    const existing = parseInstallationID(fs.readFileSync(file, "utf8"));
+    if (existing) return existing;
+  } catch {}
+
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(path.dirname(file), 0o700); } catch {}
+
+  const created = randomUUID().toLowerCase();
+  const body = JSON.stringify({ installation_id: created }, null, 2);
+  try {
+    // 동시에 두 페어링이 시작돼도 먼저 쓴 id가 정본이다.
+    fs.writeFileSync(file, body, { flag: "wx", mode: 0o600 });
+  } catch (e) {
+    if (e?.code !== "EEXIST") throw e;
+    const winner = parseInstallationID(fs.readFileSync(file, "utf8"));
+    if (winner) return winner;
+    // 기존 파일이 깨졌다면 새 정상값으로 복구한다. 이 파일에는 자격증명이 없다.
+    fs.writeFileSync(file, body, { mode: 0o600 });
+  }
+  try { fs.chmodSync(file, 0o600); } catch {}
+  return created;
+}
+
+// 계정 UUID를 못 얻은 관측끼리 전역 account='' 행에서 경쟁하지 않도록 기기별로 격리한다.
+// 접두사는 앱/백엔드가 "확인된 동일 계정"과 구분할 수 있게 의도적으로 남긴다.
+function unknownAccountKey(installationID, providerID) {
+  if (!installationID || !providerID) return null;
+  const digest = crypto
+    .createHash("sha256")
+    .update(`${installationID}\0${providerID}`)
+    .digest("hex")
+    .slice(0, 16);
+  return `unknown:${digest}`;
+}
+
+module.exports = { parseInstallationID, resolveInstallationID, unknownAccountKey };

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "charge-connect",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Connects your computer to the Charge iPhone app and uploads AI coding usage",
   "bin": {
     "charge-connect": "cli.js"
   },
   "scripts": {
-    "test": "node --test collect.test.js"
+    "test": "node --test collect.test.js cli.test.js"
   },
   "files": [
     "cli.js",
     "collect.js",
+    "identity.js",
     "install.sh",
     "install.linux.sh",
     "install.ps1",