charge-connect 0.1.7 → 0.1.9

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,12 @@ 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 });
+  const claude_environment = Object.fromEntries(
+    ["CLAUDE_CONFIG_DIR", "CLAUDE_SECURESTORAGE_CONFIG_DIR"]
+      .filter((key) => process.env[key] !== undefined)
+      .map((key) => [key, process.env[key]])
+  );
+  fs.writeFileSync(CONF, JSON.stringify({ url, anon, token, install_id: installationID, claude_environment }, null, 2), { mode: 0o600 });
   try { fs.chmodSync(CONF, 0o600); } catch {}
   console.log(`✓ 페어링 완료 — 이 컴퓨터가 '${label}'(으)로 등록되었습니다.`);
 }
@@ -95,7 +225,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 +287,7 @@ async function offerCcusageInstall() {
   }
 }
 
-(async () => {
+async function main() {
   const arg = process.argv[2];
   if (!arg) {
     console.error("사용법: npx charge-connect <페어링코드>  (앱 온보딩에서 코드 발급)");
@@ -171,6 +301,9 @@ async function offerCcusageInstall() {
     await unpair();
     return;
   }
+  // 페어링 코드를 소비하기 전에 최신 버전으로 넘긴다. 새 프로세스에는 표시를 남겨
+  // 재귀 업데이트 확인 없이 곧바로 같은 코드와 옵션으로 페어링하게 한다.
+  if (await maybeUpdateBeforePairing()) return;
   // 페어링 코드로 간주: 페어링 → 스케줄 등록 → 첫 수집.
   // 스케줄을 먼저 등록한다 — 첫 수집이 실패해도(네트워크가 잠깐 끊기는 등) 자동 수집은
   // 살아 있어야 한다. 페어링 코드는 이미 소모돼서 같은 코드로 재시도할 수 없기 때문이다.
@@ -216,7 +349,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);
 
@@ -15,6 +16,7 @@ const daysArg = process.argv.indexOf("--days");
 const parsedDays = daysArg > -1 ? parseInt(process.argv[daysArg + 1], 10) : NaN;
 const DAYS = Number.isFinite(parsedDays) && parsedDays > 0 ? parsedDays : 60;
 const CACHE_FILE = path.join(__dirname, ".last-payload.json");
+const HEALTH_FILE = path.join(__dirname, ".collection-health.json");
 const HOME = process.env.HOME ?? process.env.USERPROFILE;
 
 // 스케줄러가 부를 때는 볼 콘솔이 없으니 출력을 직접 파일로 받는다.
@@ -115,8 +117,8 @@ 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이고
+// 퍼센트 수치 파싱, 값이 있을 때만 숫자를 돌려주고, 비었으면 null.
+// Number()에 맡기면 안 된다: Number(null), Number(""), Number(false), Number([])는 전부 0이고
 // finite라, "수치가 비었다"와 "진짜 0%(정상 사용 0)"가 구분되지 않는다. 빈 값이 0%로 올라가면
 // 서버 입장에선 멀쩡한 값이라(빈 창 가드는 JSON null만 보존한다) 다른 기기가 올린 게이지를 0으로 덮는다.
 // 숫자이거나 공백 아닌 숫자 문자열일 때만 값으로 인정한다.
@@ -149,7 +151,7 @@ function sanitizeCachedProvider(prev) {
   // 만료를 걷어내고 표시할 창이 하나도 안 남으면 복원 대상에서 뺀다(null).
   // 전부 null인 껍데기를 며칠 묵은 collected_at과 함께 올리면 앱엔 빈 카드가 뜨고,
   // 서버 행의 나이가 그 옛 시각으로 되감겨 다른 기기의 묵은 업로드까지 신선도 가드를 통과한다.
-  // 결과적으로 그 프로바이더는 이번 페이로드에서 통째로 빠진다 — 서버의 은퇴 delete에는
+  // 결과적으로 그 프로바이더는 이번 페이로드에서 통째로 빠진다, 서버의 은퇴 delete에는
   // 20분 유예가 있어, 한두 사이클 빠졌다가 다시 관측되면 카드가 사라지지 않는다.
   if (!session && !weekly && !extras.length) return null;
   return {
@@ -212,7 +214,7 @@ function explicitWindowLabel(window) {
 function normalizeRateWindow(window, slot, duplicateDuration = false, forcedLabel = null) {
   if (!window || typeof window !== "object") return null;
   // 후보마다 percentValue를 적용해 '유효한' 첫 값을 고른다. ?? 체인은 null/undefined만
-  // 건너뛰므로 ""·false·[]가 앞자리에 있으면 Number()에서 0으로 둔갑해 그대로 굳었다 —
+  // 건너뛰므로 "", false, []가 앞자리에 있으면 Number()에서 0으로 둔갑해 그대로 굳었다 , 
   // 즉 이 폴백의 의미가 "null/undefined 건너뛰기"에서 "유효하지 않은 값 건너뛰기"로 바뀐다.
   // 빈 수치를 0%로 올리면 서버의 빈 창 가드를 통과해 다른 기기의 멀쩡한 게이지를 덮는다.
   const percent = [window.usedPercent, window.percent, window.utilization]
@@ -276,11 +278,11 @@ async function collectDaily() {
   return [...byDay.values()].sort((a, b) => a.period.localeCompare(b.period));
 }
 
-// run은 테스트 주입용 — 기본값이면 기존 동작 그대로.
+// 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 신선도 판정에 쓴다 —
+  // collected_at = 이 블록을 실제로 관측한 시각. 서버가 charge_live 신선도 판정에 쓴다 , 
   // 수집이 깨진 기기가 캐시된 옛 블록을 5분마다 재업로드해도 최신 블록을 덮지 못한다.
   // 캐시 폴백은 cache.live를 통째로 재사용하므로 이 값이 갱신되지 않고 나이가 보존된다.
   return block ? { ...block, collected_at: new Date().toISOString() } : null;
@@ -290,7 +292,7 @@ async function collectLive({ run = runCcusage } = {}) {
 // 그 사이클을 통째로 버리면 다음 5분까지 묵은 캐시가 올라가므로, 네트워크 계층 실패(HTTP
 // 응답을 못 받은 경우)만 짧게 한 번 더 시도한다. 상태 코드가 온 요청은 재시도하지 않는다
 // (401을 두 번 물어봐야 답이 같고, 5분마다 도는 작업이라 재시도는 최소로).
-// 타임아웃 시그널은 반드시 시도마다 새로 만든다 — 호출자가 만든 signal을 두 시도가 나눠 쓰면
+// 타임아웃 시그널은 반드시 시도마다 새로 만든다, 호출자가 만든 signal을 두 시도가 나눠 쓰면
 // 1차가 예산 후반에 죽었을 때 2차는 대기 시간만큼 이미 지난 예산을 물려받아 즉시 abort된다.
 // 재시도가 무의미해지는 것도 문제지만, 로그에 남는 원인이 "fetch failed"에서
 // "This operation was aborted"로 바뀌어 진짜 원인(네트워크 미연결)을 가린다.
@@ -313,28 +315,50 @@ function freshestCredentials(sources) {
   return sources.reduce((a, b) => (expiresAt(b) > expiresAt(a) ? b : a));
 }
 
-async function claudeCredentials() {
+function claudeCredentialLocation(env = process.env, home = HOME) {
+  const configDir = (env.CLAUDE_CONFIG_DIR || path.join(home, ".claude")).normalize("NFC");
+  // Claude Code supports a separate credential store; an explicit empty override
+  // selects the default store even when CLAUDE_CONFIG_DIR points elsewhere.
+  const override = env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
+  const storageDir = (override !== undefined ? override || path.join(home, ".claude") : configDir).normalize("NFC");
+  const scoped = override !== undefined ? !!override : !!env.CLAUDE_CONFIG_DIR;
+  const suffix = scoped
+    ? `-${require("node:crypto").createHash("sha256").update(storageDir).digest("hex").slice(0, 8)}` : "";
+  return { configDir, file: path.join(storageDir, ".credentials.json"), service: `Claude Code-credentials${suffix}` };
+}
+
+async function claudeCredentials({ env = process.env, home = HOME, run = runAsync, read = fs.readFileSync } = {}) {
+  const location = claudeCredentialLocation(env, home);
   const sources = [];
   try {
-    sources.push(JSON.parse(await runAsync("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"])));
+    sources.push(JSON.parse(await run("security", ["find-generic-password", "-s", location.service, "-w"], 10_000)));
   } catch {}
   try {
-    sources.push(JSON.parse(fs.readFileSync(path.join(HOME, ".claude", ".credentials.json"), "utf8")));
+    sources.push(JSON.parse(read(location.file, "utf8")));
   } catch {}
-  if (!sources.length) throw new Error("Claude Code 자격증명 없음");
-  return freshestCredentials(sources);
+  const usable = sources.filter((source) => typeof (source?.claudeAiOauth ?? source)?.accessToken === "string"
+    && (source.claudeAiOauth ?? source).accessToken.trim());
+  if (!usable.length) throw new Error("Claude Code 구독 로그인 정보를 읽을 수 없음");
+  return freshestCredentials(usable);
 }
 
 // Claude: Claude Code OAuth 세션을 재사용해 공식 usage API 조회.
-// 반환: { provider, status } — status "ok" | "auth_expired" | "error",
-// 자격증명 자체가 없으면(미설치) status null이라 collect_status에 항목이 안 생긴다.
+// 반환: { provider, status } — "ok", "auth_expired", or "error[:reason]".
+// 설치 흔적이 없으면 status null; 설치 흔적은 있지만 로그인 정보를 못 읽으면 설정 안내.
 // fetchFn/loadCredentials는 테스트 주입용 — 기본값이면 기존 동작 그대로.
-async function claudeProvider({ fetchFn = fetch, loadCredentials = claudeCredentials } = {}) {
+async function claudeProvider({
+  fetchFn = fetch, loadCredentials = claudeCredentials,
+  hasClaude = () => fs.existsSync(claudeCredentialLocation().configDir),
+} = {}) {
   let cred;
   try {
     cred = await loadCredentials();
   } catch {
-    return { provider: null, status: null }; // 자격증명 없음 = Claude Code 미설치
+    // A config directory without readable subscription credentials is a setup
+    // issue, not proof that Claude Code is absent. Surface it even on first use.
+    const detected = hasClaude();
+    if (detected) console.error("Claude Code 구독 로그인 정보를 읽을 수 없습니다 — 이 PC의 Claude Code에서 /status와 /login을 확인하세요 (API 키 계정은 구독 한도 조회 미지원)");
+    return { provider: null, status: detected ? "error:credentials_missing" : null };
   }
   try {
     const oauth = cred.claudeAiOauth ?? cred;
@@ -346,7 +370,7 @@ async function claudeProvider({ fetchFn = fetch, loadCredentials = claudeCredent
       : oauth.subscriptionType
         ? oauth.subscriptionType[0].toUpperCase() + oauth.subscriptionType.slice(1)
         : null;
-    // signal은 넘기지 않는다 — fetchOnceRetried가 시도마다 새 10초 예산을 만들어 붙인다
+    // 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" },
     }, { timeoutMs: 10_000 });
@@ -354,7 +378,10 @@ async function claudeProvider({ fetchFn = fetch, loadCredentials = claudeCredent
       // 401 = 토큰 만료 (Claude Code를 한 번 실행하면 갱신됨), 그 외는 일시 장애일 가능성.
       // 이 구분이 서버 collect_status로 올라가 앱이 "재로그인 필요"를 안내할 수 있다.
       console.error(`claude usage API ${res.status}${res.status === 401 ? " — 토큰 만료, Claude Code를 실행하면 갱신됩니다" : ""}`);
-      return { provider: null, status: res.status === 401 ? "auth_expired" : "error" };
+      const status = res.status === 401 ? "auth_expired"
+        : res.status === 403 ? "error:access_denied"
+        : res.status === 429 ? "error:rate_limited" : "error";
+      return { provider: null, status };
     }
     const d = await res.json();
     // 계정 UUID → 해시 (프로필 조회 실패 시 null — 캐시 폴백이 채워준다)
@@ -441,11 +468,11 @@ function codexAuth() {
 // Codex 실시간 조회: Codex CLI 자신이 60초마다 폴링하는 것과 같은 엔드포인트를
 // 로컬 OAuth 토큰으로 호출한다. 토큰 갱신은 하지 않는다 — 만료됐으면 null을 반환하고
 // 스냅샷 폴백에 맡긴다 (CLI가 다음 실행 때 알아서 갱신해 둔다).
-// fetchFn은 테스트 주입용 — 기본값이면 기존 동작 그대로.
+// fetchFn은 테스트 주입용, 기본값이면 기존 동작 그대로.
 async function codexLiveWindows(auth, { fetchFn = fetch } = {}) {
   if (!auth?.accessToken || !auth?.accountId) return null;
   try {
-    // signal은 넘기지 않는다 — fetchOnceRetried가 시도마다 새 10초 예산을 만들어 붙인다
+    // signal은 넘기지 않는다, fetchOnceRetried가 시도마다 새 10초 예산을 만들어 붙인다
     const res = await fetchOnceRetried(fetchFn, "https://chatgpt.com/backend-api/wham/usage", {
       headers: {
         Authorization: `Bearer ${auth.accessToken}`,
@@ -455,7 +482,7 @@ async function codexLiveWindows(auth, { fetchFn = fetch } = {}) {
     }, { timeoutMs: 10_000 });
     if (!res.ok) return null;
     const d = await res.json();
-    // 수치가 비면 0%가 아니라 창 없음 — 0%는 서버의 빈 창 가드를 통과해 게이지를 덮는다
+    // 수치가 비면 0%가 아니라 창 없음, 0%는 서버의 빈 창 가드를 통과해 게이지를 덮는다
     const win = (w) => {
       const percent = percentValue(w?.used_percent);
       return percent === null
@@ -480,18 +507,18 @@ async function codexLiveWindows(auth, { fetchFn = fetch } = {}) {
 
 // 최신 .jsonl에 rate_limits가 없는 경우가 흔하다(막 연 세션, 한도 응답 전에 끝난 세션).
 // 그렇다고 전부 훑으면 세션 로그가 수천 개인 사용자에서 5분 주기를 넘기므로 최근 몇 개만 본다.
-// 5개는 너무 빡빡했다 — 짧은 세션이 연달아 다섯 번이면 여섯 번째의 멀쩡한 스냅샷을 놓치고
+// 5개는 너무 빡빡했다, 짧은 세션이 연달아 다섯 번이면 여섯 번째의 멀쩡한 스냅샷을 놓치고
 // "관측 실패(error)"로 보고해 앱에 경고가 뜬다. 파일당 읽기는 개별 try로 감싸져 있다.
 const SNAPSHOT_SCAN_FILES = 20;
-// 파일당 읽는 꼬리 크기 — 마지막 rate_limits는 파일 끝에 있다 (전체를 읽으면 수십 MB를 파싱하게 된다)
+// 파일당 읽는 꼬리 크기, 마지막 rate_limits는 파일 끝에 있다 (전체를 읽으면 수십 MB를 파싱하게 된다)
 const SNAPSHOT_TAIL_BYTES = 2 * 1024 * 1024;
 
-// Codex 스냅샷 폴백: 최근 세션 로그(.jsonl)에 기록된 마지막 rate_limits —
+// Codex 스냅샷 폴백: 최근 세션 로그(.jsonl)에 기록된 마지막 rate_limits , 
 // 마지막으로 Codex를 실제 사용한 시점의 값이라 실시간 조회가 실패했을 때만 쓴다.
-// 반환: null = 볼 스냅샷이 아예 없음(미설치·최근 로그에 rate_limits 없음),
+// 반환: null = 볼 스냅샷이 아예 없음(미설치, 최근 로그에 rate_limits 없음),
 // { session, weekly, collected_at } = 스냅샷은 있었음. 만료 창은 여기서 이미 걸러지므로
 // 둘 다 null일 수 있고, 그건 "관측은 했는데 리셋이 다 지났다"는 뜻이다(호출자가 stale로 판정).
-// dir은 테스트 주입용 — 기본값이면 기존 동작 그대로.
+// dir은 테스트 주입용, 기본값이면 기존 동작 그대로.
 async function codexSnapshotWindows(dir = path.join(HOME, ".codex", "sessions")) {
   if (!fs.existsSync(dir)) return null; // Codex 미설치
   const files = [];
@@ -519,7 +546,7 @@ async function codexSnapshotWindows(dir = path.join(HOME, ".codex", "sessions"))
     return null;
   };
   // 세션 로그는 수십 MB까지 자란다(실측 최대 43MB). 통째로 동기 읽기를 하면 그동안 이벤트 루프가
-  // 멈춰 진행 중인 fetch의 AbortSignal 타이머가 전부 터진다 — 이 파일 맨 위에서 금지한 바로 그 패턴이다.
+  // 멈춰 진행 중인 fetch의 AbortSignal 타이머가 전부 터진다, 이 파일 맨 위에서 금지한 바로 그 패턴이다.
   // 그래서 비동기로, 그것도 꼬리 SNAPSHOT_TAIL_BYTES만 읽는다. 우리가 찾는 건 "마지막" rate_limits라
   // 꼬리에 없으면 그 파일의 값은 어차피 낡은 것이고, 더 최근 파일이 우선순위를 갖는다.
   const lastRateLimits = async (file) => {
@@ -534,7 +561,7 @@ async function codexSnapshotWindows(dir = path.join(HOME, ".codex", "sessions"))
       for (const line of buf.toString("utf8").split("\n")) {
         if (!line.includes('"rate_limits"')) continue;
         try {
-          // 꼬리를 자른 지점의 첫 줄은 조각날 수 있다 — 파싱 실패는 그냥 건너뛴다
+          // 꼬리를 자른 지점의 첫 줄은 조각날 수 있다, 파싱 실패는 그냥 건너뛴다
           rl = findRL(JSON.parse(line)) ?? rl;
         } catch {}
       }
@@ -554,7 +581,7 @@ async function codexSnapshotWindows(dir = path.join(HOME, ".codex", "sessions"))
     }
   }
   if (!found) return null;
-  // 수치가 비면 0%가 아니라 창 없음 — 0%는 서버의 빈 창 가드를 통과해 게이지를 덮는다
+  // 수치가 비면 0%가 아니라 창 없음, 0%는 서버의 빈 창 가드를 통과해 게이지를 덮는다
   const win = (w) => {
     const percent = percentValue(w?.used_percent);
     return percent === null
@@ -565,18 +592,18 @@ async function codexSnapshotWindows(dir = path.join(HOME, ".codex", "sessions"))
           window_minutes: w.window_minutes ?? null,
         };
   };
-  // 만료 판정을 여기서 끝낸다 — 예전엔 dropExpired가 codexProvider에서야 돌아, 리셋이 다 지난
+  // 만료 판정을 여기서 끝낸다, 예전엔 dropExpired가 codexProvider에서야 돌아, 리셋이 다 지난
   // 3일 묵은 스냅샷도 "창이 있다"고 통과한 뒤 그 창이 뒤늦게 전부 null이 됐다.
   const session = dropExpired(win(found.rl.primary));
   const weekly = dropExpired(win(found.rl.secondary));
-  // collected_at = 그 스냅샷이 들어 있던 파일의 mtime — 스냅샷은 "지금"이 아니라 마지막
+  // collected_at = 그 스냅샷이 들어 있던 파일의 mtime, 스냅샷은 "지금"이 아니라 마지막
   // 사용 시점의 값이므로, 수집 시각을 넣으면 다른 기기의 진짜 최신 값을 신선도 규칙에서 이긴다.
   return { session, weekly, collected_at: new Date(found.m).toISOString() };
 }
 
 // 반환: { provider, status } — live 성공 "ok", 스냅샷 폴백 "stale",
 // ~/.codex는 있는데 아무것도 관측 못 하면 "error", 미설치면 status null(항목 없음).
-// loadAuth/liveWindows/snapshotWindows/hasCodex는 테스트 주입용 — 기본값이면 기존 동작 그대로.
+// loadAuth/liveWindows/snapshotWindows/hasCodex는 테스트 주입용, 기본값이면 기존 동작 그대로.
 async function codexProvider({
   loadAuth = codexAuth,
   liveWindows = codexLiveWindows,
@@ -589,15 +616,15 @@ async function codexProvider({
     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"이다 —
+    // 상태는 "error"가 아니다, 수집은 정상이고 데이터가 낡았을 뿐인데 error로 보고하면
+    // 앱이 "재로그인/수집 실패" 경고를 띄운다(앱은 error, auth_expired만 경고로 친다).
+    // live 조회에 성공했더라도 여기까지 왔다면 올릴 창이 없으니 "ok"가 아니라 "stale"이다 , 
     // "ok"는 이번 사이클에 쓸 수 있는 값을 올렸다는 뜻인데, 실제로 올라가는 건 캐시 폴백뿐이다.
     if (!session && !weekly) return { provider: null, status: "stale" };
     return {
@@ -807,7 +834,7 @@ async function collectProviders() {
 
 // 서버는 (user_id, id, account) 한 행을 업서트하므로, 같은 키를 한 페이로드에 두 번 실으면
 // 한 문장 안에서 같은 행을 두 번 건드려 어느 쪽이 남을지가 배열 순서에 달린다.
-// 더 신선한 쪽만 남긴다 — collected_at이 없으면 나이 미상이라 스탬프가 있는 쪽에 진다.
+// 더 신선한 쪽만 남긴다, collected_at이 없으면 나이 미상이라 스탬프가 있는 쪽에 진다.
 function dedupeProviders(providers) {
   const stamp = (p) => {
     const t = Date.parse(p?.collected_at ?? "");
@@ -815,10 +842,10 @@ function dedupeProviders(providers) {
   };
   const byKey = new Map();
   for (const p of providers) {
-    // 구분자는 NUL 이스케이프 — id·account 어디에도 못 들어가는 문자여야 키가 안 겹친다
+    // 구분자는 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()];
@@ -827,7 +854,7 @@ function dedupeProviders(providers) {
 // 이번 사이클 수집 결과에 캐시 복원분을 얹고 업로드 계약(키 유일성)에 맞춰 정리한다.
 function mergeCachedProviders({ providers, cached = [], codexBarComplete = false, statuses = null }) {
   const merged = [...providers];
-  // statuses가 null이면 수집이 통째로 죽어 아무것도 판정할 수 없는 경우 — 미상 그대로 둔다
+  // statuses가 null이면 수집이 통째로 죽어 아무것도 판정할 수 없는 경우, 미상 그대로 둔다
   const nextStatuses = statuses ? { ...statuses } : statuses;
   for (const prev of cached) {
     if (merged.some((p) => p.id === prev.id)) continue;
@@ -835,27 +862,86 @@ function mergeCachedProviders({ providers, cached = [], codexBarComplete = false
     if (codexBarComplete && prev.collector_source === "codexbar") continue;
     const sanitized = sanitizeCachedProvider(prev);
     if (!sanitized) continue;
-    // 0.1.4 이전 캐시엔 collected_at이 없다 — 없는 채로 보낸다. 서버는 스탬프 없는 업로드를
+    // 0.1.4 이전 캐시엔 collected_at이 없다, 없는 채로 보낸다. 서버는 스탬프 없는 업로드를
     // "최신"이 아니라 "나이 미상"으로 보고 기존 행이 충분히 묵었을 때만 받아준다.
     // (예전엔 epoch로 찍어 지게 만들었는데, 그 값이 앱까지 새어 "56년 전"으로 보였다.)
     merged.push(sanitized);
     // CodexBar CLI가 통째로 실패/미검출/타임아웃이면 statuses가 비어 있어 아무도 실패로
-    // 기록되지 않는다 — 판정이 없는 복원 항목만 'stale'로 채운다.
+    // 기록되지 않는다, 판정이 없는 복원 항목만 'stale'로 채운다.
     // 정상 수집이 남긴 판정(auth_expired/error 등)은 덮지 않는다.
     if (nextStatuses && !nextStatuses[sanitized.id]) nextStatuses[sanitized.id] = "stale";
   }
-  // 계정 식별 실패 시 마지막으로 알려진 계정 해시 유지 (계정 미상('')과 실제 계정 행이 갈라지는 것 방지)
-  for (const p of merged) {
-    if (!p.account) p.account = cached.find((c) => c.id === p.id)?.account ?? null;
-  }
-  // dedupe는 account 보정 뒤에 — 보정으로 비로소 같은 키가 되는 경우가 있다
   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) }));
+}
+
+// Count actual collection cycles, not app refreshes or retries within one request.
+// A long gap (sleep/offline), recovery, or missing observation breaks the streak.
+// Keep the status a string with its original prefix so existing apps/servers can read it.
+function advanceCollectionHealth(statuses, previous = {}, now = Date.now()) {
+  if (statuses === null) return { statuses: null, failures: {} };
+  const failures = {};
+  const annotated = {};
+  for (const [id, value] of Object.entries(statuses)) {
+    const status = value.split(";")[0];
+    if (!status.startsWith("error") && !status.startsWith("auth_expired")) {
+      annotated[id] = status;
+      continue;
+    }
+    const prev = previous?.[id];
+    const continues = Number.isSafeInteger(prev?.count) && prev.count > 0
+      && Number.isFinite(prev.since) && prev.since <= prev.lastAttempt
+      && Number.isFinite(prev.lastAttempt) && now >= prev.lastAttempt
+      && now - prev.lastAttempt <= 12 * 60_000;
+    const count = continues ? Math.min(prev.count + 1, 9999) : 1;
+    const since = continues ? prev.since : now;
+    failures[id] = { count, since, lastAttempt: now };
+    annotated[id] = `${status};failures=${count};since=${Math.floor(since / 1000)}`;
+  }
+  return { statuses: annotated, failures };
+}
+
+function recordCollectionHealth(statuses, {
+  file = HEALTH_FILE, scope = null, now = Date.now(), persist = true,
+} = {}) {
+  let previous = {};
+  try {
+    const saved = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (saved.scope === scope) previous = saved.failures;
+  } catch {}
+  const next = advanceCollectionHealth(statuses, previous, now);
+  if (persist) {
+    // Save independently of the payload: an upload failure must not erase attempts.
+    const temporary = `${file}.${process.pid}.tmp`;
+    try {
+      fs.writeFileSync(temporary, JSON.stringify({ scope, failures: next.failures }), { mode: 0o600 });
+      fs.renameSync(temporary, file);
+    } catch {
+      console.error("수집 실패 횟수를 저장하지 못했습니다");
+    } finally {
+      try { fs.rmSync(temporary, { force: true }); } catch {}
+    }
+  }
+  return next.statuses;
+}
+
 // 업로드 설정 — 우선순위: 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 {
@@ -866,7 +952,7 @@ function resolveMode() {
 }
 
 // 디바이스 토큰으로 charge_upload RPC 호출 (서버가 본인 행에만 기록)
-// fetchFn은 테스트 주입용 — 기본값이면 기존 동작 그대로.
+// fetchFn은 테스트 주입용, 기본값이면 기존 동작 그대로.
 async function pairedUpload(mode, daily, live, providers, collectStatus = null, { fetchFn = fetch } = {}) {
   const post = (body) =>
     fetchFn(`${mode.url}/rest/v1/rpc/charge_upload`, {
@@ -892,9 +978,9 @@ async function pairedUpload(mode, daily, live, providers, collectStatus = null,
     res = await post(legacyBody);
     if (res.ok) {
       // 이 경로로 올라간 사이클은 collect_status가 서버에 반영되지 않는다(파라미터 자체가 없다).
-      // 상태는 매 사이클 통째로 다시 보내므로 서버가 갱신되면 다음 5분에 저절로 복구된다 —
+      // 상태는 매 사이클 통째로 다시 보내므로 서버가 갱신되면 다음 5분에 저절로 복구된다 , 
       // 다만 "왜 상태가 비었나"를 로그 없이는 알 수 없어 흔적을 남긴다.
-      console.error("구버전 시그니처로 업로드 성공 — collect_status는 이번 사이클 미반영(다음 사이클에 복구)");
+      console.error("구버전 시그니처로 업로드 성공, collect_status는 이번 사이클 미반영(다음 사이클에 복구)");
       return;
     }
     throw new Error(`업로드 실패 (${res.status}): ${await res.text()}`);
@@ -903,6 +989,14 @@ async function pairedUpload(mode, daily, live, providers, collectStatus = null,
 }
 
 async function main() {
+  const mode = resolveMode();
+  // Scheduler environments do not inherit the shell used for pairing. Restore
+  // only the two non-secret location settings, never login tokens or API keys.
+  for (const key of ["CLAUDE_CONFIG_DIR", "CLAUDE_SECURESTORAGE_CONFIG_DIR"]) {
+    if (process.env[key] === undefined && typeof mode?.claude_environment?.[key] === "string") {
+      process.env[key] = mode.claude_environment[key];
+    }
+  }
   // 이전 성공 페이로드 캐시 — 일부 수집이 실패해도 그 부분만 이전 값으로 유지
   let cache = {};
   try {
@@ -928,7 +1022,7 @@ async function main() {
     live = liveR.value;
   } else {
     console.error(`live 수집 실패, 이전 값 유지: ${liveR.reason?.message ?? liveR.reason}`);
-    // 캐시 블록은 collected_at을 갱신하지 않고 통째로 재사용한다 — 갱신하면 수집이 깨진
+    // 캐시 블록은 collected_at을 갱신하지 않고 통째로 재사용한다, 갱신하면 수집이 깨진
     // 기기의 옛 블록이 다른 기기의 진짜 활성 블록을 서버 신선도 규칙에서 이겨버린다.
     live = cache.live ?? null;
   }
@@ -949,13 +1043,18 @@ async function main() {
     statuses: providerCollection.statuses,
   }));
 
+  providers = namespaceUnknownAccounts(providers, mode?.install_id);
+  statuses = recordCollectionHealth(statuses, {
+    scope: accountHash(mode?.token),
+    persist: !DRY_RUN && !!mode,
+  });
+
   if (DRY_RUN) {
     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);
@@ -977,7 +1076,10 @@ if (require.main === module) {
 
 module.exports = {
   CCUSAGE_PKG,
+  advanceCollectionHealth,
   accountHash,
+  claudeCredentialLocation,
+  claudeCredentials,
   claudeProvider,
   codexBarEntryToProvider,
   codexLiveWindows,
@@ -991,11 +1093,13 @@ module.exports = {
   fetchOnceRetried,
   freshestCredentials,
   mergeCachedProviders,
+  namespaceUnknownAccounts,
   normalizeRateWindow,
   normalizeResetAt,
   pairedUpload,
   parseCodexBarJSON,
   percentValue,
+  recordCollectionHealth,
   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.7",
+  "version": "0.1.9",
   "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",