pi-provider-qoder-cn 0.2.8 → 0.2.16

package/dist/index.js

@@ -93,6 +93,14 @@ var init_cn_naming = __esm({
 });
 
 // src/cosy.ts
+var cosy_exports = {};
+__export(cosy_exports, {
+  QODER_CLIENT_TYPE: () => QODER_CLIENT_TYPE,
+  QODER_GATEWAY_COSY_VERSION: () => QODER_GATEWAY_COSY_VERSION,
+  QODER_OPENAPI_COSY_VERSION: () => QODER_OPENAPI_COSY_VERSION,
+  buildAuthHeaders: () => buildAuthHeaders,
+  getMachineId: () => getMachineId
+});
 import crypto from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -379,6 +387,9 @@ function getQoderUsageURL(mode) {
 function getQoderRefreshURL(mode) {
   return `${getQoderOpenApiUrl(mode)}/api/v1/jobToken/refresh`;
 }
+function getQoderDeviceRefreshURL(mode) {
+  return `${getQoderOpenApiUrl(mode)}/api/v1/deviceToken/refresh`;
+}
 function getQoderDeviceLoginURL(codeChallenge, machineID, nonce) {
   const baseUrl = getQoderRegionConfig("global").deviceLoginUrl;
   if (!baseUrl) throw new Error("Qoder browser login URL is not configured");
@@ -428,7 +439,7 @@ var init_region = __esm({
         supportsBrowserLogin: false
       }
     };
-    QODER_PROVIDER_MODES = ["cn"];
+    QODER_PROVIDER_MODES = ["cn", "global"];
   }
 });
 
@@ -1099,6 +1110,38 @@ var init_catalog = __esm({
   }
 });
 
+// src/auth/expiry.ts
+function resolveTokenExpiryMs(expiresAt, expiresIn, now = Date.now()) {
+  if (expiresAt !== void 0 && expiresAt !== null && expiresAt !== "") {
+    if (typeof expiresAt === "number" && Number.isFinite(expiresAt) && expiresAt > 0) {
+      return expiresAt < 1e12 ? expiresAt * 1e3 : expiresAt;
+    }
+    const parsed = Date.parse(String(expiresAt));
+    if (!Number.isNaN(parsed)) return parsed;
+    const numeric = Number.parseInt(String(expiresAt), 10);
+    if (!Number.isNaN(numeric) && numeric > 0) {
+      return numeric < 1e12 ? numeric * 1e3 : numeric;
+    }
+  }
+  if (typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn > 0) {
+    return now + (expiresIn > ONE_DAY_SECONDS ? expiresIn : expiresIn * 1e3);
+  }
+  return now + FALLBACK_TTL_MS;
+}
+function toEpochMs(value, now = Date.now()) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return void 0;
+  const ms = value < 1e12 ? value * 1e3 : value;
+  return ms > now + 365 * 864e5 ? now + FALLBACK_TTL_MS : ms;
+}
+var ONE_DAY_SECONDS, FALLBACK_TTL_MS;
+var init_expiry = __esm({
+  "src/auth/expiry.ts"() {
+    "use strict";
+    ONE_DAY_SECONDS = 86400;
+    FALLBACK_TTL_MS = 24 * 36e5;
+  }
+});
+
 // src/auth/pat.ts
 var pat_exports = {};
 __export(pat_exports, {
@@ -1145,13 +1188,7 @@ async function exchangeJobToken(pat, mode) {
   if (!data.token) {
     throw new Error("Qoder PAT exchange returned no job token");
   }
-  let expiresAt = Date.now() + 24 * 60 * 60 * 1e3;
-  if (data.expires_at) {
-    const parsed = Date.parse(data.expires_at);
-    if (!Number.isNaN(parsed)) expiresAt = parsed;
-  } else if (data.expires_in) {
-    expiresAt = Date.now() + (data.expires_in > 86400 ? data.expires_in : data.expires_in * 1e3);
-  }
+  const expiresAt = resolveTokenExpiryMs(data.expires_at, data.expires_in);
   return {
     jobToken: data.token,
     jobRefreshToken: data.refresh_token || "",
@@ -1204,6 +1241,7 @@ var init_pat = __esm({
     "use strict";
     init_cosy();
     init_region();
+    init_expiry();
     UA = "pi-provider-qoder-cn";
     PAT_REFRESH_PREFIX = "pat";
   }
@@ -1235,16 +1273,7 @@ function generatePKCE() {
   return { codeVerifier, codeChallenge };
 }
 function parseExpiresAt(s, expiresInSeconds) {
-  if (s) {
-    const t = Date.parse(s);
-    if (!Number.isNaN(t)) return t;
-    const ms = Number.parseInt(s, 10);
-    if (!Number.isNaN(ms) && ms > 0) return ms;
-  }
-  if (expiresInSeconds && expiresInSeconds > 0) {
-    return Date.now() + expiresInSeconds * 1e3;
-  }
-  return Date.now() + 30 * 24 * 60 * 60 * 1e3;
+  return resolveTokenExpiryMs(s, expiresInSeconds);
 }
 async function confirmCnEndpoint(callbacks, mode) {
   if (mode !== "cn") return;
@@ -1415,6 +1444,9 @@ async function runDeviceFlow(callbacks) {
       if (!tokenData.token) {
         throw new Error("Device token poll returned empty access token");
       }
+      if (!tokenData.refresh_token) {
+        throw new Error("Device token poll returned no refresh token");
+      }
       const expireMs = parseExpiresAt(tokenData.expires_at, tokenData.expires_in);
       getProgress(callbacks)?.("Fetching user profile...");
       let email = "";
@@ -1462,6 +1494,7 @@ var init_login = __esm({
     init_cosy();
     init_region();
     init_vpc();
+    init_expiry();
     init_pat();
   }
 });
@@ -1475,12 +1508,12 @@ __export(oauth_exports, {
   getQoderPatForMode: () => getQoderPatForMode,
   loginQoderForMode: () => loginQoderForMode,
   refreshQoderTokenForMode: () => refreshQoderTokenForMode,
-  resolveQoderIdentity: () => resolveQoderIdentity
+  resolveQoderIdentity: () => resolveQoderIdentity,
+  saveCredentialsToAuthFile: () => saveCredentialsToAuthFile
 });
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync, rmSync, statSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname3, join as join4 } from "node:path";
-import * as PiCodingAgent from "@earendil-works/pi-coding-agent";
 function getHomeDir4() {
   return process.env.HOME || process.env.USERPROFILE || homedir4();
 }
@@ -1493,17 +1526,17 @@ function clearQoderAuthMemCache() {
 }
 function readAuthFileCached() {
   const authPath = getAuthFilePath();
-  if (authFileMem !== void 0) {
-    if (authFileMem === null) return null;
-    if (authFileMem.path === authPath) return authFileMem.data;
-  }
   if (!existsSync4(authPath)) {
     authFileMem = null;
     return null;
   }
   try {
+    const stat = statSync(authPath);
+    if (authFileMem && authFileMem.path === authPath && authFileMem.mtimeMs === stat.mtimeMs) {
+      return authFileMem.data;
+    }
     const data = JSON.parse(readFileSync4(authPath, "utf-8"));
-    authFileMem = { path: authPath, data };
+    authFileMem = { path: authPath, data, mtimeMs: stat.mtimeMs };
     return data;
   } catch {
     authFileMem = null;
@@ -1532,8 +1565,25 @@ function saveCredentialsToAuthFile(providerID, credentials) {
       auth = cached ? { ...cached } : {};
     }
     auth[providerID] = { type: "oauth", ...credentials };
-    writeFileSync4(authPath, JSON.stringify(auth, null, 2), { encoding: "utf-8", mode: 384 });
-    authFileMem = { path: authPath, data: auth };
+    const tmp = `${authPath}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync4(tmp, JSON.stringify(auth, null, 2), { encoding: "utf-8", mode: 384 });
+    let published = false;
+    for (let attempt = 0; attempt < 3 && !published; attempt++) {
+      try {
+        renameSync(tmp, authPath);
+        published = true;
+      } catch (err) {
+        if (attempt === 2) {
+          console.error(`[pi-provider-qoder] rename failed for ${authPath}, falling back to direct write:`, err);
+          writeFileSync4(authPath, JSON.stringify(auth, null, 2), { encoding: "utf-8", mode: 384 });
+          published = true;
+        } else {
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25 * (attempt + 1));
+        }
+      }
+    }
+    rmSync(tmp, { force: true });
+    authFileMem = { path: authPath, data: auth, mtimeMs: statSync(authPath).mtimeMs };
     const q = credentials;
     if (q.access && q.userID) {
       identityCache.set(`${providerID}:${q.access}`, q);
@@ -1546,23 +1596,14 @@ async function autoLoginQoderFromEnvironment(providerID, mode) {
   const pat = getQoderPatForMode(mode);
   if (!pat) return;
   const credentials = await credentialsFromPat(pat, mode);
-  if (typeof AuthStorage2?.create === "function") {
-    try {
-      const authStorage = AuthStorage2.create();
-      authStorage.set(providerID, { type: "oauth", ...credentials });
-    } catch {
-      saveCredentialsToAuthFile(providerID, credentials);
-    }
-  } else {
-    saveCredentialsToAuthFile(providerID, credentials);
-  }
+  saveCredentialsToAuthFile(providerID, credentials);
   const qCreds = credentials;
   await updateQoderModelsCache(qCreds.access, qCreds.userID, qCreds.name, qCreds.email, mode);
 }
 function getCachedCredentials(_accessToken, providerID = "qoder") {
   const auth = readAuthFileCached();
   if (!auth) return null;
-  const creds = auth[providerID] || (providerID === "qoder" ? auth.qoder : null);
+  const creds = auth[providerID];
   if (creds?.userID || creds?.access) {
     if (creds.access && creds.userID) {
       identityCache.set(`${providerID}:${creds.access}`, creds);
@@ -1594,7 +1635,9 @@ async function resolveQoderIdentity(accessToken, providerID, mode) {
     expires: stored?.expires || 0
   };
   identityCache.set(cacheKey, creds);
-  saveCredentialsToAuthFile(providerID, creds);
+  if (stored?.refresh && info.userID && (!stored.access || stored.access === accessToken)) {
+    saveCredentialsToAuthFile(providerID, creds);
+  }
   return creds;
 }
 async function loginQoderForMode(callbacks, mode) {
@@ -1614,62 +1657,93 @@ async function loginQoderForMode(callbacks, mode) {
   const creds = await interactiveLogin(callbacks, mode);
   try {
     const qCreds = creds;
-    updateQoderModelsCache(qCreds.access, qCreds.userID, qCreds.name, qCreds.email, mode).catch(() => {
-    });
+    await updateQoderModelsCache(qCreds.access, qCreds.userID, qCreds.name, qCreds.email, mode);
   } catch {
   }
   saveCredentialsToAuthFile(providerID, creds);
   return creds;
 }
-async function refreshQoderTokenForMode(credentials, mode) {
+async function refreshQoderTokenForMode(credentials, mode, signal) {
+  const providerID = getQoderRegionConfig(mode).providerID;
+  const existing = inFlightRefreshes.get(providerID);
+  if (existing) return existing;
+  const promise = (async () => {
+    try {
+      return await executeRefreshForMode(credentials, mode, signal);
+    } finally {
+      inFlightRefreshes.delete(providerID);
+    }
+  })();
+  inFlightRefreshes.set(providerID, promise);
+  return promise;
+}
+async function executeRefreshForMode(credentials, mode, signal) {
+  const region = getQoderRegionConfig(mode);
+  const providerID = region.providerID;
   if (isPatRefresh(credentials.refresh)) {
     const { pat } = decodePatRefresh(credentials.refresh);
     if (pat) {
       try {
         const refreshed = await credentialsFromPat(pat, mode);
         const qCreds = refreshed;
+        saveCredentialsToAuthFile(providerID, refreshed);
         updateQoderModelsCache(qCreds.access, qCreds.userID, qCreds.name, qCreds.email, mode).catch(() => {
         });
         return refreshed;
-      } catch {
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `${region.loginName} credential refresh failed (PAT re-exchange): ${detail}. If this persists, the PAT may be revoked \u2014 run /login ${providerID}.`
+        );
       }
     }
-    return {
-      ...credentials,
-      expires: Date.now() + 60 * 60 * 1e3
-      // extend 1 hour to retry later
-    };
+    throw new Error(
+      `${region.loginName} credential refresh failed: the stored refresh chain carries no PAT. Run /login ${providerID}.`
+    );
   }
   const parts = credentials.refresh.split("|");
   const refreshToken = parts[0] || "";
+  if (!refreshToken) {
+    throw new Error(
+      `${region.loginName} credential has no stored refresh chain (written by an older version). Run /login ${providerID} once.`
+    );
+  }
   const userID = parts[1] || "";
   const machineID = parts[2] || getMachineId();
   const prev = credentials;
   const prevName = prev.name || "";
   const prevEmail = prev.email || "";
-  const refreshURL = getQoderRefreshURL(mode);
-  try {
-    const response = await fetch(refreshURL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${credentials.access}`,
-        Accept: "application/json",
-        "User-Agent": "pi-provider-qoder-cn"
-      },
-      body: JSON.stringify({ refresh_token: refreshToken })
-    });
+  const isDevice = refreshToken.startsWith("drt-");
+  const refreshURL = isDevice ? getQoderDeviceRefreshURL(mode) : getQoderRefreshURL(mode);
+  const body = JSON.stringify({ refresh_token: refreshToken });
+  const failures = [];
+  for (const withAuth of [true, false]) {
+    let response;
+    try {
+      response = await fetch(refreshURL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...withAuth ? { Authorization: `Bearer ${credentials.access}` } : {},
+          Accept: "application/json",
+          "User-Agent": "pi-provider-qoder-cn"
+        },
+        body,
+        signal
+      });
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      failures.push(error instanceof Error ? error.message : String(error));
+      break;
+    }
     if (response.ok) {
       const data = await response.json();
-      const newAccess = data.token;
-      const newRefresh = data.refresh_token || refreshToken;
-      let expireMs = Date.now() + 30 * 24 * 60 * 60 * 1e3;
-      if (data.expires_at) {
-        const parsed = Date.parse(data.expires_at);
-        if (!Number.isNaN(parsed)) expireMs = parsed;
-      } else if (data.expires_in) {
-        expireMs = Date.now() + (data.expires_in > 86400 ? data.expires_in : data.expires_in * 1e3);
+      const newAccess = typeof data.token === "string" && data.token ? data.token : data.access_token;
+      if (typeof newAccess !== "string" || !newAccess) {
+        throw new Error("token refresh response carried no access token");
       }
+      const newRefresh = data.refresh_token || refreshToken;
+      const expireMs = resolveTokenExpiryMs(data.expires_at, data.expires_in);
       const refreshed = {
         ...credentials,
         refresh: `${newRefresh}|${userID}|${machineID}`,
@@ -1680,30 +1754,29 @@ async function refreshQoderTokenForMode(credentials, mode) {
         name: prevName,
         machineID
       };
+      saveCredentialsToAuthFile(providerID, refreshed);
       updateQoderModelsCache(newAccess, userID, prevName, prevEmail, mode).catch(() => {
       });
       return refreshed;
     }
-  } catch {
+    const errText = await response.text();
+    failures.push(`${response.status} ${response.statusText}: ${errText.slice(0, 120)}`);
+    if (response.status !== 401 && response.status !== 403 || !withAuth) break;
   }
-  const refreshedFallback = {
-    ...credentials,
-    expires: Date.now() + 60 * 60 * 1e3
-    // extend for 1 hour
-  };
-  return refreshedFallback;
+  throw new Error(`${region.loginName} token refresh failed (${failures.join(" | ")}). Run /login ${providerID}.`);
 }
-var AuthStorage2, identityCache, authFileMem;
+var identityCache, authFileMem, inFlightRefreshes;
 var init_oauth = __esm({
   "src/auth/oauth.ts"() {
     "use strict";
     init_catalog();
     init_cosy();
     init_region();
+    init_expiry();
     init_login();
     init_pat();
-    AuthStorage2 = PiCodingAgent.AuthStorage;
     identityCache = /* @__PURE__ */ new Map();
+    inFlightRefreshes = /* @__PURE__ */ new Map();
   }
 });
 
@@ -1764,7 +1837,400 @@ async function fetchQoderUsageForMode(credentials, mode) {
 // src/index.ts
 init_catalog();
 
+// src/commands/claim.ts
+init_expiry();
+init_cosy();
+init_region();
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir5, hostname } from "node:os";
+import { basename, dirname as dirname4, join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+function piAgentDir2() {
+  const home = process.env.HOME || process.env.USERPROFILE || homedir5();
+  return join5(home, ".pi", "agent");
+}
+function getCheckinCachePath(mode = "cn") {
+  const file = mode === "cn" ? "qoder-cn-checkin.json" : "qoder-checkin.json";
+  return join5(piAgentDir2(), file);
+}
+function readCheckinCache(mode = "cn") {
+  try {
+    const file = getCheckinCachePath(mode);
+    if (!existsSync5(file)) return null;
+    return JSON.parse(readFileSync5(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeCheckinCache(info, mode = "cn") {
+  try {
+    const file = getCheckinCachePath(mode);
+    const dir = dirname4(file);
+    if (!existsSync5(dir)) mkdirSync5(dir, { recursive: true });
+    writeFileSync5(file, JSON.stringify(info, null, 2), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m"
+};
+function paint(text, code) {
+  return code && text ? `${code}${text}${ANSI.reset}` : text;
+}
+function msUntilBeijing10AM(now = Date.now()) {
+  const beijingOffset = 8 * 36e5;
+  const beijingTime = now + beijingOffset;
+  const beijingDate = new Date(beijingTime);
+  let targetUtc = Date.UTC(beijingDate.getUTCFullYear(), beijingDate.getUTCMonth(), beijingDate.getUTCDate(), 10, 0, 0);
+  if (beijingTime >= targetUtc) {
+    targetUtc += 24 * 36e5;
+  }
+  return targetUtc - beijingTime;
+}
+function formatCountdownBeijing(ms) {
+  const totalMinutes = Math.max(1, Math.round(ms / 6e4));
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return hours > 0 ? `${hours}\u5C0F\u65F6${minutes}\u5206\u949F` : `${minutes}\u5206\u949F`;
+}
+function formatDateTime(isoOrMs) {
+  if (!isoOrMs) return "n/a";
+  const d = new Date(isoOrMs);
+  if (Number.isNaN(d.getTime())) return String(isoOrMs);
+  return new Intl.DateTimeFormat("zh-CN", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  }).format(d);
+}
+var printableAscii = (v) => typeof v === "string" && v.trim().length > 0 && /^[\x20-\x7e]+$/.test(v.trim());
+var identityMemCache = /* @__PURE__ */ new Map();
+var IDENTITY_TTL_MS = 30 * 6e4;
+function candidateUmidExes() {
+  const custom = process.env.QODER_UMID_EXE;
+  if (custom) return [custom];
+  const candidates = [];
+  if (process.platform === "win32") {
+    const moduleDir = dirname4(fileURLToPath(import.meta.url));
+    const pkgRoot = basename(moduleDir) === "commands" ? dirname4(dirname4(moduleDir)) : dirname4(moduleDir);
+    candidates.push(join5(pkgRoot, "bin", "runtime-info.exe"));
+  }
+  const localAppData = process.env.LOCALAPPDATA || join5(process.env.HOME || process.env.USERPROFILE || homedir5(), "AppData", "Local");
+  for (const r of [join5(localAppData, "Programs", "Qoder"), "C:\\Program Files\\Qoder", "D:\\Qoder"]) {
+    candidates.push(join5(r, "resources", "umid", "runtime-info.exe"));
+  }
+  return candidates;
+}
+function runUmidExe(exe, environment, accountId) {
+  const res = spawnSync(exe, [String(environment), "--account-stdin"], {
+    input: JSON.stringify({ account: accountId }),
+    timeout: 1e4,
+    windowsHide: true,
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024
+  });
+  if (res.error) throw res.error;
+  if (res.status !== 0) throw new Error(`runtime-info exited ${res.status}: ${String(res.stderr || "").slice(0, 120)}`);
+  return String(res.stdout || "");
+}
+async function resolveSashMachineIdentity(mode, accountId) {
+  if (!accountId) return null;
+  const key = `${mode}:${accountId}`;
+  const hit = identityMemCache.get(key);
+  if (hit && hit.expiresAt > Date.now()) return hit.identity;
+  const environment = mode === "global" ? 3 : 0;
+  for (const exe of candidateUmidExes()) {
+    if (!existsSync5(exe)) continue;
+    try {
+      const stdout = await runUmidExe(exe, environment, accountId);
+      const parsed = JSON.parse(stdout);
+      if (!printableAscii(parsed.machineToken) || !printableAscii(parsed.machineCode) || !printableAscii(parsed.machineType)) {
+        continue;
+      }
+      const identity = {
+        machineToken: parsed.machineToken.trim(),
+        machineCode: parsed.machineCode.trim(),
+        machineType: parsed.machineType.trim()
+      };
+      identityMemCache.set(key, { identity, expiresAt: Date.now() + IDENTITY_TTL_MS });
+      return identity;
+    } catch {
+    }
+  }
+  return null;
+}
+function buildSashHeaders(accessToken, machineID, identity) {
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    "Cosy-ClientType": "10",
+    "Cosy-Version": "1.13.3",
+    "Cosy-MachineId": machineID,
+    "Cosy-MachineOS": "x86_64_windows",
+    "Cosy-MachineHostname": hostname(),
+    "User-Agent": "Qoder"
+  };
+  if (identity) {
+    headers["Cosy-MachineToken"] = identity.machineToken;
+    headers["Cosy-MachineCode"] = identity.machineCode;
+    headers["Cosy-MachineType"] = identity.machineType;
+  }
+  return headers;
+}
+async function fetchQoderCampaigns(accessToken, machineID, mode, identity) {
+  const url = `${getQoderOpenApiUrl(mode)}/sash/api/v1/me/campaigns?forceRefresh=true`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: buildSashHeaders(accessToken, machineID, identity),
+    signal: AbortSignal.timeout(1e4)
+  });
+  const text = await response.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = void 0;
+  }
+  if (!response.ok) {
+    const detail = data?.message || text.slice(0, 200);
+    throw new Error(`Failed to query Qoder campaigns (${response.status}): ${detail}`);
+  }
+  if (!data) throw new Error("Qoder campaigns response was not JSON.");
+  return data;
+}
+async function claimQoderCampaign(accessToken, machineID, campaignId, mode, identity) {
+  const url = `${getQoderOpenApiUrl(mode)}/sash/api/v1/me/campaigns/${encodeURIComponent(campaignId)}/claim`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: buildSashHeaders(accessToken, machineID, identity),
+    body: JSON.stringify({}),
+    signal: AbortSignal.timeout(1e4)
+  });
+  const text = await response.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = void 0;
+  }
+  if (!response.ok) {
+    const detail = data?.message || text.slice(0, 200);
+    throw new Error(`Failed to claim Qoder benefit (${response.status}): ${detail}`);
+  }
+  if (!data) throw new Error("Qoder claim response was not JSON.");
+  return data;
+}
+async function fetchCheckinGrantInfo(accessToken, machineID, mode, identity) {
+  const cached = readCheckinCache(mode);
+  if (cached?.claimed && cached.expiresAt && cached.cacheUntil && Date.now() < cached.cacheUntil) {
+    return cached;
+  }
+  try {
+    const campaignsData = await fetchQoderCampaigns(accessToken, machineID, mode, identity);
+    const campaigns = campaignsData.campaigns || [];
+    const dailyCreditCampaign = campaigns.find(
+      (c) => c.actionType === "CLAIM_BENEFIT" && (c.benefit?.kind === "CREDITS" || c.benefit?.amount === 100)
+    ) || campaigns.find((c) => c.actionType === "CLAIM_BENEFIT");
+    if (!dailyCreditCampaign) return null;
+    const title = dailyCreditCampaign.placements?.[0]?.content?.zh?.title || "\u6BCF\u5929\u9886 100 Credits";
+    const amount = dailyCreditCampaign.benefit?.amount || 100;
+    const validityDays = dailyCreditCampaign.benefit?.validity?.days || 30;
+    const endAtMs = toEpochMs(dailyCreditCampaign.endAt);
+    const cacheUntil = endAtMs && endAtMs > Date.now() ? endAtMs : Date.now() + msUntilBeijing10AM();
+    let info;
+    if (dailyCreditCampaign.claimStatus === "CLAIMED") {
+      try {
+        const claimRes = await claimQoderCampaign(
+          accessToken,
+          machineID,
+          dailyCreditCampaign.campaignId,
+          mode,
+          identity
+        );
+        info = {
+          claimed: true,
+          amount: claimRes.benefit?.amount || amount,
+          claimedAt: claimRes.claimedAt || cached?.claimedAt,
+          expiresAt: claimRes.expiresAt || cached?.expiresAt,
+          validityDays: claimRes.benefit?.validity?.days || validityDays,
+          campaignId: dailyCreditCampaign.campaignId,
+          campaignTitle: title,
+          cacheUntil
+        };
+      } catch {
+        info = {
+          claimed: true,
+          amount,
+          claimedAt: cached?.claimedAt,
+          expiresAt: cached?.expiresAt,
+          validityDays,
+          campaignId: dailyCreditCampaign.campaignId,
+          campaignTitle: title,
+          cacheUntil
+        };
+      }
+    } else {
+      info = {
+        claimed: false,
+        amount,
+        validityDays,
+        campaignId: dailyCreditCampaign.campaignId,
+        campaignTitle: title,
+        cacheUntil
+      };
+    }
+    writeCheckinCache(info, mode);
+    return info;
+  } catch {
+    return readCheckinCache(mode);
+  }
+}
+async function resolveCredentials(providerID, ctx) {
+  let accessToken;
+  try {
+    accessToken = await ctx?.modelRegistry?.getApiKeyForProvider(providerID) || void 0;
+  } catch {
+  }
+  const { getCachedCredentials: getCachedCredentials2 } = await Promise.resolve().then(() => (init_oauth(), oauth_exports));
+  const stored = getCachedCredentials2("", providerID);
+  accessToken = accessToken || stored?.access || void 0;
+  if (!accessToken) return null;
+  const machineID = stored?.machineID || getMachineId();
+  const userID = stored?.userID || "";
+  return { accessToken, machineID, userID };
+}
+async function runClaimCommand(mode, args, ctx) {
+  const region = getQoderRegionConfig(mode);
+  const providerID = region.providerID;
+  const wantsRaw = ["json", "raw", "debug"].includes((args || "").trim().toLowerCase());
+  try {
+    const creds = await resolveCredentials(providerID, ctx);
+    if (!creds) {
+      const msg = mode === "cn" ? `\u672A\u627E\u5230 ${providerID} \u767B\u5F55\u51ED\u636E\uFF0C\u8BF7\u5148\u8FD0\u884C /login ${providerID}` : `No ${providerID} credentials found. Run /login ${providerID} first.`;
+      ctx?.ui?.notify(msg, "warning");
+      if (!ctx?.ui) console.warn(msg);
+      return;
+    }
+    const { accessToken, machineID, userID } = creds;
+    const identity = await resolveSashMachineIdentity(mode, userID).catch(() => null);
+    const campaignsData = await fetchQoderCampaigns(accessToken, machineID, mode, identity);
+    const campaigns = campaignsData.campaigns || [];
+    const dailyCreditCampaign = campaigns.find(
+      (c) => c.actionType === "CLAIM_BENEFIT" && (c.benefit?.kind === "CREDITS" || c.benefit?.amount === 100)
+    ) || campaigns.find((c) => c.actionType === "CLAIM_BENEFIT");
+    if (!dailyCreditCampaign) {
+      if (wantsRaw) {
+        const rawJson = JSON.stringify(campaignsData, null, 2);
+        ctx?.ui?.notify(rawJson, "info");
+        if (!ctx?.ui) console.log(rawJson);
+        return;
+      }
+      const msg = identity === null ? mode === "cn" ? "\u26A0\uFE0F \u672A\u627E\u5230 Qoder \u684C\u9762\u7AEF\u8BBE\u5907\u6307\u7EB9\u7EC4\u4EF6\uFF08runtime-info.exe\uFF09\uFF0C\u670D\u52A1\u7AEF\u56E0\u6B64\u4E0D\u4E0B\u53D1\u53EF\u9886\u53D6\u7684\u7B7E\u5230\u6D3B\u52A8\u3002\u8BF7\u5B89\u88C5\u5E76\u6253\u5F00 Qoder \u684C\u9762\u7AEF\uFF0C\u6216\u8BBE\u7F6E QODER_UMID_EXE \u6307\u5411\u5176 resources/umid/runtime-info.exe \u540E\u91CD\u8BD5\u3002" : "\u26A0\uFE0F Daily check-in campaigns are hidden without desktop device attestation, and the Qoder desktop UMID component (runtime-info.exe) was not found on this machine.\n- Install/launch the Qoder desktop app, or set QODER_UMID_EXE to its resources/umid/runtime-info.exe, then retry." : mode === "cn" ? "\u2139\uFE0F \u5F53\u524D\u6682\u65E0\u53EF\u9886\u53D6\u7684\u7B7E\u5230\u6D3B\u52A8\uFF08\u6BCF\u65E5 10:00 UTC+8 \u5F00\u653E\u5237\u65B0\uFF09" : "\u2139\uFE0F Device verified, but no claimable check-in campaign is offered for this account/region right now (the campaign list carries banners only; claims reset at 10:00 UTC+8 when offered).";
+      ctx?.ui?.notify(msg, identity === null ? "warning" : "info");
+      if (!ctx?.ui) console.log(msg);
+      return;
+    }
+    const content = mode === "cn" ? dailyCreditCampaign.placements?.[0]?.content?.zh || dailyCreditCampaign.placements?.[0]?.content?.en : dailyCreditCampaign.placements?.[0]?.content?.en || dailyCreditCampaign.placements?.[0]?.content?.zh;
+    const campaignTitle = content?.title || (mode === "cn" ? "\u6BCF\u5929\u9886 100 Credits" : "Claim 100 Credits Daily");
+    const amount = dailyCreditCampaign.benefit?.amount || 100;
+    const validityDays = dailyCreditCampaign.benefit?.validity?.days || 30;
+    const endAtMs = toEpochMs(dailyCreditCampaign.endAt);
+    const remainingToReset = endAtMs && endAtMs > Date.now() ? endAtMs - Date.now() : msUntilBeijing10AM();
+    const countdown = formatCountdownBeijing(remainingToReset);
+    if (dailyCreditCampaign.claimStatus === "CLAIMED") {
+      const cached = readCheckinCache(mode);
+      writeCheckinCache(
+        {
+          claimed: true,
+          amount,
+          validityDays,
+          campaignId: dailyCreditCampaign.campaignId,
+          campaignTitle,
+          claimedAt: cached?.claimedAt,
+          expiresAt: cached?.expiresAt,
+          cacheUntil: Date.now() + remainingToReset
+        },
+        mode
+      );
+      if (wantsRaw) {
+        const rawJson = JSON.stringify(dailyCreditCampaign, null, 2);
+        ctx?.ui?.notify(rawJson, "info");
+        if (!ctx?.ui) console.log(rawJson);
+        return;
+      }
+      const lines2 = mode === "cn" ? [
+        paint(`\u2139\uFE0F \u4ECA\u65E5 ${amount} Credits \u5DF2\u7ECF\u9886\u53D6\u8FC7\uFF0C\u65E0\u9700\u91CD\u590D\u64CD\u4F5C`, ANSI.cyan),
+        `- \u6D3B\u52A8\u540D\u79F0\uFF1A${campaignTitle}`,
+        `- \u989D\u5EA6\u8BF4\u660E\uFF1A${amount} Credits\uFF08\u5168\u6A21\u578B\u901A\u7528\u8D44\u6E90\u5305\uFF0C${validityDays} \u5929\u6709\u6548\uFF09`,
+        `- \u4E0B\u6B21\u5237\u65B0\uFF1A\u660E\u65E5 10:00 UTC+8\uFF08\u8DDD\u5237\u65B0\u7EA6 ${countdown}\uFF09`
+      ] : [
+        paint(`\u2139\uFE0F Today's ${amount} Credits already claimed.`, ANSI.cyan),
+        `- Campaign: ${campaignTitle}`,
+        `- Benefit: ${amount} Credits (${validityDays}-day validity)`,
+        `- Next reset: Daily at 10:00 UTC+8 (in ~${countdown})`
+      ];
+      const output2 = lines2.join("\n");
+      ctx?.ui?.notify(output2, "info");
+      if (!ctx?.ui) console.log(output2);
+      return;
+    }
+    const claimRes = await claimQoderCampaign(accessToken, machineID, dailyCreditCampaign.campaignId, mode, identity);
+    const grantAmount = claimRes.benefit?.amount || amount;
+    const grantDays = claimRes.benefit?.validity?.days || validityDays;
+    const expiresText = claimRes.expiresAt ? formatDateTime(claimRes.expiresAt) : `${grantDays} \u5929\u540E`;
+    writeCheckinCache(
+      {
+        claimed: true,
+        amount: grantAmount,
+        claimedAt: claimRes.claimedAt,
+        expiresAt: claimRes.expiresAt,
+        validityDays: grantDays,
+        campaignId: dailyCreditCampaign.campaignId,
+        campaignTitle,
+        cacheUntil: Date.now() + remainingToReset
+      },
+      mode
+    );
+    const lines = mode === "cn" ? [
+      paint(`\u{1F389} \u6210\u529F\u9886\u53D6\u4ECA\u65E5 ${grantAmount} Credits\uFF01`, `${ANSI.green}${ANSI.bold}`),
+      `- \u989D\u5EA6\u7C7B\u578B\uFF1A\u5168\u6A21\u578B\u901A\u7528\u8D44\u6E90\u5305\uFF08Add-on Credits\uFF09`,
+      `- \u6709\u6548\u671F\u9650\uFF1A${grantDays} \u5929\uFF08\u6709\u6548\u671F\u81F3 ${expiresText}\uFF09`,
+      `- \u9886\u53D6\u6D41\u6C34\uFF1A${claimRes.grantId || "ok"}`,
+      `- \u4E0B\u6B21\u5237\u65B0\uFF1A\u660E\u65E5 10:00 UTC+8\uFF08\u8DDD\u5237\u65B0\u7EA6 ${countdown}\uFF09`
+    ] : [
+      paint(`\u{1F389} Successfully claimed ${grantAmount} Credits!`, `${ANSI.green}${ANSI.bold}`),
+      `- Type: Universal Add-on Credits`,
+      `- Validity: ${grantDays} days (expires ${expiresText})`,
+      `- Grant ID: ${claimRes.grantId || "ok"}`,
+      `- Next reset: Daily at 10:00 UTC+8 (in ~${countdown})`
+    ];
+    const output = lines.join("\n");
+    ctx?.ui?.notify(output, "info");
+    if (!ctx?.ui) console.log(output);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const errText = mode === "cn" ? `\u274C \u6BCF\u65E5\u7B7E\u5230\u9886\u53D6\u5931\u8D25: ${message}` : `\u274C Daily check-in claim failed: ${message}`;
+    ctx?.ui?.notify(errText, "error");
+    if (!ctx?.ui) console.error(errText);
+  }
+}
+
 // src/protocol/errors.ts
+init_vpc();
 function parseQoderErrorPayload(payload) {
   if (!payload) return null;
   let parsed = payload;
@@ -1819,12 +2285,21 @@ function getBeijingDailyResetCountdown(now = Date.now()) {
   const minutes = totalMinutes % 60;
   return hours > 0 ? `${hours}\u5C0F\u65F6${minutes}\u5206\u949F` : `${minutes}\u5206\u949F`;
 }
-function formatQoderStreamError(statusCode, rawBody, now = Date.now()) {
+function formatQoderStreamError(statusCode, rawBody, now = Date.now(), mode = "cn") {
   const parsed = parseQoderErrorPayload(rawBody);
   const code = parsed?.code;
   const message = parsed?.message || (typeof rawBody === "string" ? rawBody : JSON.stringify(rawBody));
   const countdown = getBeijingDailyResetCountdown(now);
+  const isCn = mode !== "global";
   if (code === "110" || /billing daily count exceeded/i.test(message) || /daily usage limit reached/i.test(message)) {
+    if (!isCn) {
+      return [
+        `[Qoder quota limit] Daily call allowance exhausted (Billing daily count exceeded, code 110)`,
+        `- Reset: at 00:00 UTC+8 (in ${countdown})`,
+        `- Reason: the account is on the free personal standard plan or tripped the daily frequency fuse. Add-on credits stay unspendable while the daily cap is active.`,
+        `- Fix: wait for the reset; switch provider with /model; or upgrade at https://qoder.com/pricing to lift the daily limit.`
+      ].join("\n");
+    }
     return [
       `[Qoder CN \u989D\u5EA6\u9650\u5236] \u4ECA\u65E5\u8C03\u7528\u6B21\u6570\u5DF2\u8FBE\u4E0A\u9650 (Billing daily count exceeded, \u9519\u8BEF\u7801 110)`,
       `- \u5237\u65B0\u65F6\u95F4\uFF1A\u5C06\u5728\u5317\u4EAC\u65F6\u95F4 00:00 \u91CD\u7F6E\uFF08\u7EA6 ${countdown}\u540E\uFF09`,
@@ -1833,44 +2308,71 @@ function formatQoderStreamError(statusCode, rawBody, now = Date.now()) {
     ].join("\n");
   }
   if (code === "117" || /team member credits exhausted/i.test(message)) {
-    return [
+    return isCn ? [
       `[Qoder CN \u4F01\u4E1A\u989D\u5EA6\u9650\u5236] \u4F01\u4E1A\u5206\u914D\u7ED9\u60A8\u7684\u4E2A\u4EBA Credits \u989D\u5EA6\u5DF2\u7528\u5C3D (\u9519\u8BEF\u7801 117)`,
       `- \u9650\u5236\u539F\u56E0\uFF1A\u7BA1\u7406\u5458\u5728\u4F01\u4E1A\u63A7\u5236\u53F0\u5206\u914D\u7ED9\u60A8\u4E2A\u4EBA\u7684\u53EF\u7528 Credits \u989D\u5EA6\u5DF2\u8017\u5C3D\u3002`,
       `- \u89E3\u51B3\u5EFA\u8BAE\uFF1A\u8BF7\u8054\u7CFB\u4F01\u4E1A\u7BA1\u7406\u5458\u5728 Qoder \u56E2\u961F\u7BA1\u7406\u540E\u53F0\u4E3A\u60A8\u589E\u52A0\u6210\u5458 Credits \u914D\u989D\u3002`
+    ].join("\n") : [
+      `[Qoder enterprise quota] Your member credit allowance is exhausted (code 117)`,
+      `- Reason: the admin-assigned per-member credit cap has been consumed.`,
+      `- Fix: ask your organization admin to raise your member quota in the team console.`
     ].join("\n");
   }
   if (code === "116" || /team administrator credits exhausted/i.test(message)) {
-    return [
+    return isCn ? [
       `[Qoder CN \u4F01\u4E1A\u989D\u5EA6\u9650\u5236] \u4F01\u4E1A/\u56E2\u961F\u7BA1\u7406\u5458\u7684 Credits \u603B\u4F59\u989D\u5DF2\u8017\u5C3D (\u9519\u8BEF\u7801 116)`,
       `- \u9650\u5236\u539F\u56E0\uFF1A\u5F53\u524D\u4F01\u4E1A\u7EC4\u7EC7\u8D26\u6237\u7684 Credits \u989D\u5EA6\u5DF2\u5168\u90E8\u7528\u5B8C\u3002`,
       `- \u89E3\u51B3\u5EFA\u8BAE\uFF1A\u8BF7\u8054\u7CFB\u4F01\u4E1A\u7BA1\u7406\u5458\u5728\u63A7\u5236\u53F0\u4E3A\u7EC4\u7EC7\u8D26\u6237\u5145\u503C\u6216\u7EED\u671F\u3002`
+    ].join("\n") : [
+      `[Qoder enterprise quota] The organization's credit pool is exhausted (code 116)`,
+      `- Reason: every credit in the organization account has been consumed.`,
+      `- Fix: ask your organization admin to purchase or renew the org pool.`
     ].join("\n");
   }
   if (code === "122" || /billing-group credits limit reached/i.test(message)) {
-    return [
+    return isCn ? [
       `[Qoder CN \u4F01\u4E1A\u8BA1\u8D39\u7EC4\u9650\u5236] \u60A8\u6240\u5728\u7684\u4F01\u4E1A\u8BA1\u8D39\u7EC4\u5DF2\u8FBE\u5230\u672C\u671F\u652F\u51FA\u4E0A\u9650 (\u9519\u8BEF\u7801 122)`,
       `- \u9650\u5236\u539F\u56E0\uFF1A\u8BA1\u8D39\u7EC4\u5468\u671F\u5185\u5DF2\u6D88\u8017\u5B8C\u7BA1\u7406\u5458\u8BBE\u5B9A\u7684\u4E0A\u9650\u989D\u5EA6\u3002`,
       `- \u89E3\u51B3\u5EFA\u8BAE\uFF1A\u8BF7\u8054\u7CFB\u8BA1\u8D39\u7BA1\u7406\u5458\u6216\u4F01\u4E1A\u7BA1\u7406\u5458\u8C03\u6574\u8BE5\u8BA1\u8D39\u7EC4\u7684\u5468\u671F\u652F\u51FA\u4E0A\u9650\u3002`
+    ].join("\n") : [
+      `[Qoder billing group] The billing group reached its period spend cap (code 122)`,
+      `- Reason: the admin-set limit for this billing group is consumed for the period.`,
+      `- Fix: ask the billing administrator to raise the group's period cap.`
     ].join("\n");
   }
   if (code === "119" || /free usage limit for the selected model reached/i.test(message)) {
-    return [
+    return isCn ? [
       `[Qoder CN \u6A21\u578B\u9650\u514D\u989D\u5EA6\u5DF2\u6EE1] \u5F53\u524D\u6A21\u578B\u7684\u514D\u8D39\u4F53\u9A8C\u989D\u5EA6\u5DF2\u7528\u5B8C (\u9519\u8BEF\u7801 119)`,
       `- \u5237\u65B0\u65F6\u95F4\uFF1A\u5C06\u5728\u5317\u4EAC\u65F6\u95F4 00:00 \u91CD\u7F6E\uFF08\u7EA6 ${countdown}\u540E\uFF09`,
       `- \u89E3\u51B3\u5EFA\u8BAE\uFF1A\u53EF\u4F7F\u7528 /model \u5207\u6362\u81F3\u5176\u4ED6\u4ED8\u8D39\u6A21\u578B\uFF08\u5982 deepseek-v4-pro / glm-5.3\uFF09\u6D88\u8017 Credits \u989D\u5EA6\uFF0C\u6216\u6B21\u65E5\u91CD\u7F6E\u540E\u7EE7\u7EED\u4F7F\u7528\u3002`
+    ].join("\n") : [
+      `[Qoder model free tier] This model's free daily trial allowance is used up (code 119)`,
+      `- Reset: at 00:00 UTC+8 (in ${countdown})`,
+      `- Fix: switch to a paid model via /model to spend credits, or wait for the reset.`
     ].join("\n");
   }
   if (code === "113" || code === "118" || /quota exhausted/i.test(message) || /credits exhausted/i.test(message)) {
-    return [
+    const store = isCn ? QODER_CN_OFFICIAL.manageUrl : "https://qoder.com";
+    return isCn ? [
       `[Qoder CN \u989D\u5EA6\u8017\u5C3D] \u8D26\u6237 Credits \u4F59\u989D\u5DF2\u5168\u90E8\u7528\u5C3D (\u9519\u8BEF\u7801 ${code || 113})`,
       `- \u9650\u5236\u539F\u56E0\uFF1A\u5F53\u524D\u8BA2\u9605\u5957\u9910\u53CA\u8D44\u6E90\u5305\u5185\u7684\u53EF\u7528\u989D\u5EA6\u5DF2\u5168\u90E8\u6263\u51CF\u5B8C\u6BD5\u3002`,
-      `- \u89E3\u51B3\u5EFA\u8BAE\uFF1A\u8BF7\u524D\u5F80 qoder.com.cn \u8D2D\u4E70\u8D44\u6E90\u5305/\u52A0\u6CB9\u5305\uFF0C\u6216\u7B49\u5F85\u4E0B\u4E00\u8BA1\u8D39\u5468\u671F\u5237\u65B0\u3002`
+      `- \u89E3\u51B3\u5EFA\u8BAE\uFF1A\u8BF7\u524D\u5F80 ${store} \u8D2D\u4E70\u8D44\u6E90\u5305/\u52A0\u6CB9\u5305\uFF0C\u6216\u7B49\u5F85\u4E0B\u4E00\u8BA1\u8D39\u5468\u671F\u5237\u65B0\u3002`
+    ].join("\n") : [
+      `[Qoder credits exhausted] The account has no remaining credits (code ${code || 113})`,
+      `- Reason: the plan allowance and every add-on pack are consumed.`,
+      `- Fix: purchase a credit pack at ${store}, or wait for the next billing cycle.`
     ].join("\n");
   }
   if (code === "105" || /token expired/i.test(message) || /login expired/i.test(message)) {
+    if (isCn) {
+      return [
+        `[Qoder CN \u51ED\u8BC1\u5931\u6548] \u767B\u5F55\u6001\u5DF2\u8FC7\u671F\u6216 Token \u5931\u6548 (\u9519\u8BEF\u7801 105)`,
+        `- \u89E3\u51B3\u5EFA\u8BAE\uFF1A\u8BF7\u91CD\u65B0\u8FD0\u884C /login qoder-cn\uFF0C\u6216\u66F4\u65B0\u73AF\u5883\u53D8\u91CF\u4E2D\u7684\u4E2A\u4EBA\u8BBF\u95EE\u4EE4\u724C\uFF08PAT\uFF09\u3002`
+      ].join("\n");
+    }
     return [
-      `[Qoder CN \u51ED\u8BC1\u5931\u6548] \u767B\u5F55\u6001\u5DF2\u8FC7\u671F\u6216 Token \u5931\u6548 (\u9519\u8BEF\u7801 105)`,
-      `- \u89E3\u51B3\u5EFA\u8BAE\uFF1A\u8BF7\u91CD\u65B0\u8FD0\u884C /login qoder-cn\uFF0C\u6216\u66F4\u65B0\u73AF\u5883\u53D8\u91CF\u4E2D\u7684\u4E2A\u4EBA\u8BBF\u95EE\u4EE4\u724C\uFF08PAT\uFF09\u3002`
+      `[Qoder \u51ED\u8BC1\u5931\u6548 | Credential expired] The login session or token has expired (\u9519\u8BEF\u7801 105)`,
+      `- Next step: run /login qoder. You can also refresh credentials by exporting QODER_PERSONAL_ACCESS_TOKEN (PAT).`
     ].join("\n");
   }
   if (rawBody === void 0 || rawBody === null) {
@@ -1880,10 +2382,40 @@ function formatQoderStreamError(statusCode, rawBody, now = Date.now()) {
   const truncated = bodyStr.length > 500 ? `${bodyStr.slice(0, 500)}...` : bodyStr;
   return `Upstream status ${statusCode}: ${truncated}`;
 }
+function isCredentialExpiredError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return message.includes("\u9519\u8BEF\u7801 105") || message.includes("\u51ED\u8BC1\u5931\u6548") || /token expired|login expired/i.test(message);
+}
 
 // src/commands/usage.ts
 init_region();
-var ANSI = {
+function estimateRollingAddOnExpiry(addOn, latestExpiryMs, now = Date.now()) {
+  if (!addOn || !addOn.total || addOn.total <= 0 || !addOn.remaining || addOn.remaining <= 0) {
+    return null;
+  }
+  const packSize = 100;
+  const totalPacks = Math.max(1, Math.round(addOn.total / packSize));
+  if (totalPacks > 50) return null;
+  const used = Math.max(0, addOn.used ?? 0);
+  const consumedPacks = Math.min(totalPacks - 1, Math.floor(used / packSize));
+  const earliestActiveIndex = consumedPacks;
+  const daysAgoClaimed = totalPacks - 1 - earliestActiveIndex;
+  const anchorExpiryMs = latestExpiryMs && Number.isFinite(latestExpiryMs) ? latestExpiryMs : now + 30 * 864e5;
+  const earliestMs = anchorExpiryMs - daysAgoClaimed * 864e5;
+  const daysRemaining = Math.max(0, Math.round((earliestMs - now) / 864e5));
+  const earliestRemaining = Math.min(addOn.remaining, packSize - used % packSize);
+  const d = new Date(earliestMs);
+  const earliestDate = d.toISOString().slice(0, 10);
+  return {
+    earliestDate,
+    earliestMs,
+    earliestRemaining,
+    totalPacks,
+    consumedPacks,
+    daysRemaining
+  };
+}
+var ANSI2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -1896,15 +2428,15 @@ var EMPTY_CHAR = "\u2591";
 var UNKNOWN_CHAR = "?";
 var BAR_WIDTH = 20;
 var COLUMN_GAP = "  ";
-function paint(text, code) {
-  return code && text ? `${code}${text}${ANSI.reset}` : text;
+function paint2(text, code) {
+  return code && text ? `${code}${text}${ANSI2.reset}` : text;
 }
 function usageColor(percentage, danger = false) {
-  if (danger) return `${ANSI.red}${ANSI.bold}`;
+  if (danger) return `${ANSI2.red}${ANSI2.bold}`;
   if (typeof percentage !== "number" || !Number.isFinite(percentage)) return void 0;
-  if (percentage >= 85) return `${ANSI.red}${ANSI.bold}`;
-  if (percentage >= 60) return ANSI.yellow;
-  return ANSI.green;
+  if (percentage >= 85) return `${ANSI2.red}${ANSI2.bold}`;
+  if (percentage >= 60) return ANSI2.yellow;
+  return ANSI2.green;
 }
 function usageBar(percentage, options = {}) {
   const width = options.width ?? BAR_WIDTH;
@@ -1913,7 +2445,7 @@ function usageBar(percentage, options = {}) {
   const fill = known ? FILLED_CHAR.repeat(filled) : "";
   const rest = known ? EMPTY_CHAR.repeat(width - filled) : UNKNOWN_CHAR.repeat(width);
   if (!options.color) return `[${fill}${rest}]`;
-  return paint("[", ANSI.dim) + paint(fill, usageColor(percentage, options.danger)) + paint(rest, ANSI.dim) + paint("]", ANSI.dim);
+  return paint2("[", ANSI2.dim) + paint2(fill, usageColor(percentage, options.danger)) + paint2(rest, ANSI2.dim) + paint2("]", ANSI2.dim);
 }
 function formatAmount(value, unit) {
   if (typeof value !== "number" || !Number.isFinite(value)) return "?";
@@ -1950,7 +2482,7 @@ function isBucketRow(row) {
   return typeof row.used === "number" || typeof row.total === "number";
 }
 function rightCell(text, width, code) {
-  return " ".repeat(Math.max(0, width - text.length)) + paint(text, code);
+  return " ".repeat(Math.max(0, width - text.length)) + paint2(text, code);
 }
 function renderUsageRows(rows, notes, color) {
   const buckets = rows.filter(isBucketRow);
@@ -1975,7 +2507,7 @@ function renderUsageRows(rows, notes, color) {
     ].join(COLUMN_GAP);
   });
   for (const note of notes) {
-    lines.push(`${note.label.padEnd(labelWidth)}${COLUMN_GAP}${color ? paint(note.value, note.color) : note.value}`);
+    lines.push(`${note.label.padEnd(labelWidth)}${COLUMN_GAP}${color ? paint2(note.value, note.color) : note.value}`);
   }
   return lines.map((line) => line.replace(/ +$/, ""));
 }
@@ -2023,7 +2555,7 @@ function formatQoderUsage(raw, mode, now = Date.now(), options = {}) {
   const isPersonalStandard = raw?.userType === "personal_standard" || raw?.userType === "free";
   const notes = [];
   if (danger) {
-    notes.push({ label: "Status", value: "quota exceeded", color: ANSI.red });
+    notes.push({ label: "Status", value: "quota exceeded", color: ANSI2.red });
   }
   if (!showUserQuota && !showAddOnQuota && !showOrg) notes.push({ label: "Buckets", value: "none returned" });
   if (raw?.isPlanQuotaProrated) notes.push({ label: "Note", value: "plan quota is prorated" });
@@ -2034,13 +2566,48 @@ function formatQoderUsage(raw, mode, now = Date.now(), options = {}) {
   if (isPersonalStandard || !showOrg && formatResetTime(raw?.expiresAt, now) === "never") {
     notes.push({ label: "Daily reset", value: formatDailyResetCountdown(now) });
   }
+  const checkin = options.checkin;
+  if (checkin) {
+    if (checkin.claimed && checkin.expiresAt) {
+      const rel = formatResetTime(Date.parse(checkin.expiresAt), now);
+      notes.push({
+        label: "Today checkin",
+        value: `${checkin.amount} Credits claimed (expires ${rel})`,
+        color: color ? ANSI2.green : void 0
+      });
+    } else if (checkin.claimed) {
+      notes.push({
+        label: "Today checkin",
+        value: `${checkin.amount} Credits claimed (expires in ~30d)`,
+        color: color ? ANSI2.green : void 0
+      });
+    } else {
+      notes.push({
+        label: "Today checkin",
+        value: `${checkin.amount} Credits available (run /${region.providerID}.claim)`,
+        color: color ? ANSI2.yellow : void 0
+      });
+    }
+  }
+  const addOn = pickBucket(raw, "addOnQuota");
+  if (showAddOnQuota && (addOn?.remaining ?? 0) > 0 && checkin) {
+    const latestExpiryMs = checkin.expiresAt ? Date.parse(checkin.expiresAt) : void 0;
+    const estimate = estimateRollingAddOnExpiry(addOn, latestExpiryMs, now);
+    if (estimate) {
+      const earliestText = estimate.totalPacks > 1 ? `earliest active pack ~${estimate.earliestDate} \xB7 in ~${estimate.daysRemaining}d (~${formatAmount(estimate.earliestRemaining)} credits)` : `${estimate.earliestDate} (in ${estimate.daysRemaining}d)`;
+      notes.push({
+        label: "Add-on expiry",
+        value: `Rolling 30d (${earliestText})`
+      });
+    }
+  }
   notes.push({ label: "Expires", value: formatResetTime(raw?.expiresAt, now) });
   const manageUrl = raw?.addOnQuota?.detailUrl || raw?.upgradeUrl || region.manageUrl;
   if (manageUrl) notes.push({ label: "Manage", value: manageUrl });
   const title = `${region.usageTitle}${userType}`;
   return {
     title: region.usageTitle,
-    lines: [paint(title, color ? ANSI.bold : void 0), ...renderUsageRows(rows, notes, color)]
+    lines: [paint2(title, color ? ANSI2.bold : void 0), ...renderUsageRows(rows, notes, color)]
   };
 }
 async function fetchQoderQuota(accessToken, mode) {
@@ -2050,7 +2617,8 @@ async function fetchQoderQuota(accessToken, mode) {
       Authorization: `Bearer ${accessToken}`,
       Accept: "application/json",
       "User-Agent": "pi-provider-qoder-cn"
-    }
+    },
+    signal: AbortSignal.timeout(1e4)
   });
   const text = await response.text();
   let data;
@@ -2091,7 +2659,7 @@ async function resolveUsageIdentity(providerID, mode, ctx, withIdentity = true)
     } catch {
     }
   }
-  return { access, name, email };
+  return { access, name, email, userID: stored?.userID || (storedMatches ? stored?.userID : void 0) };
 }
 var FORMAT_ARGS = /* @__PURE__ */ new Set(["json", "raw", "debug"]);
 var PLAIN_ARGS = /* @__PURE__ */ new Set(["plain", "no-color", "nocolor"]);
@@ -2113,9 +2681,15 @@ async function runUsageCommand(mode, args, ctx) {
       ctx?.ui?.notify(`No ${providerID} credentials. Run /login ${providerID} first.`, "warning");
       return;
     }
-    const raw = await fetchQoderQuota(accessToken, mode);
+    const { getMachineId: getMachineId2 } = await Promise.resolve().then(() => (init_cosy(), cosy_exports));
+    const machineID = getMachineId2();
+    const deviceIdentity = wantsRaw ? null : await resolveSashMachineIdentity(mode, identity?.userID).catch(() => null);
+    const [raw, checkinInfo] = await Promise.all([
+      fetchQoderQuota(accessToken, mode),
+      wantsRaw ? Promise.resolve(null) : fetchCheckinGrantInfo(accessToken, machineID, mode, deviceIdentity).catch(() => null)
+    ]);
     const color = !wantsRaw && shouldColorize(args, { hasUI: Boolean(ctx?.ui) });
-    const output = wantsRaw ? JSON.stringify(raw, null, 2) : formatQoderUsage(raw, mode, Date.now(), { color, user: identity }).lines.join("\n");
+    const output = wantsRaw ? JSON.stringify(raw, null, 2) : formatQoderUsage(raw, mode, Date.now(), { color, user: identity, checkin: checkinInfo }).lines.join("\n");
     ctx?.ui?.notify(output, "info");
     if (!ctx?.ui) console.log(output);
   } catch (error) {
@@ -2575,6 +3149,8 @@ function transformMessagesForQoder(messages) {
 }
 
 // src/protocol/stream.ts
+var healCooldowns = /* @__PURE__ */ new Map();
+var HEAL_COOLDOWN_MS = 6e4;
 function stableHash(prefix, ...inputs) {
   const hash = crypto3.createHash("sha256");
   hash.update(prefix);
@@ -2661,6 +3237,25 @@ async function peekQueueNotice(reader, decoder) {
     return null;
   }
 }
+async function peekCredentialExpired(reader, decoder) {
+  const text = await reader.peekLine(decoder);
+  const firstLine = text.split("\n")[0]?.trim() ?? "";
+  if (!firstLine.startsWith("data:")) return false;
+  const payload = firstLine.slice(5).trim();
+  if (!payload || payload === "[DONE]") return false;
+  try {
+    const envelope = JSON.parse(payload);
+    if (envelope.isQueued === true) return false;
+    if (typeof envelope.statusCodeValue === "number" && envelope.statusCodeValue !== 200) {
+      const parsed = parseQoderErrorPayload(envelope.body);
+      const message = parsed?.message ?? (typeof envelope.body === "string" ? envelope.body : "");
+      return parsed?.code === "105" || /token expired|login expired/i.test(message);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
 function resolveRequestContext(piAi, context) {
   const {
     collapseSystemMessages,
@@ -2710,374 +3305,424 @@ function streamQoder(model, context, options) {
   (async () => {
     try {
       const providerMode = model.provider === "qoder-cn" ? "cn" : "global";
+      let reader;
+      let started = false;
       const region = getQoderRegionConfig(providerMode);
-      const accessToken = options?.apiKey;
-      if (!accessToken) {
-        throw new Error(
-          providerMode === "cn" ? "Qoder CN credentials not set. Run /login qoder-cn or set QODERCN_PERSONAL_ACCESS_TOKEN." : "Qoder credentials not set. Run /login qoder or set QODER_PERSONAL_ACCESS_TOKEN."
-        );
-      }
-      const ident = await resolveQoderIdentity(accessToken, model.provider, providerMode);
-      const userID = ident.userID || "qoder-user";
-      const name = ident.name || region.userNameFallback;
-      const email = ident.email || region.userEmailFallback;
-      const machineID = ident.machineID || getMachineId();
-      const modelConfig = getCachedModelConfig(model.id, providerMode);
-      if (!modelConfig?.key) {
-        throw new Error(`Unknown Qoder model id: ${model.id}`);
-      }
-      const qoderModel = modelConfig.key;
-      const isReasoning = !!modelConfig.is_reasoning;
-      const resolved = resolveRequestContext(PiAi, context);
-      const normalizedMessages = transformMessagesForQoder(resolved.messages);
-      const systemText = resolved.systemText;
-      let lastUserText = "";
-      for (let i = normalizedMessages.length - 1; i >= 0; i--) {
-        if (normalizedMessages[i].role === "user") {
-          const content = normalizedMessages[i].content;
-          lastUserText = typeof content === "string" ? content : Array.isArray(content) ? content.map((c) => "text" in c ? c.text : "").join("") : "";
-          break;
+      const runAttempt = async (apiKey) => {
+        const accessToken = apiKey ?? options?.apiKey;
+        if (!accessToken) {
+          throw new Error(
+            providerMode === "cn" ? "Qoder CN credentials not set. Run /login qoder-cn or set QODERCN_PERSONAL_ACCESS_TOKEN." : "Qoder credentials not set. Run /login qoder or set QODER_PERSONAL_ACCESS_TOKEN."
+          );
         }
-      }
-      const stablePart = stableHash("qoder-session", userID, qoderModel);
-      const sessionID = options?.sessionId ? `${stablePart}-${options.sessionId}` : `${stablePart}-${crypto3.randomUUID()}`;
-      let maxTokens = MAX_OUTPUT_TOKENS;
-      if (options?.maxTokens && options.maxTokens < maxTokens) {
-        maxTokens = options.maxTokens;
-      }
-      const toolsRaw = resolved.tools.length > 0 ? transformTools(resolved.tools) : void 0;
-      const recordID = stableChatRecordID(qoderModel, normalizedMessages, toolsRaw, maxTokens);
-      const requestedLevel = options?.reasoning;
-      const clamped = requestedLevel ? clampThinkingLevel(model, requestedLevel) : void 0;
-      const reasoningLevel = clamped === "off" ? void 0 : clamped;
-      const parameters = { max_tokens: maxTokens };
-      if (reasoningLevel) {
-        parameters.enable_thinking = true;
-        const mapped = model.thinkingLevelMap?.[reasoningLevel];
-        const effort = mapped && mapped !== "enabled" && mapped !== "disabled" ? mapped : reasoningLevel;
-        if (modelConfig?.thinking_config?.enabled?.efforts && typeof effort === "string") {
-          parameters.reasoning_effort = effort;
+        const ident = await resolveQoderIdentity(accessToken, model.provider, providerMode);
+        const userID = ident.userID || "qoder-user";
+        const name = ident.name || region.userNameFallback;
+        const email = ident.email || region.userEmailFallback;
+        const machineID = ident.machineID || getMachineId();
+        const modelConfig = getCachedModelConfig(model.id, providerMode);
+        if (!modelConfig?.key) {
+          throw new Error(`Unknown Qoder model id: ${model.id}`);
         }
-      } else {
-        parameters.enable_thinking = false;
-      }
-      const reqBody = {
-        request_id: crypto3.randomUUID(),
-        request_set_id: recordID,
-        chat_record_id: recordID,
-        session_id: sessionID,
-        stream: true,
-        chat_task: "FREE_INPUT",
-        is_reply: true,
-        is_retry: false,
-        source: 1,
-        version: "3",
-        session_type: "qodercli",
-        agent_id: "agent_common",
-        task_id: "common",
-        code_language: "",
-        chat_prompt: "",
-        image_urls: null,
-        aliyun_user_type: "",
-        // Qoder's server ignores the top-level `system` field (verified: the
-        // model never sees it). Inject the system prompt as a leading
-        // role:system message instead, which the server does honor.
-        system: "",
-        messages: systemText ? [{ role: "system", content: systemText }, ...normalizedMessages] : normalizedMessages,
-        tools: toolsRaw || [],
-        parameters,
-        chat_context: {
-          chatPrompt: "",
-          imageUrls: null,
-          extra: {
-            context: [],
-            modelConfig: {
-              key: qoderModel,
-              is_reasoning: isReasoning
-            },
-            originalContent: lastUserText
-          },
-          features: [],
-          text: lastUserText
-        },
-        model_config: modelConfig,
-        business: {
-          product: "cli",
-          version: "1.0.0",
-          type: "agent",
-          stage: "start",
-          id: crypto3.randomUUID(),
-          name: lastUserText.substring(0, 30),
-          begin_at: Date.now()
+        const qoderModel = modelConfig.key;
+        const isReasoning = !!modelConfig.is_reasoning;
+        const resolved = resolveRequestContext(PiAi, context);
+        const normalizedMessages = transformMessagesForQoder(resolved.messages);
+        const systemText = resolved.systemText;
+        let lastUserText = "";
+        for (let i = normalizedMessages.length - 1; i >= 0; i--) {
+          if (normalizedMessages[i].role === "user") {
+            const content = normalizedMessages[i].content;
+            lastUserText = typeof content === "string" ? content : Array.isArray(content) ? content.map((c) => "text" in c ? c.text : "").join("") : "";
+            break;
+          }
         }
-      };
-      const bodyBytes = Buffer.from(JSON.stringify(reqBody));
-      const encodedBytes = qoderEncodeBody(bodyBytes);
-      const chatURL = getQoderChatURL(providerMode);
-      const headers = buildAuthHeaders(encodedBytes, chatURL, {
-        userID,
-        authToken: accessToken,
-        name,
-        email,
-        machineID
-      });
-      const modelSource = modelConfig.source || "system";
-      let queuedAttempt = 0;
-      let reader;
-      let decoder;
-      let buffer = "";
-      let bufferStart = 0;
-      for (; ; ) {
-        const response = await fetch(chatURL, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Accept: "text/event-stream",
-            "Cache-Control": "no-cache",
-            "Accept-Encoding": "identity",
-            "X-Model-Key": qoderModel,
-            "X-Model-Source": modelSource,
-            ...headers
+        const stablePart = stableHash("qoder-session", userID, qoderModel);
+        const sessionID = options?.sessionId ? `${stablePart}-${options.sessionId}` : `${stablePart}-${crypto3.randomUUID()}`;
+        let maxTokens = MAX_OUTPUT_TOKENS;
+        if (options?.maxTokens && options.maxTokens < maxTokens) {
+          maxTokens = options.maxTokens;
+        }
+        const toolsRaw = resolved.tools.length > 0 ? transformTools(resolved.tools) : void 0;
+        const recordID = stableChatRecordID(qoderModel, normalizedMessages, toolsRaw, maxTokens);
+        const requestedLevel = options?.reasoning;
+        const clamped = requestedLevel ? clampThinkingLevel(model, requestedLevel) : void 0;
+        const reasoningLevel = clamped === "off" ? void 0 : clamped;
+        const parameters = { max_tokens: maxTokens };
+        if (reasoningLevel) {
+          parameters.enable_thinking = true;
+          const mapped = model.thinkingLevelMap?.[reasoningLevel];
+          const effort = mapped && mapped !== "enabled" && mapped !== "disabled" ? mapped : reasoningLevel;
+          if (modelConfig?.thinking_config?.enabled?.efforts && typeof effort === "string") {
+            parameters.reasoning_effort = effort;
+          }
+        } else {
+          parameters.enable_thinking = false;
+        }
+        const reqBody = {
+          request_id: crypto3.randomUUID(),
+          request_set_id: recordID,
+          chat_record_id: recordID,
+          session_id: sessionID,
+          stream: true,
+          chat_task: "FREE_INPUT",
+          is_reply: true,
+          is_retry: false,
+          source: 1,
+          version: "3",
+          session_type: "qodercli",
+          agent_id: "agent_common",
+          task_id: "common",
+          code_language: "",
+          chat_prompt: "",
+          image_urls: null,
+          aliyun_user_type: "",
+          // Qoder's server ignores the top-level `system` field (verified: the
+          // model never sees it). Inject the system prompt as a leading
+          // role:system message instead, which the server does honor.
+          system: "",
+          messages: systemText ? [{ role: "system", content: systemText }, ...normalizedMessages] : normalizedMessages,
+          tools: toolsRaw || [],
+          parameters,
+          chat_context: {
+            chatPrompt: "",
+            imageUrls: null,
+            extra: {
+              context: [],
+              modelConfig: {
+                key: qoderModel,
+                is_reasoning: isReasoning
+              },
+              originalContent: lastUserText
+            },
+            features: [],
+            text: lastUserText
           },
-          body: encodedBytes,
-          signal: options?.signal
+          model_config: modelConfig,
+          business: {
+            product: "cli",
+            version: "1.0.0",
+            type: "agent",
+            stage: "start",
+            id: crypto3.randomUUID(),
+            name: lastUserText.substring(0, 30),
+            begin_at: Date.now()
+          }
+        };
+        const bodyBytes = Buffer.from(JSON.stringify(reqBody));
+        const encodedBytes = qoderEncodeBody(bodyBytes);
+        const chatURL = getQoderChatURL(providerMode);
+        const headers = buildAuthHeaders(encodedBytes, chatURL, {
+          userID,
+          authToken: accessToken,
+          name,
+          email,
+          machineID
         });
-        if (!response.ok) {
-          const errText = await response.text();
-          throw new Error(formatQoderStreamError(response.status, errText));
-        }
-        const body = response.body;
-        if (!body) throw new Error("No response body");
-        reader = new PeekableReader(body.getReader());
-        decoder = new TextDecoder();
-        buffer = "";
-        bufferStart = 0;
-        const queue = await peekQueueNotice(reader, decoder);
-        if (queue) {
-          await reader.cancel().catch(() => {
+        const modelSource = modelConfig.source || "system";
+        let queuedAttempt = 0;
+        await reader?.cancel().catch(() => {
+        });
+        reader = void 0;
+        let decoder;
+        let buffer = "";
+        let bufferStart = 0;
+        for (; ; ) {
+          const response = await fetch(chatURL, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Accept: "text/event-stream",
+              "Cache-Control": "no-cache",
+              "Accept-Encoding": "identity",
+              "X-Model-Key": qoderModel,
+              "X-Model-Source": modelSource,
+              ...headers
+            },
+            body: encodedBytes,
+            signal: options?.signal
           });
-          if (queuedAttempt >= MAX_QUEUE_RETRIES) {
+          if (!response.ok) {
+            const errText = await response.text();
+            throw new Error(formatQoderStreamError(response.status, errText, Date.now(), providerMode));
+          }
+          const body = response.body;
+          if (!body) throw new Error("No response body");
+          reader = new PeekableReader(body.getReader());
+          decoder = new TextDecoder();
+          buffer = "";
+          bufferStart = 0;
+          const queue = await peekQueueNotice(reader, decoder);
+          if (queue) {
+            await reader.cancel().catch(() => {
+            });
+            if (queuedAttempt >= MAX_QUEUE_RETRIES) {
+              throw new Error(
+                `Qoder is at capacity: the request stayed queued after ${queuedAttempt + 1} attempts (~${queue.waitTimeSeconds}s wait reported). Try again shortly.`
+              );
+            }
+            queuedAttempt++;
+            await sleep(queue.retryAfterMs, options?.signal);
+            continue;
+          }
+          if (await peekCredentialExpired(reader, decoder)) {
+            await reader.cancel().catch(() => {
+            });
             throw new Error(
-              `Qoder is at capacity: the request stayed queued after ${queuedAttempt + 1} attempts (~${queue.waitTimeSeconds}s wait reported). Try again shortly.`
+              formatQoderStreamError(403, '{"code":"105","message":"Login expired"}', Date.now(), providerMode)
             );
           }
-          queuedAttempt++;
-          await sleep(queue.retryAfterMs, options?.signal);
-          continue;
+          break;
         }
-        break;
-      }
-      if (!reader || !decoder) throw new Error("No response body");
-      let contentBlockIndex = -1;
-      let thinkingBlockIndex = -1;
-      let rawReasoningTail = "";
-      const toolCallsState = [];
-      const thinkingEnabled = options?.reasoning !== false && options?.reasoning !== "off";
-      const thinkingParser = thinkingEnabled ? new ThinkingTagParser(output, stream) : null;
-      stream.push({ type: "start", partial: output });
-      let sawDone = false;
-      while (!sawDone) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        if (bufferStart > 0) {
-          buffer = buffer.substring(bufferStart);
-          bufferStart = 0;
+        if (!reader || !decoder) throw new Error("No response body");
+        let contentBlockIndex = -1;
+        let thinkingBlockIndex = -1;
+        let rawReasoningTail = "";
+        const toolCallsState = [];
+        const thinkingEnabled = options?.reasoning !== false && options?.reasoning !== "off";
+        const thinkingParser = thinkingEnabled ? new ThinkingTagParser(output, stream) : null;
+        if (!started) {
+          started = true;
+        } else {
+          output.content.length = 0;
         }
-        buffer += decoder.decode(value, { stream: true });
-        while (true) {
-          const lineEnd = buffer.indexOf("\n", bufferStart);
-          if (lineEnd === -1) break;
-          const line = buffer.substring(bufferStart, lineEnd).trim();
-          bufferStart = lineEnd + 1;
-          if (!line.startsWith("data:")) continue;
-          const dataStr = line.substring(5).trim();
-          if (dataStr === "[DONE]") {
-            sawDone = true;
-            break;
+        stream.push({ type: "start", partial: output });
+        let sawDone = false;
+        while (!sawDone) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (bufferStart > 0) {
+            buffer = buffer.substring(bufferStart);
+            bufferStart = 0;
           }
-          try {
-            const envelope = JSON.parse(dataStr);
-            if (envelope.statusCodeValue && envelope.statusCodeValue !== 200) {
-              throw new Error(formatQoderStreamError(envelope.statusCodeValue, envelope.body));
-            }
-            const innerStr = envelope.body;
-            if (innerStr === "[DONE]") {
+          buffer += decoder.decode(value, { stream: true });
+          while (true) {
+            const lineEnd = buffer.indexOf("\n", bufferStart);
+            if (lineEnd === -1) break;
+            const line = buffer.substring(bufferStart, lineEnd).trim();
+            bufferStart = lineEnd + 1;
+            if (!line.startsWith("data:")) continue;
+            const dataStr = line.substring(5).trim();
+            if (dataStr === "[DONE]") {
               sawDone = true;
               break;
             }
-            if (!innerStr) continue;
-            const inner = JSON.parse(innerStr);
-            if (inner.id) output.responseId = inner.id;
-            if (inner.model) output.responseModel = inner.model;
-            if (inner.usage) {
-              const u = inner.usage;
-              const promptTokens = u.prompt_tokens ?? 0;
-              const cacheReadTokens = u.prompt_tokens_details?.cached_tokens ?? 0;
-              const cacheWriteTokens = u.prompt_tokens_details?.cache_write_tokens ?? 0;
-              output.usage.input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
-              output.usage.output = u.completion_tokens ?? 0;
-              output.usage.totalTokens = u.total_tokens ?? 0;
-              output.usage.cacheRead = cacheReadTokens;
-              output.usage.cacheWrite = cacheWriteTokens;
-            }
-            if (inner.choices && inner.choices.length > 0) {
-              const choice = inner.choices[0];
-              const delta = choice.delta;
-              if (delta) {
-                if (delta.reasoning_content) {
-                  rawReasoningTail = (rawReasoningTail + delta.reasoning_content).slice(-512);
-                  const reasoningChunk = stripDsmlResidue(stripThinkingTags(delta.reasoning_content));
-                  if (reasoningChunk) {
-                    if (thinkingBlockIndex === -1) {
-                      thinkingBlockIndex = output.content.length;
-                      output.content.push({ type: "thinking", thinking: "" });
-                      stream.push({ type: "thinking_start", contentIndex: thinkingBlockIndex, partial: output });
-                    }
-                    const block = output.content[thinkingBlockIndex];
-                    block.thinking += reasoningChunk;
-                    stream.push({
-                      type: "thinking_delta",
-                      contentIndex: thinkingBlockIndex,
-                      delta: reasoningChunk,
-                      partial: output
-                    });
-                  }
-                }
-                if (delta.content) {
-                  if (thinkingBlockIndex !== -1) {
-                    const block = output.content[thinkingBlockIndex];
-                    stream.push({
-                      type: "thinking_end",
-                      contentIndex: thinkingBlockIndex,
-                      content: block.thinking,
-                      partial: output
-                    });
-                    thinkingBlockIndex = -1;
-                  }
-                  if (thinkingParser) {
-                    thinkingParser.processChunk(delta.content);
-                  } else {
-                    if (contentBlockIndex === -1) {
-                      contentBlockIndex = output.content.length;
-                      output.content.push({ type: "text", text: "" });
-                      stream.push({ type: "text_start", contentIndex: contentBlockIndex, partial: output });
+            try {
+              const envelope = JSON.parse(dataStr);
+              if (envelope.statusCodeValue && envelope.statusCodeValue !== 200) {
+                throw new Error(
+                  formatQoderStreamError(envelope.statusCodeValue, envelope.body, Date.now(), providerMode)
+                );
+              }
+              const innerStr = envelope.body;
+              if (innerStr === "[DONE]") {
+                sawDone = true;
+                break;
+              }
+              if (!innerStr) continue;
+              const inner = JSON.parse(innerStr);
+              if (inner.id) output.responseId = inner.id;
+              if (inner.model) output.responseModel = inner.model;
+              if (inner.usage) {
+                const u = inner.usage;
+                const promptTokens = u.prompt_tokens ?? 0;
+                const cacheReadTokens = u.prompt_tokens_details?.cached_tokens ?? 0;
+                const cacheWriteTokens = u.prompt_tokens_details?.cache_write_tokens ?? 0;
+                output.usage.input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
+                output.usage.output = u.completion_tokens ?? 0;
+                output.usage.totalTokens = u.total_tokens ?? 0;
+                output.usage.cacheRead = cacheReadTokens;
+                output.usage.cacheWrite = cacheWriteTokens;
+              }
+              if (inner.choices && inner.choices.length > 0) {
+                const choice = inner.choices[0];
+                const delta = choice.delta;
+                if (delta) {
+                  if (delta.reasoning_content) {
+                    rawReasoningTail = (rawReasoningTail + delta.reasoning_content).slice(-512);
+                    const reasoningChunk = stripDsmlResidue(stripThinkingTags(delta.reasoning_content));
+                    if (reasoningChunk) {
+                      if (thinkingBlockIndex === -1) {
+                        thinkingBlockIndex = output.content.length;
+                        output.content.push({ type: "thinking", thinking: "" });
+                        stream.push({ type: "thinking_start", contentIndex: thinkingBlockIndex, partial: output });
+                      }
+                      const block = output.content[thinkingBlockIndex];
+                      block.thinking += reasoningChunk;
+                      stream.push({
+                        type: "thinking_delta",
+                        contentIndex: thinkingBlockIndex,
+                        delta: reasoningChunk,
+                        partial: output
+                      });
                     }
-                    const block = output.content[contentBlockIndex];
-                    block.text += delta.content;
-                    stream.push({
-                      type: "text_delta",
-                      contentIndex: contentBlockIndex,
-                      delta: delta.content,
-                      partial: output
-                    });
                   }
-                }
-                if (delta.tool_calls && Array.isArray(delta.tool_calls)) {
-                  for (const tc of delta.tool_calls) {
-                    const idx = tc.index ?? 0;
-                    if (!toolCallsState[idx]) {
-                      toolCallsState[idx] = { arguments: "", id: "", name: "", contentIndex: 0 };
-                    }
-                    const state = toolCallsState[idx];
-                    if (tc.id) state.id = tc.id;
-                    if (tc.function?.name) state.name = tc.function.name;
-                    if (state.emittedStart === void 0 && (state.id || state.name)) {
-                      state.emittedStart = true;
-                      state.contentIndex = output.content.length;
-                      output.content.push({
-                        type: "toolCall",
-                        id: state.id,
-                        name: state.name,
-                        arguments: {}
+                  if (delta.content) {
+                    if (thinkingBlockIndex !== -1) {
+                      const block = output.content[thinkingBlockIndex];
+                      stream.push({
+                        type: "thinking_end",
+                        contentIndex: thinkingBlockIndex,
+                        content: block.thinking,
+                        partial: output
                       });
-                      stream.push({ type: "toolcall_start", contentIndex: state.contentIndex, partial: output });
+                      thinkingBlockIndex = -1;
                     }
-                    if (state.emittedStart) {
-                      const block = output.content[state.contentIndex];
-                      block.id = state.id;
-                      block.name = state.name;
-                    }
-                    if (tc.function?.arguments) {
-                      const argDelta = tc.function.arguments;
-                      state.arguments += argDelta;
+                    if (thinkingParser) {
+                      thinkingParser.processChunk(delta.content);
+                    } else {
+                      if (contentBlockIndex === -1) {
+                        contentBlockIndex = output.content.length;
+                        output.content.push({ type: "text", text: "" });
+                        stream.push({ type: "text_start", contentIndex: contentBlockIndex, partial: output });
+                      }
+                      const block = output.content[contentBlockIndex];
+                      block.text += delta.content;
                       stream.push({
-                        type: "toolcall_delta",
-                        contentIndex: state.contentIndex,
-                        delta: argDelta,
+                        type: "text_delta",
+                        contentIndex: contentBlockIndex,
+                        delta: delta.content,
                         partial: output
                       });
                     }
                   }
+                  if (delta.tool_calls && Array.isArray(delta.tool_calls)) {
+                    for (const tc of delta.tool_calls) {
+                      const idx = tc.index ?? 0;
+                      if (!toolCallsState[idx]) {
+                        toolCallsState[idx] = { arguments: "", id: "", name: "", contentIndex: 0 };
+                      }
+                      const state = toolCallsState[idx];
+                      if (tc.id) state.id = tc.id;
+                      if (tc.function?.name) state.name = tc.function.name;
+                      if (state.emittedStart === void 0 && (state.id || state.name)) {
+                        state.emittedStart = true;
+                        state.contentIndex = output.content.length;
+                        output.content.push({
+                          type: "toolCall",
+                          id: state.id,
+                          name: state.name,
+                          arguments: {}
+                        });
+                        stream.push({ type: "toolcall_start", contentIndex: state.contentIndex, partial: output });
+                      }
+                      if (state.emittedStart) {
+                        const block = output.content[state.contentIndex];
+                        block.id = state.id;
+                        block.name = state.name;
+                      }
+                      if (tc.function?.arguments) {
+                        const argDelta = tc.function.arguments;
+                        state.arguments += argDelta;
+                        stream.push({
+                          type: "toolcall_delta",
+                          contentIndex: state.contentIndex,
+                          delta: argDelta,
+                          partial: output
+                        });
+                      }
+                    }
+                  }
+                }
+                if (choice.finish_reason) {
+                  output.stopReason = choice.finish_reason;
                 }
               }
-              if (choice.finish_reason) {
-                output.stopReason = choice.finish_reason;
-              }
-            }
-          } catch (e) {
-            if (e instanceof SyntaxError) {
-              if (process.env.QODER_DEBUG) {
-                console.error("[pi-provider-qoder] skipping malformed SSE line:", dataStr.slice(0, 200));
+            } catch (e) {
+              if (e instanceof SyntaxError) {
+                if (process.env.QODER_DEBUG) {
+                  console.error("[pi-provider-qoder] skipping malformed SSE line:", dataStr.slice(0, 200));
+                }
+                continue;
               }
-              continue;
+              throw e;
             }
-            throw e;
           }
         }
-      }
-      await reader.cancel().catch(() => {
-      });
-      if (thinkingParser) {
-        thinkingParser.finalize();
-      }
-      if (thinkingBlockIndex !== -1) {
-        const block = output.content[thinkingBlockIndex];
-        stream.push({
-          type: "thinking_end",
-          contentIndex: thinkingBlockIndex,
-          content: block.thinking,
-          partial: output
+        await reader.cancel().catch(() => {
         });
-      }
-      for (const state of toolCallsState) {
-        if (state?.emittedStart && !state.emittedEnd) {
-          state.emittedEnd = true;
-          let args = {};
-          try {
-            args = JSON.parse(state.arguments || "{}");
-          } catch {
-          }
-          const block = output.content[state.contentIndex];
-          block.arguments = args;
+        if (thinkingParser) {
+          thinkingParser.finalize();
+        }
+        if (thinkingBlockIndex !== -1) {
+          const block = output.content[thinkingBlockIndex];
           stream.push({
-            type: "toolcall_end",
-            contentIndex: state.contentIndex,
-            toolCall: {
-              type: "toolCall",
-              id: state.id,
-              name: state.name,
-              arguments: args
-            },
+            type: "thinking_end",
+            contentIndex: thinkingBlockIndex,
+            content: block.thinking,
             partial: output
           });
         }
-      }
-      if (toolCallsState.some((state) => state?.emittedStart)) {
-        output.stopReason = "toolUse";
-      }
-      if (isDegenerateDsmlTurn(output, rawReasoningTail)) {
-        output.stopReason = "error";
-        output.errorMessage = "Qoder server error: degenerate model output (unparseable DSML tool-call markup, no tool call executed)";
-        stream.push({ type: "error", reason: "error", error: output });
+        for (const state of toolCallsState) {
+          if (state?.emittedStart && !state.emittedEnd) {
+            state.emittedEnd = true;
+            let args = {};
+            try {
+              args = JSON.parse(state.arguments || "{}");
+            } catch {
+            }
+            const block = output.content[state.contentIndex];
+            block.arguments = args;
+            stream.push({
+              type: "toolcall_end",
+              contentIndex: state.contentIndex,
+              toolCall: {
+                type: "toolCall",
+                id: state.id,
+                name: state.name,
+                arguments: args
+              },
+              partial: output
+            });
+          }
+        }
+        if (toolCallsState.some((state) => state?.emittedStart)) {
+          output.stopReason = "toolUse";
+        }
+        if (isDegenerateDsmlTurn(output, rawReasoningTail)) {
+          output.stopReason = "error";
+          output.errorMessage = "Qoder server error: degenerate model output (unparseable DSML tool-call markup, no tool call executed)";
+          stream.push({ type: "error", reason: "error", error: output });
+          stream.end();
+          return;
+        }
+        stream.push({
+          type: "done",
+          reason: output.stopReason,
+          message: output
+        });
         stream.end();
-        return;
+      };
+      try {
+        await runAttempt(void 0);
+      } catch (error) {
+        if (!["qoder", "qoder-cn"].includes(model.provider) || !isCredentialExpiredError(error)) {
+          throw error;
+        }
+        const stored = getCachedCredentials("", model.provider);
+        if (!stored) throw error;
+        const attemptedAccess = options?.apiKey;
+        if (stored.access && attemptedAccess && stored.access !== attemptedAccess) {
+          await runAttempt(stored.access);
+          return;
+        }
+        const lastHeal = healCooldowns.get(model.provider) ?? 0;
+        if (Date.now() - lastHeal < HEAL_COOLDOWN_MS) throw error;
+        healCooldowns.set(model.provider, Date.now());
+        let healed;
+        try {
+          healed = await refreshQoderTokenForMode(stored, providerMode, options?.signal);
+        } catch (healError) {
+          if (healError === error) throw error;
+          healCooldowns.delete(model.provider);
+          throw healError;
+        }
+        saveCredentialsToAuthFile(model.provider, healed);
+        await runAttempt(healed.access);
+      } finally {
+        await reader?.cancel().catch(() => {
+        });
       }
-      stream.push({
-        type: "done",
-        reason: output.stopReason,
-        message: output
-      });
-      stream.end();
     } catch (e) {
       output.stopReason = options?.signal?.aborted ? "aborted" : "error";
       output.errorMessage = e instanceof Error ? e.message : String(e);
@@ -3120,7 +3765,7 @@ function createQoderOAuth(mode) {
   return {
     name: region.loginName,
     login: (callbacks) => loginQoderForMode(callbacks, mode),
-    refreshToken: (credentials) => refreshQoderTokenForMode(credentials, mode),
+    refreshToken: (credentials, signal) => refreshQoderTokenForMode(credentials, mode, signal),
     getApiKey: (cred) => cred.access,
     // NOTE: no `modifyModels` hook on purpose. OMP (Bun) does a whole-catalog
     // structuredClone before invoking it, and its bundled catalog contains a
@@ -3190,11 +3835,29 @@ async function index_default(pi) {
 }
 function registerCommands(pi) {
   pi.registerCommand("qoder-cn.usage", {
-    description: "Show qoder-cn quota: plan + add-on credits, used/limit and reset (append 'json' for the raw payload)",
+    description: "Show Qoder CN quota: plan + add-on credits, used/limit and reset (append 'json' for the raw payload)",
     handler: async (args, ctx) => {
       await runUsageCommand("cn", args, ctx);
     }
   });
+  pi.registerCommand("qoder-cn.claim", {
+    description: "Claim Qoder CN daily 100 free Credits reward (resets daily at 10:00 UTC+8)",
+    handler: async (args, ctx) => {
+      await runClaimCommand("cn", args, ctx);
+    }
+  });
+  pi.registerCommand("qoder.usage", {
+    description: "Show Qoder Global quota: plan + add-on credits and check-in status (append 'json' for raw payload)",
+    handler: async (args, ctx) => {
+      await runUsageCommand("global", args, ctx);
+    }
+  });
+  pi.registerCommand("qoder.claim", {
+    description: "Claim Qoder Global daily 100 free Credits reward (resets daily at 10:00 UTC+8)",
+    handler: async (args, ctx) => {
+      await runClaimCommand("global", args, ctx);
+    }
+  });
 }
 export {
   index_default as default