dsh-multi-router 0.5.1 → 0.5.3

package/lib/{chunk-U2YTBWLW.js → chunk-JYVJJ7OX.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-DNQPZMPF.js";
 import {
   RouteError
-} from "./chunk-XV7O2LRF.js";
+} from "./chunk-XA3V2DGT.js";
 import {
   REASONING_EFFORTS
-} from "./chunk-GAQ77CH4.js";
+} from "./chunk-U7J4ABAM.js";
 
 // src/shim.mjs
 import { createServer } from "node:http";
@@ -113,4 +113,4 @@ function createShim(router, { modelPrefix = "" } = {}) {
 export {
   createShim
 };
-//# sourceMappingURL=chunk-U2YTBWLW.js.map
+//# sourceMappingURL=chunk-JYVJJ7OX.js.map

package/lib/{chunk-YUP77Q3A.js → chunk-RPW6DI6O.js}

@@ -12,7 +12,11 @@ import {
 import {
   RouteError,
   abortable
-} from "./chunk-XV7O2LRF.js";
+} from "./chunk-XA3V2DGT.js";
+import {
+  beijingDay,
+  writePrivateJson
+} from "./chunk-U7J4ABAM.js";
 import {
   WorkBuddyUpstreamClient,
   modelWithCurrentPromotion,
@@ -20,7 +24,8 @@ import {
 } from "./chunk-TEZ2FMEO.js";
 
 // src/clients.mjs
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
+import { setTimeout as delay2 } from "node:timers/promises";
 
 // upstream/trae/src/usage.ts
 function asNumber(value) {
@@ -2425,26 +2430,26 @@ async function validateAndTranslateMessages(messages, systemPrompt, attachments,
 
 // upstream/qoder/src/qoder/transport/wire/serialize.ts
 function stableHash(prefix, ...inputs) {
-  const hash = crypto3.createHash("sha256");
-  hash.update(prefix);
+  const hash2 = crypto3.createHash("sha256");
+  hash2.update(prefix);
   for (const input of inputs) {
-    hash.update("\0");
-    hash.update(input);
+    hash2.update("\0");
+    hash2.update(input);
   }
-  return hash.digest("hex").slice(0, 16);
+  return hash2.digest("hex").slice(0, 16);
 }
 function stableChatRecordId(model, messages, tools, maxTokens) {
-  const hash = crypto3.createHash("sha256");
-  hash.update("qoder-record");
-  hash.update("\0");
-  hash.update(model);
-  hash.update("\0");
-  hash.update(JSON.stringify(messages));
-  hash.update("\0");
-  hash.update(JSON.stringify(tools));
-  hash.update("\0");
-  hash.update(`mt=${maxTokens}`);
-  return hash.digest("hex").slice(0, 16);
+  const hash2 = crypto3.createHash("sha256");
+  hash2.update("qoder-record");
+  hash2.update("\0");
+  hash2.update(model);
+  hash2.update("\0");
+  hash2.update(JSON.stringify(messages));
+  hash2.update("\0");
+  hash2.update(JSON.stringify(tools));
+  hash2.update("\0");
+  hash2.update(`mt=${maxTokens}`);
+  return hash2.digest("hex").slice(0, 16);
 }
 function validateQoderRequestShape(options, model) {
   if (options.reasoningEffort !== void 0) {
@@ -2691,20 +2696,20 @@ var QoderImageUploader = class {
    * are included because a center object is never shared across either.
    */
   cacheKey(image, credentials) {
-    const hash = crypto4.createHash("sha256");
-    hash.update(getQoderImageUploadUrl(this.region));
-    hash.update("\0");
-    hash.update(credentials.userID);
-    hash.update("\0");
-    hash.update(image.mediaType);
-    hash.update("\0");
+    const hash2 = crypto4.createHash("sha256");
+    hash2.update(getQoderImageUploadUrl(this.region));
+    hash2.update("\0");
+    hash2.update(credentials.userID);
+    hash2.update("\0");
+    hash2.update(image.mediaType);
+    hash2.update("\0");
     const variantId = typeof image.variantId === "string" ? image.variantId : "";
     if (variantId.length > 0) {
-      hash.update(variantId);
+      hash2.update(variantId);
     } else {
-      hash.update(crypto4.createHash("sha256").update(Buffer.from(image.data)).digest("hex"));
+      hash2.update(crypto4.createHash("sha256").update(Buffer.from(image.data)).digest("hex"));
     }
-    return hash.digest("hex");
+    return hash2.digest("hex");
   }
   remember(key, url) {
     this.cache.delete(key);
@@ -4787,6 +4792,224 @@ function modelInfoOf(model) {
 var DEFAULT_MAX_TOKENS = 32768;
 var DEFAULT_CONTEXT_WINDOW = 18e4;
 
+// src/checkins.mjs
+import { createHash as createHash2 } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { setTimeout as delay } from "node:timers/promises";
+import { withFileLock } from "@deepseek-ai/dsh-atomic-write";
+var supportsCheckin = (provider) => ["workbuddy", "trae", "qoder", "qoder-global"].includes(provider);
+var hash = (value) => createHash2("sha256").update(value).digest("hex");
+var nextDay = (now) => Date.parse(`${beijingDay(now)}T00:00:00+08:00`) + 864e5;
+var evening = (now) => Date.parse(`${beijingDay(now)}T20:05:00+08:00`);
+function checkinFailure(error, submitted = false) {
+  const status = error?.status ?? error?.failure?.status ?? Number(/\bhttp\s+(401|403|429)\b/i.exec(error?.message || "")?.[1]);
+  if (status === 401) return { status: "auth-invalid" };
+  if ([403, 429].includes(status)) return { status: "paused" };
+  if (/no valid refresh token is available|no refresh token is stored/.test(error?.message || "")) return { status: "auth-invalid" };
+  return { status: submitted ? "uncertain" : "retryable" };
+}
+var canRetry = (record2, now) => ["retryable", "before-window"].includes(record2.status) && record2.retryAt <= now && (record2.attempts || 1) < 2;
+var checkinMessages = {
+  claimed: "\u7B7E\u5230\u6210\u529F",
+  "already-claimed": "\u4ECA\u65E5\u5DF2\u9886\u53D6",
+  "device-used": "\u6B64\u8BBE\u5907\u4ECA\u65E5\u5DF2\u53C2\u4E0E\u7B7E\u5230\uFF0C\u4E0D\u518D\u5207\u6362\u5176\u4ED6\u8D26\u53F7\u9886\u53D6",
+  "no-campaign": "\u5E73\u53F0\u672A\u5F00\u653E\u53EF\u9886\u53D6\u6D3B\u52A8",
+  "before-window": "\u7B7E\u5230\u7A97\u53E3\u5C1A\u672A\u5F00\u542F",
+  paused: "\u5E73\u53F0\u9650\u5236\u6216\u9700\u8981\u9A8C\u8BC1\uFF0C\u5DF2\u6682\u505C\u6B64\u5E73\u53F0\u7B7E\u5230\uFF0C\u8BF7\u5728\u5B98\u65B9\u5BA2\u6237\u7AEF\u5904\u7406",
+  uncertain: "\u8BF7\u6C42\u7ED3\u679C\u5F85\u786E\u8BA4\uFF0C\u4ECA\u65E5\u4E0D\u518D\u81EA\u52A8\u63D0\u4EA4\uFF0C\u8BF7\u5728\u5B98\u65B9\u5BA2\u6237\u7AEF\u6838\u5BF9",
+  "auth-invalid": "\u4EE4\u724C\u5931\u6548\uFF0C\u8BF7\u5230\u8D26\u53F7\u4E0E\u767B\u5F55\u66F4\u65B0\u51ED\u8BC1",
+  retryable: "\u67E5\u8BE2\u5931\u8D25\uFF0C\u9886\u53D6\u5C1A\u672A\u63D0\u4EA4",
+  error: "\u7B7E\u5230\u672A\u5B8C\u6210\uFF0C\u4ECA\u65E5\u4E0D\u518D\u91CD\u590D\u5C1D\u8BD5\uFF0C\u8BF7\u5728\u5B98\u65B9\u5BA2\u6237\u7AEF\u67E5\u770B",
+  unsupported: "\u6682\u672A\u63A5\u5165\u53EF\u6838\u9A8C\u7684\u7B7E\u5230\u63A5\u53E3\uFF0C\u8BF7\u4F7F\u7528\u5B98\u65B9\u5BA2\u6237\u7AEF"
+};
+var Checkins = class {
+  constructor(file, manager, { now = Date.now, spacingMs = 1e4 } = {}) {
+    this.file = file;
+    this.manager = manager;
+    this.now = now;
+    this.spacingMs = spacingMs;
+    this.data = { records: {}, devices: {}, pauses: {} };
+    this.abort = new AbortController();
+  }
+  async read() {
+    try {
+      const raw = JSON.parse(await readFile(this.file, "utf8"));
+      const object = (value) => value && typeof value === "object" && !Array.isArray(value);
+      if (!object(raw) || !["records", "devices", "pauses"].every((k) => object(raw[k])) || Object.values(raw.records).some((r) => !object(r) || !Array.isArray(r.ids) || !Number.isFinite(r.at) || typeof r.day !== "string")) throw Error("Invalid check-in journal");
+      this.data = raw;
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  }
+  async load() {
+    try {
+      await this.read();
+    } catch {
+      this.failed = true;
+    }
+  }
+  state() {
+    return {
+      running: !!this.flight,
+      current: this.current,
+      error: this.failed ? "\u7B7E\u5230\u8BB0\u5F55\u65E0\u6CD5\u8BFB\u53D6\uFF0C\u5DF2\u505C\u6B62\u7B7E\u5230\uFF1B\u8BF7\u4FEE\u590D\u8BB0\u5F55\u6587\u4EF6\u540E\u91CD\u542F\u63D2\u4EF6\u3002" : void 0,
+      schedule: "\u5317\u4EAC\u65F6\u95F4 10:05 \u9996\u6B21\u7B7E\u5230\uFF0C20:05 \u4EC5\u8865\u67E5\u53EF\u91CD\u8BD5\u7684\u5931\u8D25\uFF1BDSH \u8FD0\u884C\u65F6\u6267\u884C\uFF0C\u542F\u52A8\u65F6\u8865\u67E5",
+      report: this.data.report,
+      accounts: this.manager.config.accounts.map((a) => {
+        const rows = Object.values(this.data.records).filter((r) => r.ids?.includes(a.id));
+        const last = rows.sort((a2, b) => b.at - a2.at)[0];
+        const pause = this.data.pauses[a.provider];
+        return {
+          id: a.id,
+          supported: supportsCheckin(a.provider),
+          auto: a.autoCheckin === true,
+          paused: !!pause,
+          last: last ? {
+            day: last.day,
+            at: last.at,
+            status: last.status,
+            amount: last.amount,
+            activity: last.activity,
+            retryAt: last.retryAt,
+            retryReady: canRetry(last, this.now()),
+            message: checkinMessages[last.status] || checkinMessages.error
+          } : void 0
+        };
+      })
+    };
+  }
+  start(ids, automatic = false) {
+    if (this.failed || this.abort.signal.aborted || this.flight) return;
+    if (!automatic && (!Array.isArray(ids) || !ids.length || ids.length > 200 || ids.some((id) => !this.manager.config.accounts.some((a) => a.id === id)))) throw Error("\u8BF7\u9009\u62E9\u6709\u6548\u7684\u7B7E\u5230\u8D26\u53F7");
+    const selected = this.manager.config.accounts.filter((a) => supportsCheckin(a.provider) && a.enabled !== false && (automatic ? a.autoCheckin === true : ids.includes(a.id))).map((a) => a.id);
+    if (!selected.length) return;
+    this.flight = (async () => {
+      let requested = false;
+      const counts = {};
+      for (const id of selected) {
+        if (this.abort.signal.aborted) break;
+        const account = this.manager.config.accounts.find((a) => a.id === id && a.enabled !== false && (!automatic || a.autoCheckin === true));
+        if (!account) continue;
+        if (requested) {
+          await delay(this.spacingMs, void 0, { signal: this.abort.signal });
+          requested = false;
+        }
+        this.current = id;
+        requested = await this.run(account, automatic);
+        if (requested) {
+          const last = this.state().accounts.find((a) => a.id === id)?.last;
+          if (last) counts[last.status] = (counts[last.status] || 0) + 1;
+        }
+      }
+      if (Object.keys(counts).length) await withFileLock(this.file, async () => {
+        await this.read();
+        this.data.report = { at: this.now(), counts };
+        await writePrivateJson(this.file, this.data);
+      });
+    })().catch(() => {
+      if (!this.abort.signal.aborted) this.failed = true;
+    }).finally(() => {
+      this.flight = void 0;
+      this.current = void 0;
+    });
+  }
+  async resume(provider) {
+    if (!supportsCheckin(provider) || this.failed || this.flight) throw Error("\u8BF7\u7B49\u5F85\u7B7E\u5230\u5B8C\u6210\uFF0C\u6216\u5148\u4FEE\u590D\u7B7E\u5230\u8BB0\u5F55");
+    await withFileLock(this.file, async () => {
+      await this.read();
+      delete this.data.pauses[provider];
+      await writePrivateJson(this.file, this.data);
+    });
+  }
+  async credentialsUpdated(id) {
+    await withFileLock(this.file, async () => {
+      await this.read();
+      for (const [key, row] of Object.entries(this.data.records)) if (row.status === "auth-invalid" && row.ids.includes(id)) delete this.data.records[key];
+      await writePrivateJson(this.file, this.data);
+    }, { waitMs: 3e4 });
+  }
+  async run(account, automatic = false) {
+    const now = this.now(), day = beijingDay(now);
+    if (now < Date.parse(`${day}T10:05:00+08:00`)) return false;
+    return withFileLock(this.file, async () => {
+      await this.read();
+      if (this.abort.signal.aborted || this.data.pauses[account.provider]) return false;
+      const previousEntry = Object.entries(this.data.records).find(([, r]) => r.day === day && r.ids?.includes(account.id));
+      const previous = previousEntry?.[1];
+      if (previous && !canRetry(previous, now)) return false;
+      if (this.data.lastRequestAt && now - this.data.lastRequestAt < this.spacingMs) return false;
+      this.data.lastRequestAt = now;
+      await writePrivateJson(this.file, this.data);
+      const pendingKey = hash(`${account.provider}:local:${account.id}`);
+      const pending = {
+        day,
+        at: now,
+        status: "retryable",
+        ids: previous?.ids || [account.id],
+        attempts: (previous?.attempts || (previous ? 1 : 0)) + 1,
+        ...now < evening(now) ? { retryAt: evening(now) } : {}
+      };
+      if (previousEntry) delete this.data.records[previousEntry[0]];
+      this.data.records[pendingKey] = pending;
+      await writePrivateJson(this.file, this.data);
+      let identity, client;
+      try {
+        client = await this.manager.router.client(account);
+        if (!client.checkin) throw Error("Unsupported check-in");
+        identity = await client.checkin.identity(AbortSignal.any([this.abort.signal, AbortSignal.timeout(3e4)]));
+        if (!identity?.account || account.provider === "trae" && !identity.device) throw Error("Missing check-in identity");
+      } catch (error) {
+        pending.status = checkinFailure(error).status;
+        if (pending.status === "paused") this.data.pauses[account.provider] = { at: now };
+        await writePrivateJson(this.file, this.data);
+        return true;
+      }
+      if (this.abort.signal.aborted || !this.manager.config.accounts.some((a) => a.id === account.id && a.enabled !== false && a.credentialFile === account.credentialFile && (!automatic || a.autoCheckin === true))) return true;
+      const key = hash(`${account.provider}:${identity.account}`), device = identity.device ? hash(`${account.provider}:${identity.device}`) : void 0;
+      const old = this.data.records[key];
+      delete this.data.records[pendingKey];
+      if (old?.day === day && !canRetry(old, now)) {
+        if (!old.ids.includes(account.id)) {
+          old.ids.push(account.id);
+          await writePrivateJson(this.file, this.data);
+        } else await writePrivateJson(this.file, this.data);
+        return false;
+      }
+      const record2 = {
+        ...pending,
+        status: "uncertain",
+        ids: [.../* @__PURE__ */ new Set([...pending.ids, ...old?.ids || [], account.id])],
+        attempts: Math.max(pending.attempts, old?.day === day ? (old.attempts || 1) + 1 : 1)
+      };
+      this.data.records[key] = record2;
+      for (const [k, row] of Object.entries(this.data.records)) if (row.at < now - 30 * 864e5) delete this.data.records[k];
+      for (const [k, row] of Object.entries(this.data.devices)) if (row.until <= now) delete this.data.devices[k];
+      if (device && this.data.devices[device]?.until > now) {
+        record2.status = "device-used";
+        await writePrivateJson(this.file, this.data);
+        return true;
+      }
+      if (device) this.data.devices[device] = { until: nextDay(now) };
+      await writePrivateJson(this.file, this.data);
+      let result;
+      try {
+        result = await client.checkin.claim(AbortSignal.any([this.abort.signal, AbortSignal.timeout(3e4)]));
+      } catch {
+        result = { status: "uncertain" };
+      }
+      record2.status = Object.hasOwn(checkinMessages, result?.status) ? result.status : "uncertain";
+      if (device && ["already-claimed", "no-campaign", "retryable", "before-window", "auth-invalid"].includes(record2.status)) delete this.data.devices[device];
+      if (record2.attempts >= 2 || !["retryable", "before-window"].includes(record2.status)) delete record2.retryAt;
+      if (["claimed", "already-claimed"].includes(record2.status) && Number.isFinite(result.amount) && result.amount >= 0) record2.amount = result.amount;
+      if (result?.activity) record2.activity = Object.fromEntries(["streakDays", "totalCredits", "nextStreakDay", "endsAt"].filter((k) => Number.isFinite(result.activity[k]) && result.activity[k] >= 0).map((k) => [k, result.activity[k]]));
+      if (record2.status === "paused" || result?.paused === true) this.data.pauses[account.provider] = { at: now };
+      await writePrivateJson(this.file, this.data);
+      if (record2.status === "claimed") await this.manager.monitorAccount(account);
+      return true;
+    }, { waitMs: 1e3 });
+  }
+};
+
 // src/stream.mjs
 async function preflightStream(response, signal) {
   if (!response.body) return { ok: false, status: 502, kind: "empty_stream" };
@@ -4889,7 +5112,7 @@ var expiryMs = (value) => {
 };
 async function jsonCredential(file) {
   try {
-    return JSON.parse(await readFile(file, "utf8"));
+    return JSON.parse(await readFile2(file, "utf8"));
   } catch {
     throw new RouteError(401, "credential_unreadable");
   }
@@ -4917,7 +5140,7 @@ async function createAccountClient(account, config, attachments) {
       variant,
       ownPath: account.credentialFile,
       desktopPath: `${account.credentialFile}.no-desktop`,
-      refresh: (c) => client.refreshToken(c)
+      refresh: (c) => account.provider === "workbuddy" ? refreshWorkBuddyCheckinCredential(c) : client.refreshToken(c)
     });
     const credential = async () => {
       try {
@@ -4948,6 +5171,7 @@ async function createAccountClient(account, config, attachments) {
       };
     };
     chat = async (input, signal) => client.chatStream(await credential(), prepareChatBody(JSON.stringify(input)), signal);
+    if (account.provider === "workbuddy") checkin = createWorkBuddyCheckin(() => store.resolve());
   } else if (account.provider.startsWith("trae")) {
     const snapshot = await jsonCredential(account.credentialFile);
     const saved = snapshot.credential;
@@ -4975,8 +5199,9 @@ async function createAccountClient(account, config, attachments) {
     };
     const usage = new TraeUsageClient({ credential, deviceId: async () => (await identity()).deviceId });
     if (account.provider === "trae") {
+      const checkinCredential = () => store.resolve();
       const checkinUsage = new TraeUsageClient({
-        credential,
+        credential: checkinCredential,
         deviceId: async () => (await identity()).deviceId,
         fetchImpl: async (url, options) => {
           const response = await fetch(url, options);
@@ -4985,11 +5210,12 @@ async function createAccountClient(account, config, attachments) {
             const body = await response.clone().json();
             if (body.code !== void 0 && body.code !== 0 || typeof body.checked_in !== "boolean" || typeof body.did_checked_in !== "boolean") throw Object.assign(Error("checkin_status_rejected"), { status: 403 });
           }
+          if (String(url).endsWith("/claim") && !Number.isFinite((await response.clone().json()).code)) throw Error("checkin_claim_invalid");
           return response;
         }
       });
       checkin = {
-        identity: async () => ({ account: (await credential()).userId, device: (await identity()).deviceId }),
+        identity: async () => ({ account: (await checkinCredential()).userId, device: (await identity()).deviceId }),
         claim: (signal) => claimTraeCheckin(checkinUsage, signal)
       };
     }
@@ -5052,27 +5278,7 @@ async function createAccountClient(account, config, attachments) {
       transport,
       ...attachments ? { attachments } : {}
     });
-    const checkinTransport = createQoderTransport({
-      region,
-      resolvePat: getPat,
-      resolveMachineId: () => getMachineId(),
-      fetch: async (url, options) => {
-        const response = await fetch(url, options);
-        if (!response.ok) {
-          const restricted = [401, 403, 429].includes(response.status);
-          throw new QoderLlmError(`checkin_http_${response.status}`, restricted ? "QUOTA" : "PROVIDER_ERROR", { status: response.status });
-        }
-        return response;
-      }
-    });
-    checkin = {
-      identity: async (signal) => ({ account: (await checkinTransport.readAccount({ signal })).profile.id }),
-      claim: async (signal) => {
-        const result = await checkinTransport.checkIn(signal);
-        if (result.status !== "error") return { status: result.status };
-        return { status: /401|403|429|rate.?limit|throttl|captcha|verify|verification|风控|验证|频繁|forbidden|unauthor|AUTH/i.test(result.message || "") ? "paused" : "uncertain" };
-      }
-    };
+    checkin = createQoderCheckin(region, getPat);
     accountInfo = async (signal) => {
       const result = await transport.readAccount({ force: true, signal });
       const buckets = [["\u4E2A\u4EBA\u5957\u9910", result.usage?.userQuota], ["\u9644\u52A0\u989D\u5EA6", result.usage?.addOnQuota], ["\u7EC4\u7EC7\u989D\u5EA6", result.usage?.orgResourcePackage]].filter(([, p]) => p).map(([name, p]) => ({ ...p, name }));
@@ -5101,25 +5307,173 @@ async function createAccountClient(account, config, attachments) {
   };
 }
 async function claimTraeCheckin(usage, signal) {
+  let submitted = false;
   try {
     const status = await usage.checkinStatus(signal);
     if (status.checkedIn) return { status: "already-claimed" };
     if (status.didCheckedIn) return { status: "device-used" };
     if (!status.enabled) return { status: "no-campaign" };
+    submitted = true;
     const claim = await usage.claimCheckin(signal);
     if (claim.code === 9095) return { status: "device-used" };
     if (!claim.claimed) return { status: "paused" };
     return { status: "claimed", ...Number.isFinite(status.credits) ? { amount: status.credits + (status.extraCredits || 0) } : {} };
   } catch (e) {
-    return { status: [401, 403, 429].includes(e.status) ? "paused" : "uncertain" };
+    return checkinFailure(e, submitted);
+  }
+}
+function createQoderCheckin(region, getPat, { fetchImpl = (...args) => fetch(...args), now = Date.now } = {}) {
+  const guardedFetch = async (url, options) => {
+    try {
+      const response = await fetchImpl(url, options);
+      if (!response.ok) throw new QoderLlmError("checkin_http_error", "PROVIDER_ERROR", { status: response.status });
+      if (String(url).endsWith("/campaigns") && !Array.isArray((await response.clone().json()).campaigns)) throw Error("checkin_campaigns_invalid");
+      return response;
+    } catch (error) {
+      if (error instanceof QoderLlmError) throw error;
+      throw new QoderLlmError("checkin_network_error", "PROVIDER_ERROR");
+    }
+  };
+  const auth = new QoderAuthService({ region, fetch: guardedFetch, resolveMachineId: () => getMachineId() });
+  const campaigns = new QoderCheckInService({ region, authService: auth, fetch: guardedFetch });
+  const credentials = async (signal) => auth.getCredentials(await getPat(), signal);
+  return {
+    identity: async (signal) => ({ account: (await credentials(signal)).userID }),
+    claim: async (signal) => {
+      let submitted = false;
+      try {
+        const token = (await credentials(signal)).authToken;
+        const rows = await campaigns.fetchCampaigns(token, signal), time = now();
+        const benefits = rows.filter((c) => c.actionType === "CLAIM_BENEFIT");
+        const active = benefits.filter((c) => (!Number.isFinite(c.startAt) || c.startAt * 1e3 <= time) && (!Number.isFinite(c.endAt) || c.endAt * 1e3 > time));
+        const target = active.find((c) => c.claimStatus === "CLAIMABLE" && typeof c.campaignId === "string" && c.campaignId);
+        if (!target) {
+          if (active.some((c) => c.claimStatus === "CLAIMED")) return { status: "already-claimed" };
+          return { status: benefits.some((c) => c.startAt * 1e3 > time || c.endAt * 1e3 <= time) ? "before-window" : "no-campaign" };
+        }
+        submitted = true;
+        const result = await campaigns.claimCampaign(token, target.campaignId, signal);
+        if (result.status !== "CLAIMED") return { status: "paused" };
+        return {
+          status: result.replayed ? "already-claimed" : "claimed",
+          ...Number.isFinite(result.benefit?.amount) && result.benefit.amount >= 0 ? { amount: result.benefit.amount } : {}
+        };
+      } catch (error) {
+        return checkinFailure(error, submitted);
+      }
+    }
+  };
+}
+function workbuddyToken(token) {
+  try {
+    const [head, body, signature, extra] = token.split(".");
+    const header = JSON.parse(Buffer.from(head, "base64url")), payload = JSON.parse(Buffer.from(body, "base64url"));
+    if (extra || !signature || header.alg !== "RS256" || payload.iss !== "https://www.codebuddy.cn/auth/realms/copilot" || typeof payload.sub !== "string" || !payload.sub) throw Error();
+    return payload;
+  } catch {
+    throw Object.assign(Error("HTTP 401 invalid_workbuddy_cn_token"), { status: 401 });
   }
 }
+async function workbuddyPost(url, headers, signal, fetchImpl) {
+  let response;
+  try {
+    response = await fetchImpl(url, { method: "POST", headers: { "Content-Type": "application/json", "Accept-Encoding": "identity", ...headers }, body: "{}", signal });
+  } catch {
+    throw Object.assign(Error("workbuddy_checkin_network"), { transient: !signal?.aborted });
+  }
+  if (!response.ok) throw Object.assign(Error(`HTTP ${response.status} workbuddy_checkin_http`), { status: response.status, transient: response.status >= 500 });
+  const body = JSON.parse(await readLimitedText(response, 256 * 1024, "Check-in"));
+  if (body?.code === 401 || body?.code === 40100) throw Object.assign(Error("HTTP 401 workbuddy_checkin_auth"), { status: 401 });
+  if ([403, 429].includes(body?.code)) throw Object.assign(Error(`HTTP ${body.code} workbuddy_checkin_restricted`), { status: body.code });
+  return body;
+}
+async function refreshWorkBuddyCheckinCredential(credential, { fetchImpl = (...args) => fetch(...args), signal = AbortSignal.timeout(3e4) } = {}) {
+  const body = await workbuddyPost("https://copilot.tencent.com/v2/plugin/auth/token/refresh", {
+    "X-Refresh-Token": credential.refreshToken,
+    "X-Auth-Refresh-Source": "plugin"
+  }, signal, fetchImpl);
+  if (body.code !== 0 || typeof body.data?.accessToken !== "string") throw Error("workbuddy_refresh_rejected");
+  const token = workbuddyToken(body.data.accessToken);
+  if (token.sub !== credential.uid || !(token.exp * 1e3 > Date.now())) throw Object.assign(Error("HTTP 401 workbuddy_refresh_identity"), { status: 401 });
+  return {
+    accessToken: body.data.accessToken,
+    expiresInSec: (token.exp * 1e3 - Date.now()) / 1e3,
+    ...typeof body.data.refreshToken === "string" && body.data.refreshToken ? { refreshToken: body.data.refreshToken } : {}
+  };
+}
+function createWorkBuddyCheckin(credential, { fetchImpl = (...args) => fetch(...args), sleep = delay2, now = Date.now } = {}) {
+  const login = async () => {
+    const c = await credential(), token = workbuddyToken(c.accessToken);
+    if (c.uid !== token.sub) throw Object.assign(Error("workbuddy_uid_mismatch"), { status: 401 });
+    return { ...c, uid: token.sub };
+  };
+  const post = (path, c, signal) => workbuddyPost(`https://www.workbuddy.cn/v2/billing/meter/${path}`, {
+    Authorization: `Bearer ${c.accessToken}`,
+    "X-User-Id": c.uid,
+    Origin: "https://www.workbuddy.cn",
+    Referer: "https://www.workbuddy.cn/profile/growth-center",
+    "User-Agent": "Mozilla/5.0"
+  }, signal, fetchImpl);
+  const activity = (data) => {
+    const rawEnd = data.end_time;
+    const endsAt = typeof rawEnd === "string" ? Date.parse(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(rawEnd) ? `${rawEnd.replace(" ", "T")}+08:00` : rawEnd) : void 0;
+    return { streakDays: data.streak_days, totalCredits: data.total_credits, nextStreakDay: data.next_streak_day, endsAt };
+  };
+  return {
+    identity: async () => ({ account: (await login()).uid }),
+    claim: async (signal) => {
+      let submitted = false;
+      try {
+        const c = await login();
+        let state;
+        for (let attempt = 0; ; attempt++) {
+          try {
+            state = await post("checkin-activity-status", c, signal);
+            break;
+          } catch (error) {
+            if (!error.transient || attempt >= 2 || signal?.aborted) throw error;
+            await sleep((attempt + 1) * 2e3, void 0, { signal });
+          }
+        }
+        if (![0, 200].includes(state?.code) || !state.data || typeof state.data !== "object") throw Error("workbuddy_status_invalid");
+        const stats = activity(state.data);
+        if (state.data.today_checked_in === true) return { status: "already-claimed", activity: stats };
+        if (state.data.active === false || stats.endsAt <= now()) return { status: "no-campaign", activity: stats };
+        if (state.data.today_checked_in !== false) throw Error("workbuddy_status_unknown");
+        submitted = true;
+        const result = await post("daily-checkin", c, signal);
+        const claimed = [0, 200].includes(result?.code), already = /今天已签到|今日已签到|already\s+(?:checked|signed)/i.test(result?.msg || "");
+        if (!claimed && !already) return { status: Number.isFinite(result?.code) ? "paused" : "uncertain" };
+        let updated = stats, paused = false;
+        try {
+          const after = await post("checkin-activity-status", c, signal);
+          if ([0, 200].includes(after?.code) && after.data) updated = activity(after.data);
+        } catch (error) {
+          paused = checkinFailure(error).status === "paused";
+        }
+        return {
+          status: already ? "already-claimed" : "claimed",
+          activity: updated,
+          ...paused ? { paused: true } : {},
+          ...claimed && Number.isFinite(result.data?.credit) && result.data.credit >= 0 ? { amount: result.data.credit } : {}
+        };
+      } catch (error) {
+        return checkinFailure(error, submitted);
+      }
+    }
+  };
+}
 
 export {
   qoderPluginDataDir,
+  supportsCheckin,
+  Checkins,
   jsonCredential,
   cachedModels,
   createAccountClient,
-  claimTraeCheckin
+  claimTraeCheckin,
+  createQoderCheckin,
+  refreshWorkBuddyCheckinCredential,
+  createWorkBuddyCheckin
 };
-//# sourceMappingURL=chunk-YUP77Q3A.js.map
+//# sourceMappingURL=chunk-RPW6DI6O.js.map