dsh-connect-workbuddy 1.0.0

package/lib/host-heartbeat-DHfQtrSf.js

@@ -0,0 +1,1118 @@
+import { readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { withFileLock, writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { execFileSync } from "node:child_process";
+//#region src/auth.ts
+/**
+* WorkBuddy credential resolution.
+*
+* 参考：corrinehu/dsh-workbuddy-connect（MIT，Copyright (c) 2026 Corrine Hu）
+*   — 桌面端 auth 文件只读、刷新结果写入 $DSH_HOME 自有副本、双凭据取
+*     到期更晚者、按需刷新（5 分钟余量）与单飞去重、刷新失败但 token
+*     未过期则继续沿用旧 token。这些机制已在该项目验证，此处沿用。
+* 改动：原版只解析单个 `workbuddy-desktop.info`。WorkBuddy 桌面端在
+*   同一 auth 目录留下带时间戳的备份文件（`workbuddy-desktop.<stamp>.info`），
+*   实测这些文件各自持有不同账号的可用凭据（本机 6 个文件 → 2 个账号，
+*   均能通过上游鉴权，但积分分别为 1875 与 0）。本实现改为扫描整个
+*   auth 目录，按 uin 去重为多个可选账号，并默认优先有可用积分的账号。
+*   跟随 App 当前登录仍是默认行为，切换账号是显式选项。
+*
+* @module dsh-connect-workbuddy/auth
+*/
+/** Basename of the plugin-owned credential copy inside the Harness home. */
+const WORKBUDDY_AUTH_FILENAME = ".workbuddy-auth.json";
+/** Env variable that overrides the desktop auth-file location. */
+const WORKBUDDY_AUTH_FILE_ENV = "WORKBUDDY_AUTH_FILE";
+/** Basename of the live WorkBuddy desktop auth file. */
+const WORKBUDDY_LIVE_FILENAME = "workbuddy-desktop.info";
+/** Current on-disk format of the plugin-owned copy; readers reject others. */
+const OWN_FORMAT_VERSION = 1;
+/** Plugin-owned copy path inside the Harness home. */
+function workbuddyOwnAuthPath() {
+	return join(resolveDshHome(), WORKBUDDY_AUTH_FILENAME);
+}
+/**
+* Platform-default directories holding the WorkBuddy desktop app's auth file.
+*
+* Windows and Linux prefer the OS-issued env location and fall back to the
+* home-derived convention when it is unset, so a redirected profile (OneDrive
+* folder backup, enterprise policy) still resolves. macOS has no equivalent
+* env variable; the single Application Support path is used as-is.
+*
+* `platform`, `home`, and `env` are injectable so the platform branches are
+* testable on any host without touching a real machine.
+*/
+function defaultDesktopAuthDirs(platform = process.platform, home = homedir(), env = process.env) {
+	if (platform === "darwin") return [join(home, "Library", "Application Support", "CodeBuddyExtension", "Data", "Public", "auth")];
+	if (platform === "win32") {
+		const local = nonEmptyEnv(env["LOCALAPPDATA"]) ?? join(home, "AppData", "Local");
+		const roaming = nonEmptyEnv(env["APPDATA"]) ?? join(home, "AppData", "Roaming");
+		return [join(local, "CodeBuddyExtension", "Data", "Public", "auth"), join(roaming, "CodeBuddyExtension", "Data", "Public", "auth")];
+	}
+	if (platform === "linux") {
+		const config = nonEmptyEnv(env["XDG_CONFIG_HOME"]) ?? join(home, ".config");
+		return [join(config, "CodeBuddyExtension", "Data", "Public", "auth")];
+	}
+	return [];
+}
+/** A non-empty, trimmed env value, or undefined when unset/blank. */
+function nonEmptyEnv(value) {
+	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+/** The live auth file's platform candidates, in probe order. */
+function defaultDesktopAuthCandidates() {
+	return defaultDesktopAuthDirs().map((dir) => join(dir, WORKBUDDY_LIVE_FILENAME));
+}
+/** First platform-default candidate; see {@link defaultDesktopAuthCandidates}. */
+function defaultDesktopAuthPath() {
+	return defaultDesktopAuthCandidates()[0];
+}
+/** Normalize an expiry that may arrive in seconds or milliseconds. */
+function expiryToMs(value) {
+	if (value <= 0) return 0;
+	return value > 0xe8d4a51000 ? value : value * 1e3;
+}
+function optionalString(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/**
+* Parse a WorkBuddy auth document in either on-disk shape: the plugin OAuth
+* nested form `{"auth":{...},"account":{...}}` and the flat panel form.
+* Returns undefined when the document carries no access token.
+*/
+function parseWorkBuddyAuth(text, filePath) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	const document = parsed;
+	let auth;
+	let identity;
+	if (typeof document["auth"] === "object" && document["auth"] !== null) {
+		auth = document["auth"];
+		identity = typeof document["account"] === "object" && document["account"] !== null ? document["account"] : {};
+	} else {
+		auth = document;
+		identity = document;
+	}
+	const accessToken = typeof auth["accessToken"] === "string" ? auth["accessToken"] : "";
+	if (accessToken === "") return void 0;
+	const expiresAtMs = typeof auth["expiresAt"] === "number" ? expiryToMs(auth["expiresAt"]) : 0;
+	const refreshExpiresAtMs = typeof auth["refreshExpiresAt"] === "number" ? expiryToMs(auth["refreshExpiresAt"]) : void 0;
+	const enterpriseId = optionalString(identity["enterpriseId"]);
+	const nickname = optionalString(identity["nickname"]);
+	const uin = optionalString(identity["uin"]);
+	return {
+		accessToken,
+		refreshToken: typeof auth["refreshToken"] === "string" ? auth["refreshToken"] : "",
+		expiresAtMs,
+		...refreshExpiresAtMs === void 0 ? {} : { refreshExpiresAtMs },
+		domain: optionalString(auth["domain"]) ?? "",
+		uid: optionalString(identity["uid"]) ?? "",
+		...enterpriseId === void 0 ? {} : { enterpriseId },
+		...nickname === void 0 ? {} : { nickname },
+		...uin === void 0 ? {} : { uin },
+		source: "desktop",
+		filePath
+	};
+}
+/**
+* Rank two candidate files for the same account.
+*
+* The live `workbuddy-desktop.info` always wins: it is the app's current
+* sign-in, and the upstream revokes the tokens in the timestamped backups
+* even though their stored `expiresAt` is still in the future (observed on a
+* real machine — every backup claimed a 2027 expiry while only the live
+* file's token was accepted). Expiry is therefore only a tie-breaker among
+* backups, never the primary ordering.
+*/
+function fileRank(path) {
+	return authFileName(path) === WORKBUDDY_LIVE_FILENAME ? 0 : 1;
+}
+/**
+* Filename of a path regardless of the host separator: Windows paths use `\`
+* and this helper must keep working when a Windows path is compared on a
+* POSIX host (e.g. tests injecting a Windows-style auth dir).
+*/
+function authFileName(path) {
+	const separator = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	return separator === -1 ? path : path.slice(separator + 1);
+}
+/**
+* Stable account id. `uin` is the billing identity the upstream keys on and
+* survives across re-login; `uid` is the fallback for documents without one.
+*/
+function workbuddyAccountId(credential) {
+	const stable = credential.uin ?? credential.uid ?? credential.nickname ?? "unknown";
+	return createHash("sha256").update(`workbuddy\0${stable}`).digest("hex").slice(0, 24);
+}
+/** Serialize the plugin-owned copy. */
+function ownDocument(credential, accountId) {
+	return {
+		version: OWN_FORMAT_VERSION,
+		...accountId === void 0 ? {} : { accountId },
+		credential
+	};
+}
+/** Parse the plugin-owned copy; other versions and shapes are rejected. */
+function parseOwnDocument(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	const document = parsed;
+	if (document["version"] !== OWN_FORMAT_VERSION) return void 0;
+	if (typeof document["credential"] !== "object" || document["credential"] === null) return void 0;
+	const credential = parseWorkBuddyAuth(JSON.stringify({ auth: document["credential"] }), workbuddyOwnAuthPath());
+	if (credential === void 0) return void 0;
+	return {
+		...credential,
+		source: "dsh"
+	};
+}
+/** Whether a filesystem error reports an absent path. */
+function isENOENT(error) {
+	return error?.code === "ENOENT";
+}
+/** Read one auth file, tolerating absence and unparsable content. */
+async function readAuthFile(path) {
+	try {
+		return parseWorkBuddyAuth(await readFile(path, "utf8"), path);
+	} catch (error) {
+		if (isENOENT(error)) return void 0;
+		return;
+	}
+}
+/**
+* Read-only credential store with demand-driven refresh and multi-account
+* discovery.
+*
+* Refresh policy: refresh only when the access token is inside the margin
+* (or already expired), keep the refreshed credential in the plugin-owned
+* copy, and never write the desktop app's files. A failed refresh still
+* returns a not-yet-expired token so an unreachable refresh endpoint does
+* not take down a working session.
+*/
+var WorkBuddyCredentialStore = class {
+	refresh;
+	refreshMarginMs;
+	ownPath;
+	authDirs;
+	desktopPathOverride;
+	accountId;
+	/** Account ids with usable credit, tried first when nothing is selected. */
+	preferIds = [];
+	inflight;
+	constructor(options) {
+		this.refresh = options.refresh;
+		this.refreshMarginMs = options.refreshMarginMs ?? 3e5;
+		this.ownPath = options.ownPath ?? workbuddyOwnAuthPath();
+		this.authDirs = options.authDirs;
+		this.desktopPathOverride = options.desktopPath;
+	}
+	/** Repoint the desktop file or directory; applies on the next read. */
+	setDesktopPath(path) {
+		this.desktopPathOverride = path;
+		this.inflight = void 0;
+	}
+	/** Select an account by id; tokens stay outside settings. */
+	selectAccount(accountId) {
+		this.accountId = accountId;
+		this.inflight = void 0;
+	}
+	/** Selected account id, for diagnostics and route assembly. */
+	selectedAccountId() {
+		return this.accountId;
+	}
+	/**
+	* Preferred account ordering used when no account is explicitly selected.
+	* An account with zero credit fails every chat request, so accounts with
+	* usable credit must win the default.
+	*/
+	setPreferAccountIds(ids) {
+		this.preferIds = [...ids];
+		this.inflight = void 0;
+	}
+	/** The auth-file path candidates, in probe order. */
+	resolveDesktopCandidates() {
+		const fromEnv = process.env[WORKBUDDY_AUTH_FILE_ENV];
+		const explicit = this.desktopPathOverride ?? (fromEnv !== void 0 && fromEnv.trim() !== "" ? fromEnv : void 0);
+		if (explicit !== void 0) return [explicit];
+		return defaultDesktopAuthCandidates();
+	}
+	/** The resolved desktop auth-file path, for diagnostics. */
+	desktopAuthPath() {
+		return this.resolveDesktopCandidates()[0];
+	}
+	/** The plugin-owned copy path, for diagnostics. */
+	ownAuthPath() {
+		return this.ownPath;
+	}
+	/**
+	* Every auth file to scan: the live file plus the timestamped backups
+	* WorkBuddy leaves beside it.
+	*
+	* An explicitly configured path pins the *directory*: its siblings are
+	* still scanned, because a user who points the plugin at their auth file
+	* expects account switching to work the same way it does on the default
+	* path. Only the file ordering changes.
+	*
+	* A corrupt or signed-out file must never hide the others, so each read is
+	* independent and failures are skipped rather than propagated.
+	*/
+	async candidateFiles() {
+		const explicitPath = this.desktopPathOverride ?? ((process.env["WORKBUDDY_AUTH_FILE"] ?? "").trim() !== "" ? process.env["WORKBUDDY_AUTH_FILE"] : void 0);
+		const files = [];
+		if (explicitPath !== void 0) {
+			files.push(explicitPath);
+			for (const backup of await this.backupsBeside(explicitPath)) files.push(backup);
+			return files;
+		}
+		const dirs = this.authDirs ?? defaultDesktopAuthDirs();
+		for (const dir of dirs) {
+			const live = join(dir, WORKBUDDY_LIVE_FILENAME);
+			files.push(live);
+			for (const backup of await this.backupsBeside(live)) files.push(backup);
+		}
+		return files;
+	}
+	/** Timestamped siblings of one auth file, newest first by filename. */
+	async backupsBeside(path) {
+		const dir = dirname(path);
+		const base = path.slice(dir.length + 1);
+		try {
+			return (await readdir(dir)).filter((name) => name !== base && name.endsWith(".info")).sort().reverse().map((name) => join(dir, name));
+		} catch {
+			return [];
+		}
+	}
+	/**
+	* Read every local credential, deduplicated by account id. Files are
+	* probed newest-first, so the first entry for an account is its freshest.
+	*/
+	async readAll() {
+		const files = await this.candidateFiles();
+		const byId = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			const credential = await readAuthFile(file);
+			if (credential === void 0) continue;
+			const id = workbuddyAccountId(credential);
+			const existing = byId.get(id);
+			if (existing === void 0) {
+				byId.set(id, credential);
+				continue;
+			}
+			if (fileRank(credential.filePath) < fileRank(existing.filePath) || fileRank(credential.filePath) === fileRank(existing.filePath) && credential.expiresAtMs > existing.expiresAtMs) byId.set(id, credential);
+		}
+		const own = await this.readOwn();
+		if (own !== void 0) {
+			const id = workbuddyAccountId(own);
+			const existing = byId.get(id);
+			if (existing === void 0 || own.expiresAtMs > existing.expiresAtMs) byId.set(id, own);
+		}
+		return [...byId.values()];
+	}
+	/**
+	* Preferred account first, else the live sign-in, else the freshest
+	* credential. Following the app's current sign-in is the documented default
+	* behaviour; the backups exist so the user can switch explicitly.
+	*/
+	preferred(credentials) {
+		if (credentials.length === 0) return void 0;
+		for (const id of this.preferIds) {
+			const match = credentials.find((credential) => workbuddyAccountId(credential) === id);
+			if (match !== void 0) return match;
+		}
+		return credentials.reduce((best, credential) => {
+			if (fileRank(credential.filePath) < fileRank(best.filePath)) return credential;
+			if (fileRank(credential.filePath) === fileRank(best.filePath) && credential.expiresAtMs > best.expiresAtMs) return credential;
+			return best;
+		});
+	}
+	/** Token-free account list for the plugin card. */
+	async accounts() {
+		const credentials = await this.readAll();
+		if (credentials.length === 0) return [];
+		const selectedExists = this.accountId !== void 0 && credentials.some((credential) => workbuddyAccountId(credential) === this.accountId);
+		const defaultSelected = this.preferred(credentials);
+		return credentials.map((credential) => {
+			const id = workbuddyAccountId(credential);
+			return {
+				id,
+				accountName: credential.nickname ?? credential.uin ?? credential.uid,
+				...credential.uin === void 0 ? {} : { uin: credential.uin },
+				domain: credential.domain,
+				source: credential.source,
+				tokenExpiresAtMs: credential.expiresAtMs,
+				filePath: credential.filePath,
+				selected: selectedExists ? id === this.accountId : credential === defaultSelected
+			};
+		});
+	}
+	/** The freshest stored credential for the current selection, no refresh. */
+	async current() {
+		const credentials = await this.readAll();
+		if (this.accountId === void 0) return this.preferred(credentials);
+		return credentials.find((credential) => workbuddyAccountId(credential) === this.accountId) ?? this.preferred(credentials);
+	}
+	/** The credential to send upstream: {@link current}, refreshed on demand. */
+	async resolve() {
+		const credential = await this.current();
+		if (credential === void 0) {
+			const candidates = this.resolveDesktopCandidates();
+			const desktop = candidates.length > 0 ? candidates.join(" or ") : "(no desktop path on this platform)";
+			throw new Error(`workbuddy: no signed-in WorkBuddy account found; sign in once in the WorkBuddy desktop app (expected ${desktop} or ${WORKBUDDY_AUTH_FILE_ENV}), or refresh an existing session`);
+		}
+		if (!this.needsRefresh(credential)) return credential;
+		this.inflight ??= this.refreshNow(credential).finally(() => {
+			this.inflight = void 0;
+		});
+		return this.inflight;
+	}
+	/** Read-only sign-in summary; never refreshes and never throws. */
+	async status() {
+		try {
+			const credential = await this.current();
+			if (credential === void 0) return { state: "signed-out" };
+			return {
+				state: "signed-in",
+				expiresAtMs: credential.expiresAtMs,
+				...credential.refreshExpiresAtMs === void 0 ? {} : { refreshExpiresAtMs: credential.refreshExpiresAtMs },
+				...credential.nickname === void 0 ? {} : { nickname: credential.nickname },
+				...credential.domain === "" ? {} : { domain: credential.domain },
+				source: credential.source
+			};
+		} catch {
+			return { state: "signed-out" };
+		}
+	}
+	/** Remove the plugin-owned copy; the desktop files are untouched. */
+	async logout() {
+		await rm(this.ownPath, { force: true });
+		await rm(`${this.ownPath}.lock`, { force: true });
+	}
+	needsRefresh(credential) {
+		if (credential.expiresAtMs <= 0) return true;
+		return Date.now() + this.refreshMarginMs >= credential.expiresAtMs;
+	}
+	async refreshNow(credential) {
+		if (credential.refreshToken === "") {
+			if (credential.expiresAtMs > Date.now() + 3e4) return credential;
+			throw new Error("workbuddy: access token expired and no refresh token is stored; sign in again in the WorkBuddy desktop app");
+		}
+		try {
+			const outcome = await this.refresh(credential);
+			const refreshed = {
+				...credential,
+				accessToken: outcome.accessToken,
+				...outcome.refreshToken === void 0 ? {} : { refreshToken: outcome.refreshToken },
+				expiresAtMs: outcome.expiresInSec !== void 0 ? Date.now() + outcome.expiresInSec * 1e3 : credential.expiresAtMs,
+				...outcome.domain === void 0 || outcome.domain === "" ? {} : { domain: outcome.domain },
+				source: "dsh"
+			};
+			await this.saveOwn(refreshed);
+			return refreshed;
+		} catch (error) {
+			if (credential.expiresAtMs > Date.now() + 3e4) return credential;
+			throw new Error(`workbuddy: token refresh failed and the access token is expired (${String(error)}); open the WorkBuddy desktop app once to sign in again`);
+		}
+	}
+	async saveOwn(credential) {
+		const accountId = workbuddyAccountId(credential);
+		await withFileLock(this.ownPath, async () => {
+			await writeFileAtomic(this.ownPath, `${JSON.stringify(ownDocument(credential, accountId), null, 2)}\n`, {
+				mode: 384,
+				dirMode: 448
+			});
+		});
+	}
+	async readOwn() {
+		try {
+			return parseOwnDocument(await readFile(this.ownPath, "utf8"));
+		} catch {
+			return;
+		}
+	}
+	/** Whether any candidate file exists as a regular file; diagnostics only. */
+	async desktopFilePresent() {
+		for (const path of this.resolveDesktopCandidates()) try {
+			if ((await stat(path)).isFile()) return true;
+		} catch {}
+		return false;
+	}
+};
+//#endregion
+//#region src/catalog.ts
+/**
+* Static CLI models captured from the CN endpoint (2026-08-30). The upstream
+* refresh replaces this list at startup; it exists so the provider registers
+* with a usable catalog even while the first fetch is in flight or offline.
+*/
+const FALLBACK_WORKBUDDY_MODELS = [
+	{
+		id: "auto",
+		name: "Auto",
+		contextWindow: 168e3,
+		maxTokens: 32e3
+	},
+	{
+		id: "hy3",
+		name: "Hy3",
+		contextWindow: 192e3,
+		maxTokens: 64e3
+	},
+	{
+		id: "glm-5v-turbo",
+		name: "GLM-5v-Turbo",
+		contextWindow: 2e5,
+		maxTokens: 64e3
+	},
+	{
+		id: "glm-5.3",
+		name: "GLM-5.3",
+		contextWindow: 1e6,
+		maxTokens: 48e3
+	},
+	{
+		id: "glm-5.2",
+		name: "GLM-5.2",
+		contextWindow: 1e6,
+		maxTokens: 48e3
+	},
+	{
+		id: "glm-5.1",
+		name: "GLM-5.1",
+		contextWindow: 2e5,
+		maxTokens: 48e3
+	},
+	{
+		id: "minimax-m3",
+		name: "MiniMax-M3",
+		contextWindow: 512e3,
+		maxTokens: 128e3
+	},
+	{
+		id: "kimi-k3-1",
+		name: "Kimi-K3",
+		contextWindow: 1e6,
+		maxTokens: 32e3
+	},
+	{
+		id: "kimi-k2.7",
+		name: "Kimi-K2.7-Code",
+		contextWindow: 256e3,
+		maxTokens: 32e3
+	},
+	{
+		id: "kimi-k2.6",
+		name: "Kimi-K2.6",
+		contextWindow: 256e3,
+		maxTokens: 32e3
+	},
+	{
+		id: "deepseek-v4-flash",
+		name: "Deepseek-V4-Flash",
+		contextWindow: 1e6,
+		maxTokens: 5e4
+	},
+	{
+		id: "deepseek-v4-pro",
+		name: "Deepseek-V4-Pro",
+		contextWindow: 1e6,
+		maxTokens: 5e4
+	}
+];
+/** Apply the saved local DSH budget; models above 200K default to 200K. */
+function applyContextBudgets(catalog, budgets = {}) {
+	return catalog.map((model) => ({
+		...model,
+		contextWindow: model.contextWindow > 2e5 ? Math.min(model.contextWindow, budgets[model.id] ?? 2e5) : model.contextWindow
+	}));
+}
+function deriveCatalog(catalog, enabled, budgets = {}) {
+	return applyContextBudgets(enabled.size === 0 ? catalog : catalog.filter((model) => enabled.has(model.id)), budgets);
+}
+/** Mutable catalog shared by the shim's `/v1/models` and the adapter. */
+var WorkBuddyCatalog = class {
+	models = FALLBACK_WORKBUDDY_MODELS;
+	/** Current entries; the fallback list until the upstream answer lands. */
+	current() {
+		return this.models;
+	}
+	/** Replace the list; callers invalidate their adapter snapshot after this. */
+	set(models) {
+		if (models.length === 0) throw new Error("workbuddy model catalog cannot be empty");
+		this.models = models.map((model) => ({ ...model }));
+	}
+};
+//#endregion
+//#region src/upstream.ts
+const CN_CHAT_BASE = "https://copilot.tencent.com";
+const CN_BILLING_BASE = "https://www.codebuddy.cn";
+const GLOBAL_BASE = "https://www.workbuddy.ai";
+const CLIENT_UA = "CLI/2.63.2 CodeBuddy/2.63.2";
+const JSON_TIMEOUT_MS = 3e4;
+const ERROR_BODY_LIMIT = 4096;
+/** Insufficient-credit markers, ASCII lowercase plus the original Chinese. */
+const HARD_CREDIT_MARKERS = [
+	"insufficient credit",
+	"no credit",
+	"credit exhausted",
+	"out of credit",
+	"quota exceeded",
+	"quota exhaust",
+	"payment required",
+	"credit not enough",
+	"not enough credit",
+	"积分不足",
+	"额度不足",
+	"余额不足",
+	"积分用完",
+	"额度用尽",
+	"没有积分"
+];
+/** Session-invalidation markers that mean "sign in again in the WorkBuddy app". */
+const SESSION_DEAD_MARKERS = ["Offline user session not found", "12153"];
+/** Classify an upstream failure from its HTTP status and body excerpt. */
+function classifyUpstreamError(status, body) {
+	if (status === 402) return "hard_credit";
+	const lower = body.toLowerCase();
+	for (const marker of HARD_CREDIT_MARKERS) if (lower.includes(marker.toLowerCase()) || body.includes(marker)) return "hard_credit";
+	for (const marker of SESSION_DEAD_MARKERS) if (body.includes(marker)) return "session_dead";
+	if (status === 429) return "soft_rate";
+	if (status === 404) return "not_found";
+	if (status >= 500) return "server";
+	if (status >= 400) return "client";
+	return "client";
+}
+/** Region for a login domain; an empty domain means CN (matching upstream tooling). */
+function regionOf(domain) {
+	const lowered = domain.trim().toLowerCase();
+	if (lowered === "workbuddy.ai" || lowered.endsWith(".workbuddy.ai")) return "global";
+	return "cn";
+}
+function chatBase(credential) {
+	return regionOf(credential.domain) === "global" ? GLOBAL_BASE : CN_CHAT_BASE;
+}
+function billingBase(credential) {
+	return regionOf(credential.domain) === "global" ? GLOBAL_BASE : CN_BILLING_BASE;
+}
+function originReferer(credential) {
+	return regionOf(credential.domain) === "global" ? GLOBAL_BASE : CN_BILLING_BASE;
+}
+/** Headers every upstream request shares. */
+function commonHeaders(credential) {
+	return {
+		"Accept": "application/json, text/plain, */*",
+		"X-Requested-With": "XMLHttpRequest",
+		"Origin": originReferer(credential),
+		"Referer": `${originReferer(credential)}/`,
+		"User-Agent": CLIENT_UA
+	};
+}
+/** Chat request headers, including the X-No-* conventions the official CLI uses. */
+function chatHeaders(credential) {
+	return {
+		...commonHeaders(credential),
+		"Content-Type": "application/json",
+		...credential.uid === "" ? { "X-No-User-Id": "1" } : { "X-User-Id": credential.uid },
+		...credential.enterpriseId === void 0 || credential.enterpriseId === "" ? { "X-No-Enterprise-Id": "1" } : { "X-Enterprise-Id": credential.enterpriseId },
+		...credential.domain === "" ? { "X-No-Department-Info": "1" } : { "X-Domain": credential.domain },
+		"X-Product": "SaaS"
+	};
+}
+/** Refresh-endpoint headers; X-Refresh-Token appears here and nowhere else. */
+function refreshHeaders(credential) {
+	const headers = {
+		...commonHeaders(credential),
+		"X-Refresh-Token": credential.refreshToken,
+		"X-Auth-Refresh-Source": "workbuddy"
+	};
+	if (credential.enterpriseId !== void 0 && credential.enterpriseId !== "") headers["X-Enterprise-Id"] = credential.enterpriseId;
+	return headers;
+}
+/** Billing request headers. */
+function billingHeaders(credential) {
+	const headers = {
+		"Authorization": `Bearer ${credential.accessToken}`,
+		"Accept": "application/json",
+		"Content-Type": "application/json"
+	};
+	if (credential.uid !== "") headers["X-User-Id"] = credential.uid;
+	if (credential.enterpriseId !== void 0 && credential.enterpriseId !== "") {
+		headers["X-Enterprise-Id"] = credential.enterpriseId;
+		headers["X-Tenant-Id"] = credential.enterpriseId;
+	}
+	if (credential.domain !== "") headers["X-Domain"] = credential.domain;
+	return headers;
+}
+/**
+* Normalize an OpenAI chat-completions body for the WorkBuddy upstream:
+* force `stream: true` (the upstream rejects non-streaming) and flatten
+* `tool_choice` (the upstream's field is a string; object forms return 400).
+*/
+function prepareChatBody(source) {
+	let body;
+	try {
+		body = JSON.parse(source);
+	} catch {
+		return source;
+	}
+	if (typeof body !== "object" || body === null || Array.isArray(body)) return source;
+	const obj = body;
+	obj["stream"] = true;
+	if (Array.isArray(obj["messages"])) for (const value of obj["messages"]) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+		const message = value;
+		if (message["role"] === "developer") message["role"] = "system";
+	}
+	normalizeToolChoice(obj);
+	return JSON.stringify(obj);
+}
+/** Rewrite OpenAI `tool_choice` spellings into the upstream's string form. */
+function normalizeToolChoice(obj) {
+	const suppress = () => {
+		delete obj["tools"];
+		delete obj["functions"];
+	};
+	if (!("tool_choice" in obj)) return;
+	const choice = obj["tool_choice"];
+	if (typeof choice === "string") {
+		if (choice.trim().toLowerCase() === "none") {
+			delete obj["tool_choice"];
+			suppress();
+		}
+		return;
+	}
+	if (typeof choice === "object" && choice !== null && !Array.isArray(choice)) {
+		const wrapped = choice;
+		const type = typeof wrapped["type"] === "string" ? wrapped["type"].trim().toLowerCase() : "";
+		if (type === "none") {
+			delete obj["tool_choice"];
+			suppress();
+		} else if (type === "auto" || type === "required") obj["tool_choice"] = type;
+		else if (type === "function") {
+			const fn = typeof wrapped["function"] === "object" && wrapped["function"] !== null ? wrapped["function"] : void 0;
+			let name = typeof fn?.["name"] === "string" ? fn["name"] : "";
+			if (name === "" && typeof wrapped["name"] === "string") name = wrapped["name"];
+			name = name.trim();
+			obj["tool_choice"] = name !== "" ? name : "auto";
+		} else delete obj["tool_choice"];
+		return;
+	}
+	delete obj["tool_choice"];
+}
+async function readEnvelope(response) {
+	const text = await response.text();
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new Error(`workbuddy upstream returned non-JSON (http ${response.status}): ${text.slice(0, 160)}`);
+	}
+	if (typeof parsed !== "object" || parsed === null) throw new Error(`workbuddy upstream returned an unexpected document (http ${response.status})`);
+	const document = parsed;
+	return {
+		code: typeof document["code"] === "number" ? document["code"] : 0,
+		msg: typeof document["msg"] === "string" ? document["msg"] : "",
+		data: "data" in document ? document["data"] : void 0
+	};
+}
+/** Fail an envelope whose business code is non-zero, classified like HTTP errors. */
+function envelopeError(status, envelope) {
+	const kind = classifyUpstreamError(status, envelope.msg);
+	return /* @__PURE__ */ new Error(`workbuddy upstream ${kind} (http ${status}): ${envelope.msg.slice(0, 160)}`);
+}
+/**
+* Parse the upstream's `credits` string into a multiplier.
+*
+* Observed forms: `"x0.79 credits"`, `"x0.05"`, `"x0.00 credits"`,
+* and absent. Unparsable values yield undefined rather than a guess — the
+* card simply omits the rate instead of displaying a fabricated one.
+*/
+function parseCreditMultiplier(value) {
+	if (typeof value !== "string") return void 0;
+	const match = /x\s*([0-9]*\.?[0-9]+)/iu.exec(value);
+	if (match === null) return void 0;
+	const parsed = Number(match[1]);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+/** Parse the upstream's `reasoning` object; unknown shapes degrade to `{}`. */
+function parseReasoning(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const raw = value;
+	const supportedEfforts = Array.isArray(raw["supportedEfforts"]) ? raw["supportedEfforts"].filter((effort) => typeof effort === "string") : void 0;
+	const defaultEffort = typeof raw["defaultEffort"] === "string" ? raw["defaultEffort"] : void 0;
+	const canDisableThinking = typeof raw["canDisableThinking"] === "boolean" ? raw["canDisableThinking"] : void 0;
+	if (supportedEfforts === void 0 && defaultEffort === void 0 && canDisableThinking === void 0) return;
+	return {
+		...supportedEfforts === void 0 || supportedEfforts.length === 0 ? {} : { supportedEfforts },
+		...defaultEffort === void 0 ? {} : { defaultEffort },
+		...canDisableThinking === void 0 ? {} : { canDisableThinking }
+	};
+}
+/** Parse one catalog entry; entries without usable token limits are dropped. */
+function parseUpstreamModel(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const raw = value;
+	const id = typeof raw["id"] === "string" ? raw["id"] : "";
+	if (id === "" || raw["disabled"] === true) return void 0;
+	const input = typeof raw["maxInputTokens"] === "number" ? raw["maxInputTokens"] : 0;
+	const output = typeof raw["maxOutputTokens"] === "number" ? raw["maxOutputTokens"] : 0;
+	if (input <= 0 || output <= 0) return void 0;
+	const name = typeof raw["name"] === "string" && raw["name"] !== "" ? raw["name"] : id;
+	const descriptionZh = typeof raw["descriptionZh"] === "string" && raw["descriptionZh"] !== "" ? raw["descriptionZh"] : void 0;
+	const descriptionEn = typeof raw["descriptionEn"] === "string" && raw["descriptionEn"] !== "" ? raw["descriptionEn"] : void 0;
+	const creditMultiplier = parseCreditMultiplier(raw["credits"]);
+	const reasoning = parseReasoning(raw["reasoning"]);
+	const supportsToolCall = typeof raw["supportsToolCall"] === "boolean" ? raw["supportsToolCall"] : void 0;
+	return {
+		id,
+		name,
+		contextWindow: input,
+		maxTokens: output,
+		...creditMultiplier === void 0 ? {} : { creditMultiplier },
+		...reasoning === void 0 ? {} : { reasoning },
+		...descriptionZh === void 0 ? {} : { descriptionZh },
+		...descriptionEn === void 0 ? {} : { descriptionEn },
+		...supportsToolCall === void 0 ? {} : { supportsToolCall }
+	};
+}
+/**
+* Upstream HTTP client. One instance serves the whole plugin; requests take
+* the credential explicitly so token refreshes apply on the next call.
+*/
+var WorkBuddyUpstreamClient = class {
+	/** POST the chat endpoint; a successful answer is the raw SSE response. */
+	async chatStream(credential, bodyJson, signal) {
+		let response;
+		try {
+			response = await fetch(`${chatBase(credential)}/v2/chat/completions`, {
+				method: "POST",
+				headers: {
+					...chatHeaders(credential),
+					"Authorization": `Bearer ${credential.accessToken}`
+				},
+				body: bodyJson,
+				...signal === void 0 ? {} : { signal }
+			});
+		} catch (error) {
+			return {
+				ok: false,
+				status: 0,
+				kind: "server",
+				message: `transport error: ${String(error)}`
+			};
+		}
+		if (response.ok) return {
+			ok: true,
+			response
+		};
+		const text = (await response.text()).slice(0, ERROR_BODY_LIMIT);
+		return {
+			ok: false,
+			status: response.status,
+			kind: classifyUpstreamError(response.status, text),
+			message: text
+		};
+	}
+	/** POST the token-refresh endpoint; the caller merges the outcome. */
+	async refreshToken(credential) {
+		const response = await fetch(`${chatBase(credential)}/v2/plugin/auth/token/refresh`, {
+			method: "POST",
+			headers: refreshHeaders(credential),
+			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 accessToken = typeof data["accessToken"] === "string" ? data["accessToken"] : "";
+		if (accessToken === "") throw new Error("workbuddy token refresh returned no accessToken; sign in again in the WorkBuddy app");
+		const outcome = { accessToken };
+		if (typeof data["refreshToken"] === "string" && data["refreshToken"] !== "") outcome.refreshToken = data["refreshToken"];
+		if (typeof data["expiresIn"] === "number" && data["expiresIn"] > 0) outcome.expiresInSec = data["expiresIn"];
+		if (typeof data["domain"] === "string" && data["domain"] !== "") outcome.domain = data["domain"];
+		return outcome;
+	}
+	/**
+	* GET the personal model catalog and keep the `cli` agent's models only,
+	* preserving the capability fields the plugin card displays.
+	*/
+	async fetchModels(credential, signal) {
+		const response = await fetch(`${chatBase(credential)}/console/enterprises/personal/models`, {
+			headers: {
+				"Authorization": `Bearer ${credential.accessToken}`,
+				"Accept": "application/json",
+				"Origin": originReferer(credential),
+				"Referer": `${originReferer(credential)}/`,
+				"User-Agent": CLIENT_UA
+			},
+			signal: 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 rawModels = Array.isArray(data["models"]) ? data["models"] : [];
+		const agents = Array.isArray(data["agents"]) ? data["agents"] : [];
+		let cliIds;
+		for (const agent of agents) if (typeof agent === "object" && agent !== null) {
+			const wrapped = agent;
+			if (wrapped["name"] === "cli" && Array.isArray(wrapped["models"])) {
+				cliIds = wrapped["models"].filter((id) => typeof id === "string");
+				break;
+			}
+		}
+		const byId = /* @__PURE__ */ new Map();
+		for (const model of rawModels) {
+			const parsed = parseUpstreamModel(model);
+			if (parsed !== void 0) byId.set(parsed.id, parsed);
+		}
+		const models = (cliIds !== void 0 && cliIds.length > 0 ? cliIds : [...byId.keys()]).map((id) => byId.get(id)).filter((model) => model !== void 0);
+		if (models.length === 0) throw new Error("workbuddy model catalog resolved to an empty list");
+		return models;
+	}
+	/** Query today's check-in status without changing account state. */
+	async fetchCheckinStatus(credential) {
+		const response = await fetch(`${billingBase(credential)}/v2/billing/meter/checkin-activity-status`, {
+			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;
+		return {
+			active: data["active"] === true,
+			todayCheckedIn: data["today_checked_in"] === true,
+			streakDays: numberField("streak_days"),
+			dailyCredit: numberField("daily_credit"),
+			todayCredit: numberField("today_credit"),
+			isStreakDay: data["is_streak_day"] === true,
+			nextStreakDay: numberField("next_streak_day"),
+			streakBonusDays: numberField("streak_bonus_days"),
+			streakBonusCredit: numberField("streak_bonus_credit"),
+			...typeof data["claim_button_text"] === "string" && data["claim_button_text"] !== "" ? { claimButtonText: data["claim_button_text"] } : {}
+		};
+	}
+	/** 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`, {
+			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;
+		return {
+			credit: numberField("credit"),
+			streakDays: numberField("streak_days"),
+			isStreakDay: data["is_streak_day"] === true
+		};
+	}
+	/**
+	* POST the billing endpoint for the remaining credit, keeping every package
+	* separate: the card groups monthly-cycle packages itself and lists the
+	* nearest-expiring one-off packages, so aggregation here would lose the
+	* dates it needs.
+	*/
+	async fetchCredits(credential) {
+		const now = /* @__PURE__ */ new Date();
+		const format = (date) => [
+			date.getFullYear().toString().padStart(4, "0"),
+			(date.getMonth() + 1).toString().padStart(2, "0"),
+			date.getDate().toString().padStart(2, "0")
+		].join("-") + " " + [
+			date.getHours().toString().padStart(2, "0"),
+			date.getMinutes().toString().padStart(2, "0"),
+			date.getSeconds().toString().padStart(2, "0")
+		].join(":");
+		const response = await fetch(`${billingBase(credential)}/v2/billing/meter/get-user-resource`, {
+			method: "POST",
+			headers: billingHeaders(credential),
+			body: JSON.stringify({
+				PageNumber: 1,
+				PageSize: 100,
+				ProductCode: "p_tcaca",
+				Status: [0, 3],
+				PackageEndTimeRangeBegin: format(now),
+				PackageEndTimeRangeEnd: format(new Date(now.getTime() + 3185136e6))
+			}),
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+		const responseWrapper = typeof envelope.data === "object" && envelope.data !== null ? envelope.data : {};
+		const data = typeof responseWrapper["Response"] === "object" && responseWrapper["Response"] !== null ? responseWrapper["Response"] : {};
+		const inner = typeof data["Data"] === "object" && data["Data"] !== null ? data["Data"] : {};
+		const rawAccounts = Array.isArray(inner["Accounts"]) ? inner["Accounts"] : [];
+		let total = 0;
+		let nearestExpiryMs;
+		let expiringSoon = 0;
+		const SOON_MS = 2592e5;
+		const parseDate = (raw) => {
+			if (typeof raw === "number" && raw > 0xe8d4a51000) return raw;
+			if (typeof raw === "string" && raw !== "") {
+				const parsed = Date.parse(raw);
+				if (!Number.isNaN(parsed)) return parsed;
+			}
+		};
+		const packages = [];
+		for (const raw of rawAccounts) {
+			if (typeof raw !== "object" || raw === null) continue;
+			const account = raw;
+			const numberField = (key) => typeof account[key] === "number" ? account[key] : 0;
+			const monthly = numberField("CapacityType") === 4;
+			const size = monthly ? numberField("CycleCapacitySize") : numberField("CapacitySize");
+			const remain = monthly ? numberField("CycleCapacityRemain") : numberField("CapacityRemain");
+			const cappedRemain = remain < 0 ? 0 : remain;
+			const cycleEndMs = parseDate(account["CycleEndTime"]);
+			const expiresAtMs = monthly ? void 0 : parseDate(account["ExpiredTime"]) ?? cycleEndMs;
+			const refreshAtMs = monthly ? cycleEndMs === void 0 ? void 0 : cycleEndMs + 1e3 : void 0;
+			if (!monthly && (cappedRemain <= 0 || expiresAtMs !== void 0 && expiresAtMs <= Date.now())) continue;
+			total += cappedRemain;
+			const expiryMs = expiresAtMs;
+			if (expiryMs !== void 0) {
+				if (nearestExpiryMs === void 0 || expiryMs < nearestExpiryMs) nearestExpiryMs = expiryMs;
+				if (expiryMs - Date.now() <= SOON_MS) expiringSoon += cappedRemain;
+			}
+			packages.push({
+				packageName: typeof account["PackageName"] === "string" ? account["PackageName"] : "(unnamed)",
+				remain: cappedRemain,
+				size,
+				monthly,
+				...refreshAtMs === void 0 ? {} : { refreshAtMs },
+				...expiresAtMs === void 0 ? {} : { expiresAtMs }
+			});
+		}
+		return {
+			total,
+			packages,
+			expiringSoon,
+			...nearestExpiryMs === void 0 ? {} : { nearestExpiryMs }
+		};
+	}
+};
+//#endregion
+//#region src/version.ts
+/** The npm package version this build was produced from. */
+const WORKBUDDY_CONNECT_VERSION = "1.0.0";
+//#endregion
+//#region src/host-heartbeat.ts
+/**
+* Host-side heartbeat: a small JSON file written under `$DSH_HOME` once the
+* `workbuddy` provider is registered. The status CLI reads it to report
+* whether the host bundle is alive, independent of the browser card.
+*
+* 参考：corrinehu/dsh-workbuddy-connect（MIT，Copyright (c) 2026 Corrine Hu）
+*   — 该机制由其设计：浏览器端无法写文件，其健康只能靠 console.error 上报，
+*     因此由宿主写心跳文件，缺失即代表宿主从未启动；崩溃后的陈旧心跳
+*     通过 PID 存活检查识别。
+* 改动：无。机制本身已完备，原样沿用。
+*
+* @module dsh-connect-workbuddy/host-heartbeat
+*/
+/** Basename of the host heartbeat file inside the Harness home. */
+const WORKBUDDY_HOST_HEARTBEAT_FILENAME = ".workbuddy-host-heartbeat.json";
+/** Current on-disk heartbeat format; readers reject others. */
+const HEARTBEAT_FORMAT_VERSION = 1;
+/** Absolute path of the host heartbeat file. */
+function workbuddyHostHeartbeatPath() {
+	return join(resolveDshHome(), WORKBUDDY_HOST_HEARTBEAT_FILENAME);
+}
+/**
+* Process start time in epoch milliseconds; undefined when unavailable.
+*
+* POSIX reads `ps -o lstart=`; Windows has no such command, so the creation
+* time is taken from PowerShell's `Get-Process` StartTime, emitted as UTC ISO
+* 8601 so `Date.parse` understands it without locale assumptions. Absent or
+* unqueryable processes (other users' processes) degrade to undefined.
+*/
+function processStartTimeMs(pid) {
+	try {
+		const output = process.platform === "win32" ? execFileSync("powershell", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			`(Get-Process -Id ${pid} -ErrorAction SilentlyContinue).StartTime.ToUniversalTime().ToString('o')`
+		], { encoding: "utf8" }) : execFileSync("ps", [
+			"-o",
+			"lstart=",
+			"-p",
+			String(pid)
+		], { encoding: "utf8" });
+		const parsed = Date.parse(output.trim());
+		return Number.isFinite(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Whether the recorded host process still matches the heartbeat's PID.
+*
+* A PID can be reused after a crash, so the recorded start time is compared
+* against the live process: a different start time means a different process.
+*/
+function isHeartbeatProcessAlive(heartbeat) {
+	if (!Number.isInteger(heartbeat.pid) || heartbeat.pid <= 0) return false;
+	try {
+		process.kill(heartbeat.pid, 0);
+	} catch {
+		return false;
+	}
+	const startedAt = processStartTimeMs(heartbeat.pid);
+	if (startedAt === void 0) return true;
+	return Math.abs(startedAt - heartbeat.registeredAt) < 6e4;
+}
+/** Read the heartbeat; absent or unparsable files report undefined. */
+async function readHostHeartbeat() {
+	try {
+		const parsed = JSON.parse(await readFile(workbuddyHostHeartbeatPath(), "utf8"));
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const document = parsed;
+		if (document["version"] !== HEARTBEAT_FORMAT_VERSION) return void 0;
+		if (document["package"] !== "dsh-connect-workbuddy") return void 0;
+		const pid = document["pid"];
+		const registeredAt = document["registeredAt"];
+		if (typeof pid !== "number" || typeof registeredAt !== "number") return void 0;
+		return {
+			version: HEARTBEAT_FORMAT_VERSION,
+			package: "dsh-connect-workbuddy",
+			pluginVersion: typeof document["pluginVersion"] === "string" ? document["pluginVersion"] : WORKBUDDY_CONNECT_VERSION,
+			registeredAt,
+			pid
+		};
+	} catch {
+		return;
+	}
+}
+/** Write the heartbeat for the current process. */
+async function writeHostHeartbeat() {
+	const heartbeat = {
+		version: HEARTBEAT_FORMAT_VERSION,
+		package: "dsh-connect-workbuddy",
+		pluginVersion: WORKBUDDY_CONNECT_VERSION,
+		registeredAt: Date.now(),
+		pid: process.pid
+	};
+	await writeFile(workbuddyHostHeartbeatPath(), `${JSON.stringify(heartbeat, null, 2)}\n`, { mode: 384 });
+}
+/** Remove the heartbeat; called when the plugin is disposed. */
+async function clearHostHeartbeat() {
+	await rm(workbuddyHostHeartbeatPath(), { force: true });
+}
+//#endregion
+export { defaultDesktopAuthCandidates as C, workbuddyAccountId as D, parseWorkBuddyAuth as E, workbuddyOwnAuthPath as O, authFileName as S, defaultDesktopAuthPath as T, WorkBuddyCatalog as _, readHostHeartbeat as a, WORKBUDDY_AUTH_FILE_ENV as b, WORKBUDDY_CONNECT_VERSION as c, parseCreditMultiplier as d, parseReasoning as f, FALLBACK_WORKBUDDY_MODELS as g, regionOf as h, processStartTimeMs as i, WorkBuddyUpstreamClient as l, prepareChatBody as m, clearHostHeartbeat as n, workbuddyHostHeartbeatPath as o, parseUpstreamModel as p, isHeartbeatProcessAlive as r, writeHostHeartbeat as s, WORKBUDDY_HOST_HEARTBEAT_FILENAME as t, classifyUpstreamError as u, deriveCatalog as v, defaultDesktopAuthDirs as w, WorkBuddyCredentialStore as x, WORKBUDDY_AUTH_FILENAME as y };