dsh-connect-workbuddy 2.0.5 → 2.0.10

package/lib/index.js

@@ -1,4 +1,4 @@
-import { A as prepareChatBody, C as workbuddyAccountId, D as parseCreditMultiplier, E as classifyUpstreamError, O as parseReasoning, S as parseWorkBuddyAuth, T as WorkBuddyUpstreamClient, _ as authFileName, a as readHostHeartbeat, b as defaultDesktopAuthPath, c as WORKBUDDY_CONNECT_VERSION, d as WorkBuddyCatalog, f as deriveCatalog, g as WorkBuddyCredentialStore, h as WORKBUDDY_AUTH_FILE_ENV, i as processStartTimeMs, j as regionOf, k as parseUpstreamModel, l as FALLBACK_WORKBUDDY_MODELS, m as WORKBUDDY_AUTH_FILENAME, n as clearHostHeartbeat, o as workbuddyHostHeartbeatPath, p as fallbackModelsFor, r as isHeartbeatProcessAlive, s as writeHostHeartbeat, t as WORKBUDDY_HOST_HEARTBEAT_FILENAME, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, v as defaultDesktopAuthCandidates, w as workbuddyOwnAuthPath, x as legacyWorkbuddyOwnAuthPath, y as defaultDesktopAuthDirs } from "./host-heartbeat-BOrNj3pY.js";
+import { A as isCredentialRejectedError, B as fetchAtRestKeyPayload, C as parseWorkBuddyAuth, D as WorkBuddyCredentialRejectedError, E as CREDENTIAL_REJECTED_CODE, F as regionOf, G as workbuddyAppExecutableCandidates, H as isEncryptedFieldWrapper, I as WORKBUDDY_APP_EXECUTABLE_ENV, L as clearAtRestKeyCache, M as parseReasoning, N as parseUpstreamModel, O as WorkBuddyUpstreamClient, P as prepareChatBody, R as deriveAtRestKey, S as legacyWorkbuddyOwnAuthPath, T as workbuddyOwnAuthPath, U as openEncryptedField, V as findWorkbuddyAppExecutable, W as readAtRestKey, _ as authFileName, a as readHostHeartbeat, b as defaultDesktopAuthPath, c as WORKBUDDY_CONNECT_VERSION, d as WorkBuddyCatalog, f as deriveCatalog, g as WorkBuddyCredentialStore, h as WORKBUDDY_AUTH_FILE_ENV, i as processStartTimeMs, j as parseCreditMultiplier, k as classifyUpstreamError, l as FALLBACK_WORKBUDDY_MODELS, m as WORKBUDDY_AUTH_FILENAME, n as clearHostHeartbeat, o as workbuddyHostHeartbeatPath, p as fallbackModelsFor, r as isHeartbeatProcessAlive, s as writeHostHeartbeat, t as WORKBUDDY_HOST_HEARTBEAT_FILENAME, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, v as defaultDesktopAuthCandidates, w as workbuddyAccountId, x as hasEncryptedCredentialFields, y as defaultDesktopAuthDirs, z as deriveAtRestKeyId } from "./host-heartbeat-DPbL9oi2.js";
 import z from "@deepseek-ai/schemastery";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createProvider } from "@earendil-works/pi-ai";
@@ -7,6 +7,76 @@ import { resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
 import { createServer } from "node:http";
 import { Readable } from "node:stream";
+//#region src/credential-recovery.ts
+/** How long a verdict stays fresh by default. */
+const DEFAULT_PROBE_TTL_MS = 6e4;
+/**
+* Cached "is this account still accepted upstream?" probe.
+*
+* The cache key includes the credential's own `lastRefreshAtMs`, so a fresh
+* sign-in (which rewrites the file's issuance time) invalidates a stale verdict
+* automatically — a rejection recorded before the user signed in again cannot
+* keep labelling the account unusable afterwards, and no explicit invalidation
+* is needed.
+*/
+function createAccountUsabilityProbe(options) {
+	const ttlMs = options.ttlMs ?? DEFAULT_PROBE_TTL_MS;
+	const now = options.now ?? Date.now;
+	const verdicts = /* @__PURE__ */ new Map();
+	return async (region, account) => {
+		let credential;
+		try {
+			credential = await options.store(region).credentialFor(account.id);
+		} catch {
+			return false;
+		}
+		if (credential === void 0) return false;
+		const key = `${region}\0${account.id}\0${credential.lastRefreshAtMs ?? credential.expiresAtMs}`;
+		const cached = verdicts.get(key);
+		if (cached !== void 0 && now() - cached.at < ttlMs) return cached.usable;
+		let usable = false;
+		try {
+			await options.client.fetchCheckinStatus(credential);
+			usable = true;
+		} catch {
+			usable = false;
+		}
+		verdicts.set(key, {
+			at: now(),
+			usable
+		});
+		return usable;
+	};
+}
+/**
+* Decide what to tell the user after the upstream refused the selected
+* credential: switch to a verified-usable account, or sign in again.
+*
+* The two answers are mutually exclusive by construction. `reloginRequired` is
+* set ONLY when there is no other local account to switch to — never as a
+* fallback for "the probe did not verify anything", because that would repeat
+* the misdirection this module exists to remove. When other accounts exist but
+* none was verified, both fields stay empty and the card says so honestly.
+*/
+async function resolveCredentialRecovery(options) {
+	let accounts;
+	try {
+		accounts = await options.store.accounts();
+	} catch {
+		return { reloginRequired: false };
+	}
+	const others = accounts.filter((account) => account.id !== options.rejectedAccountId);
+	if (others.length === 0) return { reloginRequired: true };
+	for (const account of others) if (await options.probe(options.region, account)) return {
+		usableAccount: {
+			accountId: account.id,
+			accountName: account.accountName
+		},
+		reloginRequired: false
+	};
+	return { reloginRequired: false };
+}
+//#endregion
 //#region src/adapter.ts
 /**
 * The WorkBuddy pi-ai providers: loopback-backed adapters registered
@@ -467,6 +537,69 @@ function regionOfStatusUrl(url) {
 	return WORKBUDDY_REGIONS.includes(value) ? value : void 0;
 }
 /**
+* Narrow a settings value to the `regions` map. Accepts EITHER the whole
+* settings section (the Host's resolved `Config`) OR the `regions` map itself,
+* and unwraps the former. This tolerance is deliberate: passing the whole
+* section where the map was expected was a real shipped bug in the sibling
+* project — the lookup then read `section['cn']` (absent), so the card's
+* checkbox reported `true` forever and clicking it appeared to do nothing even
+* though the write succeeded.
+*/
+function regionsMapOf(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	const record = value;
+	const nested = record["regions"];
+	if (typeof nested === "object" && nested !== null && !Array.isArray(nested)) return nested;
+	return record;
+}
+/** One region's stored slot as a plain object; any other shape reads as empty. */
+function regionSlotOf(value, region) {
+	const slot = regionsMapOf(value)[region];
+	return typeof slot === "object" && slot !== null && !Array.isArray(slot) ? slot : {};
+}
+/**
+* Whether one region's provider is switched on. Opt-out semantics: only an
+* explicit `false` disables it, so a config written before this switch existed
+* (and the pre-region-split flat fields, which never carry `enabled`) keep both
+* providers running exactly as before. The Host reads the same rule through
+* `regionStateOf`, so card and Host can never disagree about a region's state.
+*
+* `value` may be the whole settings section or the `regions` map (see
+* {@link regionsMapOf}).
+*/
+function regionEnabledOf(value, region) {
+	return regionSlotOf(value, region)["enabled"] !== false;
+}
+/** Build the next `regions` settings value for a signed-in tab's save. */
+function nextRegionSlots(regions, region, slot) {
+	return {
+		...typeof regions === "object" && regions !== null && !Array.isArray(regions) ? regions : {},
+		[region]: slot
+	};
+}
+/**
+* Build the next `regions` settings value for a provider on/off toggle. ONLY
+* the target region's `enabled` flag changes: every other field of that slot
+* (its directory, selection, image opt-ins, context budgets) and every other
+* region's slot are carried over verbatim, so switching a provider off never
+* discards the user's model picks and switching it back on restores them.
+*
+* This is deliberately separate from {@link nextRegionSlots}: that helper
+* writes a whole slot from a signed-in tab's draft, while this one must work
+* for a region that is signed OUT — which is precisely the region a user wants
+* to switch off (no international install, no international account).
+*
+* `value` may be the whole settings section or the `regions` map; the RETURN
+* value is always the `regions` map, i.e. exactly what `settingsScope.set(
+* 'regions', ...)` needs.
+*/
+function nextRegionEnabled(value, region, enabled) {
+	return nextRegionSlots(regionsMapOf(value), region, {
+		...regionSlotOf(value, region),
+		enabled
+	});
+}
+/**
 * Project one card row into its persisted `lastCatalog` shape: the native
 * context window becomes the stored `contextWindow`, and the card-only
 * presentation fields (`nativeContextWindow`, `multimodal`) are removed BY
@@ -539,12 +672,18 @@ function toWebModel(model, budgets) {
 		} }
 	};
 }
-/** Project a store account into the card's token-free account row. */
+/**
+* Project a store account into the card's token-free account row.
+*
+* `uin` is deliberately NOT forwarded: the card has never rendered it, so
+* sending it was pure exposure of an account identifier for no feature. The
+* name carries whatever the desktop app recorded, and `''` means the card
+* should show its own placeholder rather than an identifier.
+*/
 function toWebAccount(account) {
 	return {
 		id: account.id,
 		accountName: account.accountName,
-		...account.uin === void 0 ? {} : { uin: account.uin },
 		domain: account.domain,
 		source: account.source,
 		tokenExpiresAtMs: account.tokenExpiresAtMs,
@@ -552,6 +691,31 @@ function toWebAccount(account) {
 	};
 }
 /**
+* The probed-path list for a signed-out region, or nothing when the store
+* cannot produce one.
+*
+* Diagnostics must never turn a page into an error: `diagnose()` re-reads the
+* filesystem, and a store built without it (or one whose probe throws on an
+* exotic filesystem) degrades to the plain "not signed in" hint the card showed
+* before this existed. Failure reasons are `safeMessage`d because a raw
+* filesystem error can embed an absolute path or a fragment of file content.
+*/
+async function searchedPaths(store) {
+	if (typeof store.diagnose !== "function") return {};
+	try {
+		const { failures } = await store.diagnose();
+		if (failures.length === 0) return {};
+		return { searched: failures.map((failure) => ({
+			path: failure.path,
+			source: failure.source,
+			reason: failure.reason,
+			...failure.message === void 0 ? {} : { message: safeMessage(failure.message) }
+		})) };
+	} catch {
+		return {};
+	}
+}
+/**
 * Assemble one region's card document. `region` is the tab the card is on;
 * the region-scoped store already answers with only that region's accounts,
 * so the document's model slots and account list are that region's by
@@ -561,45 +725,61 @@ function toWebAccount(account) {
 async function workBuddyWebStatus(deps, region) {
 	const store = deps.store(region);
 	const accounts = await store.accounts();
+	deps.regionUsable?.(region, accounts.length > 0);
+	const enabled = deps.regionEnabled(region);
 	const authStatus = await store.status();
 	const selectionExplicit = store.hasExplicitSelection();
 	if (authStatus.state !== "signed-out" && accounts.length === 0) return {
 		status: "signed-out",
 		accounts: [],
-		selectionExplicit
+		selectionExplicit,
+		enabled
 	};
 	let credential;
 	try {
 		credential = await store.resolve();
 	} catch (error) {
+		const webAccounts = accounts.map(toWebAccount);
 		return {
 			status: "signed-out",
-			accounts: accounts.map(toWebAccount),
+			accounts: webAccounts,
 			message: safeMessage(error),
 			selectionExplicit,
-			...await store.selectionLost() ? { selectionLost: true } : {}
+			enabled,
+			...await store.selectionLost() ? { selectionLost: true } : {},
+			...webAccounts.length === 0 ? await searchedPaths(store) : {}
 		};
 	}
+	const selected = accounts.find((account) => account.selected);
 	const account = {
-		accountId: accounts.find((account) => account.selected)?.id ?? "",
-		accountName: credential.nickname ?? credential.uin ?? credential.uid,
-		...credential.uin === void 0 ? {} : { uin: credential.uin },
+		accountId: selected?.id ?? "",
+		accountName: credential.nickname ?? "",
 		...credential.domain === "" ? {} : { domain: credential.domain },
 		region,
 		source: credential.source,
 		tokenExpiresAtMs: credential.expiresAtMs,
 		selectionExplicit,
+		enabled,
 		accounts: accounts.map(toWebAccount),
 		models: deps.displayModels(region).map((model) => toWebModel(model, deps.contextBudgets(region))),
 		enabledModelIds: [...deps.enabledModelIds(region)],
 		imageModelIds: [...deps.imageModelIds(region)]
 	};
 	const [creditsResult, checkinResult] = await Promise.allSettled([deps.client.fetchCredits(credential), deps.client.fetchCheckinStatus(credential)]);
+	const rejected = [creditsResult, checkinResult].some((result) => result.status === "rejected" && isCredentialRejectedError(result.reason));
+	const recovery = !rejected ? void 0 : await resolveCredentialRecovery({
+		region,
+		store: deps.store(region),
+		...selected === void 0 ? {} : { rejectedAccountId: selected.id },
+		probe: deps.accountUsable ?? (async () => false)
+	});
 	return {
 		status: "signed-in",
 		...account,
 		...creditsResult.status === "fulfilled" ? { credits: toCredits(creditsResult.value) } : { creditsError: safeMessage(creditsResult.reason) },
-		...checkinResult.status === "fulfilled" ? { checkin: checkinResult.value } : { checkinError: safeMessage(checkinResult.reason) }
+		...checkinResult.status === "fulfilled" ? { checkin: checkinResult.value } : { checkinError: safeMessage(checkinResult.reason) },
+		...!rejected ? {} : { credentialRejected: true },
+		...recovery === void 0 ? {} : { recovery }
 	};
 }
 /**
@@ -651,7 +831,9 @@ function registerWorkBuddyStatusRoute(ctx, deps) {
 				const region = requestRegion(req, res);
 				if (region === void 0) return;
 				try {
-					json(res, 200, { accounts: (await deps.store(region).accounts()).map(toWebAccount) });
+					const accounts = await deps.store(region).accounts();
+					deps.regionUsable?.(region, accounts.length > 0);
+					json(res, 200, { accounts: accounts.map(toWebAccount) });
 				} catch (error) {
 					json(res, 500, { error: safeMessage(error) });
 				}
@@ -722,6 +904,7 @@ const modelConfig = z.object({
 	maxTokens: z.number().step(1).min(1)
 });
 const regionStateConfig = z.object({
+	enabled: z.boolean().default(true).description("Whether this region's provider is offered to DSH (opt-out; false withdraws it entirely)"),
 	lastCatalog: z.array(modelConfig).default([]),
 	enabledModelIds: z.array(z.string()).default([]),
 	imageModelIds: z.array(z.string()).default([]),
@@ -761,6 +944,17 @@ function regionStateOf(config, region) {
 		...config.contextBudgets === void 0 ? {} : { contextBudgets: config.contextBudgets }
 	};
 }
+/**
+* Whether one region's provider is switched on. Opt-out semantics: only an
+* explicit `false` disables it, so every config written before this switch
+* existed — including the pre-region-split flat fields, which never carry
+* `enabled` — keeps both providers running exactly as before. The card reads the
+* same rule through `regionEnabledOf`, so the two halves can never disagree
+* about a region's state.
+*/
+function regionEnabled(config, region) {
+	return regionStateOf(config, region).enabled !== false;
+}
 /** Every region, in card tab order. */
 const REGION_KEYS = ["cn", "global"];
 /**
@@ -844,6 +1038,10 @@ function apply(ctx, config) {
 			})
 		};
 	}
+	const accountUsabilityProbe = createAccountUsabilityProbe({
+		store: (region) => stacks[region].store,
+		client
+	});
 	const withImageSelection = (models, images) => models.map((model) => ({
 		...model,
 		...images.has(model.id) ? { multimodal: true } : { multimodal: false }
@@ -879,15 +1077,81 @@ function apply(ctx, config) {
 			stacks[region].catalog.set(configuredModels(value, region));
 		}
 		invalidateCatalog();
+		syncRegionRegistration(value);
+		refreshRegionUsability();
+	};
+	/**
+	* Tell each catalog whether its region has ANY local sign-in, so a region the
+	* user has no account for advertises nothing instead of a roster that can
+	* only 401 (issue #12).
+	*
+	* `accounts()` is the right source rather than the SELECTED credential: an
+	* orphaned saved id must not blank a region that still has other sign-ins to
+	* fall back on, and a region the user deliberately cleared must come back to
+	* life the moment its first account appears.
+	*
+	* Deliberately fire-and-forget and idempotent — it runs on every settings
+	* change, and `setRegionUsable` reports whether anything moved so a
+	* no-change pass costs nothing beyond the scan. A failed scan leaves the
+	* previous answer alone (the catalog starts permissive), so a transient
+	* filesystem error never blanks a working region.
+	*/
+	const refreshRegionUsability = async () => {
+		for (const region of REGION_KEYS) {
+			let accounts;
+			try {
+				accounts = await stacks[region].store.accounts();
+			} catch {
+				continue;
+			}
+			if (stacks[region].catalog.setRegionUsable(accounts.length > 0)) invalidateCatalog();
+		}
+	};
+	/**
+	* Live registration handles per region, filled once the shim is listening.
+	* A disabled region holds ZERO routes while staying registered: DSH allows
+	* `replace([])` for exactly this case ("a settings section that emptied holds
+	* zero routes while staying registered"), which is what makes the on/off
+	* switch reversible without a restart. Withdrawing the adapter route is what
+	* actually removes the region's models from DSH's model picker — hiding the
+	* card tab alone would leave every model selectable.
+	*/
+	const registration = {
+		cn: {},
+		global: {}
+	};
+	/**
+	* Publish each region's on/off state to the harness (issue #11-style region
+	* switch). Both swaps are single synchronous sections, so no request can
+	* observe a half-applied state, and `replace` announces itself through
+	* `llm/adapters-updated`, which is what makes third-party consumers drop the
+	* region too. No-op until the shim has registered; `applySelection` runs again
+	* on every card write (and once more after registration completes), so a
+	* toggle lands immediately.
+	*/
+	const syncRegionRegistration = (value) => {
+		for (const region of REGION_KEYS) registration[region].adapter?.replace(regionEnabled(value, region) ? [WORKBUDDY_PROVIDERS[region]] : []);
+		registration.cn.directory?.replace(REGION_KEYS.filter((region) => regionEnabled(value, region)).map((region) => ({
+			provider: WORKBUDDY_PROVIDERS[region],
+			displayName: WORKBUDDY_PROVIDER_DISPLAY_NAMES[region],
+			settingsNs: WORKBUDDY_SETTINGS_NS,
+			settingsPath: [],
+			declared: false
+		})));
 	};
 	ctx.inject(["webServer"], (webCtx) => registerWorkBuddyStatusRoute(webCtx, {
 		store: (region) => stacks[region].store,
 		client,
+		accountUsable: accountUsabilityProbe,
 		displayModels: (region) => displayModels(current(), region),
 		enabledModelIds: (region) => regionStateOf(current(), region).enabledModelIds ?? [],
 		imageModelIds: (region) => regionStateOf(current(), region).imageModelIds ?? [],
 		contextBudgets: (region) => regionStateOf(current(), region).contextBudgets ?? {},
-		discoverModels
+		discoverModels,
+		regionEnabled: (region) => regionEnabled(current(), region),
+		regionUsable(region, usable) {
+			if (stacks[region].catalog.setRegionUsable(usable)) invalidateCatalog();
+		}
 	}));
 	ctx.settings.installSection(ctx, WORKBUDDY_SETTINGS_NS, Config, config, {
 		setSource(source) {
@@ -931,9 +1195,9 @@ function apply(ctx, config) {
 			let releaseAdapterGlobal;
 			let releaseDirectory;
 			try {
-				releaseAdapterCn = ctx.llm.registerAdapter([WORKBUDDY_PROVIDER], adapters.cn.adapter);
-				releaseAdapterGlobal = ctx.llm.registerAdapter([WORKBUDDY_GLOBAL_PROVIDER], adapters.global.adapter);
-				releaseDirectory = ctx.llm.registerConfigurableProviders([{
+				releaseAdapterCn = registration.cn.adapter = ctx.llm.registerAdapter([WORKBUDDY_PROVIDER], adapters.cn.adapter);
+				releaseAdapterGlobal = registration.global.adapter = ctx.llm.registerAdapter([WORKBUDDY_GLOBAL_PROVIDER], adapters.global.adapter);
+				releaseDirectory = registration.cn.directory = ctx.llm.registerConfigurableProviders([{
 					provider: WORKBUDDY_PROVIDER,
 					displayName: WORKBUDDY_PROVIDER_DISPLAY_NAMES.cn,
 					settingsNs: WORKBUDDY_SETTINGS_NS,
@@ -964,9 +1228,11 @@ function apply(ctx, config) {
 				releaseAdapterGlobal?.();
 				releaseDirectory?.();
 			}
+			syncRegionRegistration(current());
 			ctx.llm.registerModelDiscovery(WORKBUDDY_SETTINGS_NS, async (request, signal) => {
 				const region = regionOfProvider(request.provider ?? "");
 				if (region === void 0) return [];
+				if (!regionEnabled(current(), region)) return [];
 				const discovered = await discoverModels(region, signal);
 				const state = regionStateOf(current(), region);
 				return withImageSelection(deriveCatalog(discovered, new Set(state.enabledModelIds ?? []), state.contextBudgets ?? {}), new Set(state.imageModelIds ?? [])).map((model) => ({
@@ -983,22 +1249,25 @@ function apply(ctx, config) {
 			return;
 		}
 		if (stopped) return;
-		for (const region of REGION_KEYS) (async () => {
-			try {
-				const credential = await stacks[region].store.resolve();
-				if (stopped) return;
-				const models = await client.fetchModels(credential);
-				if (stopped) return;
-				const state = regionStateOf(current(), region);
-				stacks[region].catalog.set(withImageSelection(deriveCatalog(models, new Set(state.enabledModelIds ?? []), state.contextBudgets ?? {}), new Set(state.imageModelIds ?? [])));
-				adapters[region].invalidate();
-			} catch (error) {
-				ctx.logger.warn(`dsh-connect-workbuddy: dynamic ${region} model catalog unavailable; serving the static fallback list`, error);
-			}
-		})();
+		for (const region of REGION_KEYS) {
+			if (!regionEnabled(current(), region)) continue;
+			(async () => {
+				try {
+					const credential = await stacks[region].store.resolve();
+					if (stopped) return;
+					const models = await client.fetchModels(credential);
+					if (stopped) return;
+					const state = regionStateOf(current(), region);
+					stacks[region].catalog.set(withImageSelection(deriveCatalog(models, new Set(state.enabledModelIds ?? []), state.contextBudgets ?? {}), new Set(state.imageModelIds ?? [])));
+					adapters[region].invalidate();
+				} catch (error) {
+					ctx.logger.warn(`dsh-connect-workbuddy: dynamic ${region} model catalog unavailable; serving the static fallback list`, error);
+				}
+			})();
+		}
 	}).catch((error) => {
 		ctx.logger.error("dsh-connect-workbuddy: loopback endpoint failed to start; providers not registered", error);
 	});
 }
 //#endregion
-export { Config, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_USAGE_PATH, WorkBuddyCatalog, WorkBuddyCredentialStore, WorkBuddyUpstreamClient, apply, authFileName, classifyUpstreamError, clearHostHeartbeat, createWorkBuddyAdapter, createWorkBuddyShim, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, deriveCatalog, fallbackModelsFor, inject, isHeartbeatProcessAlive, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, name, parseCreditMultiplier, parseReasoning, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, processStartTimeMs, readHostHeartbeat, regionCleared, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, selectAccountFor, toPersistedWorkBuddyModel, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };
+export { CREDENTIAL_REJECTED_CODE, Config, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_APP_EXECUTABLE_ENV, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_USAGE_PATH, WorkBuddyCatalog, WorkBuddyCredentialRejectedError, WorkBuddyCredentialStore, WorkBuddyUpstreamClient, apply, authFileName, classifyUpstreamError, clearAtRestKeyCache, clearHostHeartbeat, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, inject, isCredentialRejectedError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, name, nextRegionEnabled, nextRegionSlots, openEncryptedField, parseCreditMultiplier, parseReasoning, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, toPersistedWorkBuddyModel, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };

package/package.json

@@ -2,7 +2,7 @@
   "name": "dsh-connect-workbuddy",
   "displayName": "DSH Connect WorkBuddy",
   "description": "Connect locally signed-in WorkBuddy models to DeepSeek Harness with a read-only credits overview and model management.",
-  "version": "2.0.5",
+  "version": "2.0.10",
   "author": "dingminhua",
   "copyright": "Copyright (c) 2026 LaoDing",
   "license": "MIT",