dsh-connect-workbuddy 4.9.3 → 4.10.0

package/lib/{host-heartbeat-BHaBzzOr.js → host-heartbeat-BQHO4oiB.js}

@@ -917,6 +917,19 @@ function clearAtRestKeyCache() {
 *
 * @module dsh-connect-workbuddy/upstream
 */
+/**
+* The write half of each campaign: the endpoint that actually grants the
+* credits.
+*
+* Kept beside the status paths because they must move together: the pair is
+* what the 「套餐与积分」 page itself uses (`xp`/`vp` in its bundle), and a
+* campaign whose status is read from one path can only be claimed through its
+* matching claim path. Note the same absence of a `/v2` prefix.
+*/
+const BENEFIT_CLAIM_PATHS = {
+	compensation: "/billing/meter/claim-compensation",
+	gift: "/billing/meter/claim-gift"
+};
 const CN_CHAT_BASE = "https://copilot.tencent.com";
 const CN_BILLING_BASE = "https://www.codebuddy.cn";
 const GLOBAL_BASE = "https://www.workbuddy.ai";
@@ -1095,6 +1108,23 @@ function classifyUpstreamError(status, body) {
 	return "client";
 }
 /**
+* Read one of the upstream's localized fields, in either shape it ships: a plain
+* string, or a `{ zh, en }` object.
+*
+* One reader for every such field on purpose. `displayMsg` and `displayTips`
+* arrive in the same two shapes from the same envelope, so parsing them with two
+* separate hand-rolled branches is how one of them ends up only handling the
+* object form (which is exactly what happened to `displayTips`: it was never
+* read at all, issue #78).
+*/
+function localizedText(value) {
+	if (typeof value === "string") return value;
+	if (typeof value !== "object" || value === null) return void 0;
+	const localized = value;
+	const pick = localized.zh ?? localized.en;
+	return typeof pick === "string" ? pick : void 0;
+}
+/**
 * Parse the known-good fields out of an upstream failure body. Non-JSON
 * bodies (HTML error pages, empty strings) yield undefined rather than a guess.
 */
@@ -1107,19 +1137,13 @@ function parseUpstreamErrorDetail(body) {
 	}
 	if (typeof parsed !== "object" || parsed === null) return void 0;
 	const raw = parsed;
-	let displayMsg;
-	const display = raw.displayMsg;
-	if (typeof display === "string") displayMsg = display;
-	else if (typeof display === "object" && display !== null) {
-		const localized = display;
-		const pick = localized.zh ?? localized.en;
-		if (typeof pick === "string") displayMsg = pick;
-	}
-	if (displayMsg === void 0 && typeof raw.msg === "string") displayMsg = raw.msg;
+	const displayMsg = localizedText(raw.displayMsg) ?? (typeof raw.msg === "string" ? raw.msg : void 0);
+	const tips = localizedText(raw.displayTips);
 	const detail = {};
 	if (typeof raw.code === "number") detail.upstreamCode = raw.code;
 	if (typeof raw.requestId === "string") detail.requestId = raw.requestId;
 	if (displayMsg !== void 0) detail.displayMsg = displayMsg;
+	if (tips !== void 0) detail.tips = tips;
 	return detail;
 }
 /**
@@ -1910,6 +1934,90 @@ var WorkBuddyUpstreamClient = class {
 			...typeof data["claim_button_text"] === "string" && data["claim_button_text"] !== "" ? { claimButtonText: data["claim_button_text"] } : {}
 		};
 	}
+	/**
+	* Read every promotional benefit this account can still see, WITHOUT claiming
+	* anything.
+	*
+	* The campaign list is closed and small on purpose: the gateway exposes one
+	* status endpoint per campaign, so "discover benefits" is a fixed fan-out, not
+	* a search. A new campaign type means a new `/billing/meter/*-status` endpoint
+	* added here — the plugin never guesses at undocumented ones.
+	*
+	* Every endpoint is read in parallel because they are independent, and a
+	* failure is per-endpoint: one campaign answering 5xx must not blank out the
+	* other. The caller gets only what was actually read.
+	*
+	* Note the paths carry NO `/v2` prefix — these are not the `/v2/billing/meter`
+	* family the credit and check-in calls use. Probing `/v2/...` answers 404, which
+	* is how this distinction was found.
+	*/
+	async fetchBenefits(credential) {
+		const read = async (kind, path) => {
+			try {
+				return await this.readBenefitStatus(kind, credential, path);
+			} catch {
+				return;
+			}
+		};
+		const [compensation, gift] = await Promise.all([read("compensation", "/billing/meter/compensation-status"), read("gift", "/billing/meter/check-gift-claimed")]);
+		return [compensation, gift].filter((benefit) => benefit !== void 0);
+	}
+	/** One benefit status endpoint. Throws on anything that is not a clean `code: 0`. */
+	async readBenefitStatus(kind, credential, path) {
+		const response = await fetch(`${billingBase(credential)}${path}`, {
+			method: "POST",
+			headers: billingHeaders(credential),
+			body: "{}",
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+		const data = typeof envelope.data === "object" && envelope.data !== null ? envelope.data : {};
+		const numberField = (key) => typeof data[key] === "number" ? data[key] : 0;
+		/** The gateway states times as `YYYY-MM-DD HH:MM:SS` in local time. */
+		const timeField = (key) => {
+			const raw = data[key];
+			if (typeof raw !== "string" || raw.trim() === "") return void 0;
+			const parsed = Date.parse(raw.replace(" ", "T"));
+			return Number.isNaN(parsed) ? void 0 : parsed;
+		};
+		const endsAtMs = timeField("end_time");
+		const startsAtMs = timeField("start_time");
+		const claimedAtMs = timeField("claimed_at");
+		return {
+			kind,
+			active: data["active"] === true,
+			claimed: data["claimed"] === true,
+			creditNum: numberField("credit_num"),
+			...endsAtMs === void 0 ? {} : { endsAtMs },
+			...startsAtMs === void 0 ? {} : { startsAtMs },
+			...claimedAtMs === void 0 ? {} : { claimedAtMs }
+		};
+	}
+	/**
+	* Claim one benefit campaign on ONE account (issue #79).
+	*
+	* This is a real credit grant on a real account, so it takes no account
+	* argument other than the credential it is handed: the caller decides which
+	* single account, and there is deliberately no batch form of this method. The
+	* browser route is the only caller, and it guards the mutation with the same
+	* POST + loopback checks the check-in route carries.
+	*
+	* The response is not parsed: the documented envelope of these two endpoints
+	* is an empty success, and the caller re-reads the status afterwards. That
+	* re-read, not this answer, is what the user is shown — which is why a claim
+	* that silently did nothing still cannot leave the card saying 待领取.
+	*/
+	async claimBenefit(credential, kind) {
+		const response = await fetch(`${billingBase(credential)}${BENEFIT_CLAIM_PATHS[kind]}`, {
+			method: "POST",
+			headers: billingHeaders(credential),
+			body: "{}",
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+	}
 	/** Claim today's check-in reward. The browser route guards this mutation. */
 	async claimDailyCheckin(credential) {
 		const response = await fetch(`${billingBase(credential)}/v2/billing/meter/daily-checkin`, {
@@ -3966,7 +4074,7 @@ function generationOf(version) {
 //#endregion
 //#region src/version.ts
 /** The npm package version this build was produced from. */
-const WORKBUDDY_CONNECT_VERSION = "4.9.3";
+const WORKBUDDY_CONNECT_VERSION = "4.10.0";
 //#endregion
 //#region src/host-heartbeat.ts
 /**

package/lib/index.d.ts

@@ -706,6 +706,47 @@ interface WorkBuddyCheckinClaim {
   streakDays: number;
   isStreakDay: boolean;
 }
+/**
+ * One promotional benefit the account may or may not still be entitled to.
+ *
+ * Read from the billing gateway's OWN status endpoints — the same two the
+ * 「套餐与积分」 page calls before it decides whether to render a claim card
+ * (`/billing/meter/compensation-status`, `/billing/meter/check-gift-claimed`).
+ * Reading them is what makes the card honest: the plugin shows a benefit only
+ * while the gateway itself would still show one.
+ *
+ * The two flags answer DIFFERENT questions and neither can be derived from the
+ * other — this is the single most important fact about this shape, measured on
+ * a real account pool:
+ *
+ *   - `active` is about the WINDOW, not about the reader. An account that has
+ *     already claimed still reports `active: true` (observed: `claimed: true`
+ *     together with `active: true` on a claimed gift), so `active` alone cannot
+ *     mean "claimable".
+ *   - `claimed` is about THIS account, and it survives the window: once the
+ *     campaign lapses the endpoint keeps answering `claimed: false` with
+ *     `active: false` (observed on every international account, whose campaign
+ *     ended months ago).
+ *
+ * Hence a benefit is claimable exactly when {@link active} AND NOT
+ * {@link claimed}. See `benefitOf` in `src/benefits.ts`.
+ */
+interface WorkBuddyBenefit {
+  /** Which campaign this is; the plugin renders one row per kind. */
+  kind: 'compensation' | 'gift';
+  /** The campaign is inside its window (empty, see: already claimed ≠ inactive). */
+  active: boolean;
+  /** This account has already taken it — permanently, even after the window. */
+  claimed: boolean;
+  /** Credits on offer, as the gateway states them. */
+  creditNum: number;
+  /** Window end, epoch ms. Absent when the gateway sent none it could parse. */
+  endsAtMs?: number;
+  /** Window start, epoch ms. Compensation omits it. */
+  startsAtMs?: number;
+  /** When this account claimed it, epoch ms. Only meaningful with `claimed`. */
+  claimedAtMs?: number;
+}
 /** Token refresh answer; fields the upstream omits stay absent. */
 interface WorkBuddyRefreshOutcome {
   accessToken: string;
@@ -754,6 +795,23 @@ interface UpstreamErrorDetail {
   requestId?: string;
   /** Best human-facing message: `displayMsg.zh`, falling back to `.en`, then `msg`. */
   displayMsg?: string;
+  /**
+   * What the upstream says to DO about it: `displayTips.zh`, falling back to
+   * `.en` (issue #78).
+   *
+   * Kept separate from {@link displayMsg} because the two answer different
+   * questions and both are needed: `displayMsg` names what was rejected
+   * ("模型无法处理此请求"), while `displayTips` names the REMEDY ("请新建任务、换个
+   * 模型或稍后重试"). The generic failure path used to discard it and render the
+   * raw body instead, whose first 400 characters are the `code`/`requestId`/
+   * `extError` skeleton — so the one actionable sentence was always cut off, and
+   * a plain parameter rejection read like an empty account pool.
+   *
+   * Recorded as data rather than folded into `displayMsg` so a caller that wants
+   * to tell the user what to change can do so without the "what went wrong"
+   * clause losing its own meaning.
+   */
+  tips?: string;
 }
 /**
  * Region for a login domain; an empty domain means CN (matching upstream tooling).
@@ -917,6 +975,41 @@ declare class WorkBuddyUpstreamClient {
   fetchModels(credential: WorkBuddyCredential, signal?: AbortSignal): Promise<readonly WorkBuddyUpstreamModel[]>;
   /** Query today's check-in status without changing account state. */
   fetchCheckinStatus(credential: WorkBuddyCredential): Promise<WorkBuddyCheckinStatus>;
+  /**
+   * Read every promotional benefit this account can still see, WITHOUT claiming
+   * anything.
+   *
+   * The campaign list is closed and small on purpose: the gateway exposes one
+   * status endpoint per campaign, so "discover benefits" is a fixed fan-out, not
+   * a search. A new campaign type means a new `/billing/meter/*-status` endpoint
+   * added here — the plugin never guesses at undocumented ones.
+   *
+   * Every endpoint is read in parallel because they are independent, and a
+   * failure is per-endpoint: one campaign answering 5xx must not blank out the
+   * other. The caller gets only what was actually read.
+   *
+   * Note the paths carry NO `/v2` prefix — these are not the `/v2/billing/meter`
+   * family the credit and check-in calls use. Probing `/v2/...` answers 404, which
+   * is how this distinction was found.
+   */
+  fetchBenefits(credential: WorkBuddyCredential): Promise<readonly WorkBuddyBenefit[]>;
+  /** One benefit status endpoint. Throws on anything that is not a clean `code: 0`. */
+  private readBenefitStatus;
+  /**
+   * Claim one benefit campaign on ONE account (issue #79).
+   *
+   * This is a real credit grant on a real account, so it takes no account
+   * argument other than the credential it is handed: the caller decides which
+   * single account, and there is deliberately no batch form of this method. The
+   * browser route is the only caller, and it guards the mutation with the same
+   * POST + loopback checks the check-in route carries.
+   *
+   * The response is not parsed: the documented envelope of these two endpoints
+   * is an empty success, and the caller re-reads the status afterwards. That
+   * re-read, not this answer, is what the user is shown — which is why a claim
+   * that silently did nothing still cannot leave the card saying 待领取.
+   */
+  claimBenefit(credential: WorkBuddyCredential, kind: WorkBuddyBenefit['kind']): Promise<void>;
   /** Claim today's check-in reward. The browser route guards this mutation. */
   claimDailyCheckin(credential: WorkBuddyCredential): Promise<WorkBuddyCheckinClaim>;
   /**
@@ -1994,6 +2087,29 @@ declare function probeModel(input: {
   signal?: AbortSignal;
 }): Promise<WorkBuddyProbeResult>;
 //#endregion
+//#region src/benefits.d.ts
+/** What the account card shows for one campaign. */
+type WorkBuddyBenefitState =
+/** Offered, inside its window, not taken yet. The only state with a claim button. */
+'claimable' |
+/** This account already took it. Rendered as nothing at all. */
+'claimed' |
+/** The window is over and it was never taken — the offer is gone. */
+'expired';
+/** One campaign, resolved for display. */
+interface WorkBuddyBenefitView {
+  kind: WorkBuddyBenefit['kind'];
+  state: WorkBuddyBenefitState;
+  /** Credits on offer, as the gateway stated them. */
+  creditNum: number;
+  /** Window end, epoch ms. */
+  endsAtMs?: number;
+  /** Whole days until the window closes, floored at 0. Absent without `endsAtMs`. */
+  daysLeft?: number;
+  /** True while the window closes within {@link URGENT_DAYS} days. */
+  urgent: boolean;
+}
+//#endregion
 //#region src/account-pool.d.ts
 /**
  * Which of the pool's writers produced a measurement.
@@ -2634,6 +2750,24 @@ type WorkBuddyWebPoolExclusion = 'unusable' | 'rate-limited' |
  * does not say (issue #56).
  */
 'model-busy' | 'out-of-credit' | 'credential-rejected' | 'not-found' | 'unavailable' | 'failed';
+/** One claimable benefit, as the card renders it (issue #79). */
+interface WorkBuddyWebBenefit {
+  /** Which campaign: compensation (crash补偿) or gift (新人首月赠送). */
+  kind: 'compensation' | 'gift';
+  /** Display name for the campaign, resolved Host-side so both clients agree. */
+  title: string;
+  /** Credits on offer. */
+  creditNum: number;
+  /**
+   * Whole days until the window closes, floored at 0.
+   *
+   * ABSENT when the gateway stated no end time — the card must then omit the
+   * countdown rather than print a number nobody knows.
+   */
+  daysLeft?: number;
+  /** True when the window closes within 3 days, so the card can say 即将到期. */
+  urgent: boolean;
+}
 /**
  * One account's row in the pool, as the card renders it.
  *
@@ -2710,6 +2844,16 @@ interface WorkBuddyWebPoolAccount {
    * result the user just watched succeed.
    */
   checkedInToday?: boolean;
+  /**
+   * Promotional benefits this account can STILL claim (issue #79).
+   *
+   * Never carries a claimed or lapsed campaign: the issue's rule is that those
+   * do not appear at all, so their absence here IS the "hide it" instruction.
+   * ABSENT means not read (or nothing claimable), and the card renders no line
+   * either way — a benefit line is only ever added to say "there is something
+   * here for you", never to announce its own absence.
+   */
+  benefits?: readonly WorkBuddyWebBenefit[];
   /**
    * The model a TEST of this row would use (issue #61).
    *
@@ -2867,7 +3011,7 @@ declare const WORKBUDDY_SETTINGS_NS: "workbuddy";
 interface WorkBuddyStatusRouteOptions {
   /** The region-scoped credential store backing each region's requests. */
   store(region: WorkBuddyRegion): WorkBuddyCredentialStore;
-  client: Pick<WorkBuddyUpstreamClient, 'fetchCredits' | 'fetchCheckinStatus' | 'claimDailyCheckin'>;
+  client: Pick<WorkBuddyUpstreamClient, 'fetchCredits' | 'fetchCheckinStatus' | 'claimDailyCheckin' | 'fetchBenefits' | 'claimBenefit'>;
   /**
    * The requested region's last-refreshed model directory (unfiltered) for
    * card display. Region-scoped because the CN and international apps expose
@@ -3153,6 +3297,37 @@ interface WorkBuddyPoolDeps {
    * per-account read in the full document.
    */
   cachedCheckedInToday?(region: WorkBuddyRegion): Readonly<Record<string, boolean>>;
+  /**
+   * Claimable promotional benefits per account id (issue #79).
+   *
+   * Only campaigns the account can STILL claim are present; a claimed or lapsed
+   * campaign is absent on purpose, so the card renders nothing for it. Absent
+   * (or a missing entry) also means "not read yet", which the card treats the
+   * same way — no line, rather than a guessed state.
+   */
+  benefits?(region: WorkBuddyRegion): Promise<Readonly<Record<string, readonly WorkBuddyBenefitView[]>>>;
+  /**
+   * Claimable benefits, from the readings already taken this process.
+   *
+   * The first-paint counterpart of {@link benefits}: no request, so painting
+   * never waits on two upstream reads per account.
+   */
+  cachedBenefits?(region: WorkBuddyRegion): Readonly<Record<string, readonly WorkBuddyBenefitView[]>>;
+  /**
+   * Forget this account's cached benefit reading so the next status read is live.
+   *
+   * The claim route writes to upstream directly, so nothing else in the plugin
+   * knows the campaign just changed. Without this the card kept showing 领取 for
+   * up to `BENEFIT_CACHE_MS` (30 min) after a SUCCESSFUL claim: the credits went
+   * up, the pill stayed, and the only remaining explanation was "the claim
+   * silently failed" — which invited a second click the route then refused as
+   * already-claimed. `checkin` has the same rule and invalidates its own cache;
+   * this is the benefit counterpart.
+   *
+   * Absent is legal (a Host from before this hook) and means "the click refreshes
+   * the card, but the host-side cache may still answer stale for a while".
+   */
+  invalidateBenefit?(region: WorkBuddyRegion, accountId: string): void;
   /**
    * Every local sign-in the pool does NOT cover, so the card can offer them to
    * check in. Absent means the card lists only pool members.