Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(provider-groups): restore cross-region shares on other computers

MagicLizid1baeec8346e
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareCrossRegion.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareCrossRegion.test.ts
index 3fd73857ef..df5d83d107 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareCrossRegion.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareCrossRegion.test.ts
@@ -1,6 +1,6 @@
/**
* 跨区域受邀者(P3):只认两个官方区域;不把本区域 Access Token 发给对方区域,也不会因对方区域的
- * 401 登出本账号;只有发过申请或加入过分享的账号才会联系对方区域;凭证只在内存里。
+ * 401 登出本账号;本机加入记录或同账号组的有效引用才可恢复跨区连接;凭证只在内存里。
*/
import fs from 'node:fs';
import fsp from 'node:fs/promises';
@@ -19,8 +19,10 @@ const state = vi.hoisted(() => ({
responses: new Map<string, unknown>(),
clients: [] as Array<{ opts: Record<string, unknown>; started: boolean; stopped: boolean }>,
localReceivedError: false,
+ localHasGroupShare: false,
userId: 'user-1',
identityCards: [] as string[],
+ invokes: [] as Array<{ target: string; channel: string }>,
}));
vi.mock('electron', () => ({ app: { getVersion: () => '0.0.0-test' } }));
@@ -56,7 +58,10 @@ vi.mock('../providerShareApi.js', () => ({
providerShareApi: {
listReceived: async () => {
if (state.localReceivedError) throw new Error('local unavailable');
- return [{ ...share, shareId: 'share-local', memberId: 'member-local', owner: { ...share.owner, region: 'cn' } }];
+ return [
+ { ...share, shareId: 'share-local', memberId: 'member-local', owner: { ...share.owner, region: 'cn' } },
+ ...(state.localHasGroupShare ? [{ ...share, owner: { ...share.owner, region: 'cn' } }] : []),
+ ];
},
},
fetchIdentityCard: async (purpose: string, nonce: string) => {
@@ -76,12 +81,20 @@ vi.mock('@cindy/device-link', async (importOriginal) => ({
}
start() { this.record.started = true; }
stop() { this.record.stopped = true; }
+ async waitUntilOnline() {}
+ isLinkReady() { return false; }
+ async openLink() {}
+ async invoke(target: string, request: { channel: string }) {
+ state.invokes.push({ target, channel: request.channel });
+ return { ok: true, result: { providers: [{ id: 'openai' }] } };
+ }
},
}));
import {
__testing,
crossRegionOfIntent,
+ crossRegionInvoke,
crossRegionSendRequest,
getCrossRegionReceived,
getConfirmedCrossRegionReceivedRegions,
@@ -92,7 +105,8 @@ import {
stopProviderShareCrossRegion,
} from '../providerShareCrossRegion';
import { providerShareHostPeer } from '@cindy/device-link';
-import { getReceivedSharesSnapshot, isReceivedSharesReady, refreshReceivedShares, startProviderShareGuest, stopProviderShareGuest } from '../providerShareGuest';
+import { captureProviderShareGroupRecovery, getReceivedSharesSnapshot, isReceivedSharesReady, refreshReceivedShares, resolveRemoteAgentTargetWhenReady, startProviderShareGuest, stopProviderShareGuest } from '../providerShareGuest';
+import { createProviderGroupRemoteClient } from '../../provider-group/remoteClient';
const share = {
shareId: 'share-x', memberId: 'member-x', providerId: 'openai', providerLabel: 'OpenAI', hostDeviceId: 'owner-pc',
@@ -114,8 +128,10 @@ beforeEach(() => {
state.responses = new Map();
state.clients = [];
state.localReceivedError = false;
+ state.localHasGroupShare = false;
state.userId = 'user-1';
state.identityCards = [];
+ state.invokes = [];
});
afterEach(() => {
vi.restoreAllMocks();
@@ -126,6 +142,110 @@ afterEach(() => {
});
describe('cross-region provider share', () => {
+ // Regression 2026-10-26: a same-account group can use a cross-region share that this
+ // computer has never joined. Existing tests only restored locally marked accounts.
+ // Unit: real group view/pick -> guest resolution -> cross-region catalog transport;
+ // the minimal input is one authorized shared member and no local region marker.
+ function remoteGroup(response?: Promise<unknown>) {
+ const member = { key: 'share:share-x:openai', kind: 'share', agentDeviceId: 'share:share-x',
+ providerId: 'openai', limit: 4, weight: 1, paused: false };
+ const view = { providerId: 'openai', config: { strategy: 'least', autoSwitch: true, members: [member] },
+ members: [{ ...member, label: 'Ann', state: 'available', running: 0 }] };
+ const client = createProviderGroupRemoteClient(async (_device, _channel, args) => ({
+ ok: true,
+ result: response ? await response : (args[0] as { action: string }).action === 'pick'
+ ? { kind: 'member', member, label: 'Ann' } : view,
+ }), { captureShareRecovery: captureProviderShareGroupRecovery });
+ return { client, view };
+ }
+
+ it.each(['view', 'pick'] as const)('restores an authorized cross-region group member on %s without another invitation', async (action) => {
+ state.responses.set('/session', { credential: CREDENTIAL, expiresAt: new Date(Date.now() + 86_400_000).toISOString(), shares: [share] });
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ await refreshReceivedShares('test');
+ expect(__testing.readMarkers()).toEqual({});
+ const { client } = remoteGroup();
+ if (action === 'view') await Promise.all([client.view('group-owner', 'openai'), client.view('group-owner', 'openai')]);
+ else await client.pick('group-owner', { sessionId: 'task', providerId: 'openai', agentKind: 'codex', model: 'model', exclude: [] });
+ const target = await resolveRemoteAgentTargetWhenReady('share:share-x');
+ expect(target).toBe(providerShareHostPeer('share-x', 'owner-pc'));
+ await expect(crossRegionInvoke(target, 'maker:provider:list', []))
+ .resolves.toEqual({ ok: true, result: { providers: [{ id: 'openai' }] } });
+ expect(state.invokes).toEqual([{ target, channel: 'maker:provider:list' }]);
+ expect(state.calls.map((call) => call.path)).toEqual(['/api/device-link/provider-shares/x/session']);
+ expect(state.calls[0].opts).toMatchObject({ token: null, baseUrl: PEER, skipSessionInvalidation: true });
+ expect(Object.values(__testing.readMarkers())).toEqual([['global']]);
+ await client.view('group-owner', 'openai');
+ expect(state.calls).toHaveLength(1);
+ });
+
+ it('refreshes a newly received same-region group share without contacting the peer region', async () => {
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ await refreshReceivedShares('test');
+ state.localHasGroupShare = true;
+ await remoteGroup().client.view('group-owner', 'openai');
+ const target = await resolveRemoteAgentTargetWhenReady('share:share-x');
+ expect(target).toBe(providerShareHostPeer('share-x', 'owner-pc'));
+ expect(isCrossRegionProviderShareTarget(target)).toBe(false);
+ expect(state.calls).toEqual([]);
+ expect(__testing.readMarkers()).toEqual({});
+ });
+
+ it.each(['paused', 'removed'] as const)('does not turn a group reference into permission for a %s share', async (status) => {
+ state.responses.set('/session', { credential: status === 'removed' ? null : CREDENTIAL,
+ expiresAt: status === 'removed' ? null : new Date(Date.now() + 86_400_000).toISOString(),
+ shares: status === 'removed' ? [] : [{ ...share, status }] });
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ const { client } = remoteGroup();
+ await client.view('group-owner', 'openai');
+ await expect(resolveRemoteAgentTargetWhenReady('share:share-x')).rejects.toThrow(
+ status === 'paused' ? 'REMOTE_AGENT_SHARE_PAUSED' : 'REMOTE_AGENT_SHARE_REMOVED');
+ expect(state.calls).toHaveLength(1);
+ expect(state.invokes).toEqual([]);
+ if (status === 'removed') expect(__testing.readMarkers()).toEqual({});
+ });
+
+ it('keeps a failed group recovery unavailable, respects retry backoff and leaves local shares usable', async () => {
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ const { client } = remoteGroup();
+ await client.view('group-owner', 'openai');
+ await expect(resolveRemoteAgentTargetWhenReady('share:share-x')).rejects.toThrow('DEVICE_LINK_NOT_CONNECTED');
+ await client.view('group-owner', 'openai');
+ expect(state.calls).toHaveLength(1);
+ await expect(resolveRemoteAgentTargetWhenReady('share:share-local')).resolves.toBe(providerShareHostPeer('share-local', 'owner-pc'));
+ expect(state.clients).toEqual([]);
+ });
+
+ it.each(['group', 'session'] as const)('does not restore another account from a late %s response', async (phase) => {
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ await refreshReceivedShares('test');
+ const response = deferred<unknown>();
+ if (phase === 'session') state.responses.set('/session', response.promise);
+ const { client, view } = remoteGroup(phase === 'group' ? response.promise : undefined);
+ const pending = client.view('group-owner', 'openai');
+ let route: Promise<string> | undefined;
+ let rejected: Promise<void> | undefined;
+ if (phase === 'session') {
+ await pending;
+ await vi.waitFor(() => expect(state.calls).toHaveLength(1));
+ route = resolveRemoteAgentTargetWhenReady('share:share-x');
+ rejected = expect(route).rejects.toThrow('DEVICE_LINK_NOT_CONNECTED');
+ }
+ const markersBeforeSwitch = __testing.readMarkers();
+ state.userId = 'user-2';
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ response.resolve(phase === 'group' ? view : {
+ credential: CREDENTIAL, expiresAt: new Date(Date.now() + 86_400_000).toISOString(), shares: [share],
+ });
+ await pending;
+ await rejected;
+ expect(state.calls).toHaveLength(phase === 'group' ? 0 : 1);
+ // The old account can retain its own already-written marker; the new account gains none.
+ expect(__testing.readMarkers()).toEqual(markersBeforeSwitch);
+ expect(getCrossRegionReceived()).toEqual([]);
+ expect(state.clients).toEqual([]);
+ });
+
it('serializes marker read-modify-write across accounts and regions', async () => {
const firstAccount = 'a'.repeat(64);
const secondAccount = 'b'.repeat(64);
@@ -238,6 +358,7 @@ describe('cross-region provider share', () => {
for (let i = 0; i < 3; i += 1) {
getReceivedSharesSnapshot({ ownerStamp: { dataOwnerId: state.userId, ownerGeneration: 1 }, regions: ['global'] });
}
+ await expect(resolveRemoteAgentTargetWhenReady('share:unknown')).rejects.toThrow('REMOTE_AGENT_SHARE_REMOVED');
await new Promise((resolve) => setTimeout(resolve, 0));
expect(state.identityCards).toEqual([]);
expect(state.calls).toEqual([]);
@@ -340,6 +461,8 @@ describe('cross-region provider share', () => {
expect(isReceivedSharesReady()).toBe(false);
expect(snapshot.confirmedRegions).toEqual([failed === 'local' ? 'global' : 'cn']);
expect(snapshot.received.map((item) => item.shareId)).toEqual([failed === 'local' ? 'share-x' : 'share-local']);
+ const usable = failed === 'local' ? 'share-x' : 'share-local';
+ await expect(resolveRemoteAgentTargetWhenReady(`share:${usable}`)).resolves.toBe(providerShareHostPeer(usable, 'owner-pc'));
});
it('does not confirm an incomplete or failed peer list for favorite cleanup', async () => {
@@ -375,12 +498,17 @@ describe('cross-region provider share', () => {
expect(getReceivedSharesSnapshot().confirmedRegions).toEqual(['cn']);
expect(isCrossRegionReceivedReady()).toBe(false);
expect(isReceivedSharesReady()).toBe(false);
+ const route = resolveRemoteAgentTargetWhenReady('share:share-x');
+ const resolved = empty
+ ? expect(route).rejects.toThrow('REMOTE_AGENT_SHARE_REMOVED')
+ : expect(route).resolves.toBe(providerShareHostPeer('share-x', 'owner-pc'));
session.resolve({
credential: empty ? null : CREDENTIAL,
expiresAt: empty ? null : new Date(Date.now() + 86_400_000).toISOString(),
shares: empty ? [] : [share],
});
await refreshProviderShareCrossRegion('global');
+ await resolved;
expect(isCrossRegionReceivedReady()).toBe(true);
expect(isReceivedSharesReady()).toBe(true);
expect(getReceivedSharesSnapshot().received.map((item) => item.shareId))
diff --git a/apps/desktop/src/main/device-link/providerShareCrossRegion.ts b/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
index 6a609ada53..a8747b8aa9 100644
--- a/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
+++ b/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
@@ -53,6 +53,7 @@ const CREDENTIAL_REFRESH_MARGIN_MS = 60 * 60_000;
const SESSION_REFRESH_MS = 12 * 60 * 60_000;
const ONLINE_WAIT_MS = 8_000;
const MARKER_FILE = 'provider-share-regions.json';
+const GROUP_RECOVERY_INTERVAL_MS = 30_000;
export interface CrossRegionEvents {
changed(): void;
@@ -80,6 +81,8 @@ interface Runtime {
account: string;
regions: Map<Region, RegionState>;
stopped: boolean;
+ groupRecovery: Promise<void> | null;
+ nextGroupRecoveryAt: number;
}
let runtime: Runtime | null = null;
@@ -389,7 +392,7 @@ export function startProviderShareCrossRegion(events: CrossRegionEvents, options
userDataDir = options.userDataDir;
const account = accountKey();
if (!account) return;
- const rt: Runtime = { events, account, regions: new Map(), stopped: false };
+ const rt: Runtime = { events, account, regions: new Map(), stopped: false, groupRecovery: null, nextGroupRecoveryAt: 0 };
runtime = rt;
const activeRegions = readMarkers()[account] ?? [];
// 清理失败或未完成就退出时,下次只恢复本地空名单,不向对方区域发送身份。
@@ -422,6 +425,43 @@ export function refreshProviderShareCrossRegion(region: Region): Promise<void> {
return rt && current(rt) ? refreshRegion(rt, region) : Promise.resolve();
}
+/**
+ * A verified same-account group references shares already accepted on another computer.
+ * Register this computer with the official peer region; its server still decides membership.
+ * Never call this for renderer hints, favorites or arbitrary missing share IDs.
+ */
+export function restoreCrossRegionReceivedForRemoteGroup(shareIds: readonly string[]): Promise<void> {
+ const rt = runtime;
+ if (!rt || !current(rt) || shareIds.length === 0) return Promise.resolve();
+ const region = peerRegion();
+ const state = rt.regions.get(region);
+ if (shareIds.every((id) => state?.shares.some((share) => share.shareId === id))) return Promise.resolve();
+ if (rt.groupRecovery) return rt.groupRecovery;
+ if (state?.refreshing) return state.refreshing;
+ if ((state?.failures && state.timer) || Date.now() < rt.nextGroupRecoveryAt) return Promise.resolve();
+ rt.nextGroupRecoveryAt = Date.now() + GROUP_RECOVERY_INTERVAL_MS;
+ // A previously confirmed empty list is stale once another computer reports membership.
+ if (state && state.shares.length === 0) state.loaded = false;
+ const run = (async () => {
+ await writeMarker(rt.account, region, true, false, () => current(rt)).catch((error) =>
+ log.warn('cross-region marker write failed', { error: String(error) }));
+ if (current(rt)) await refreshRegion(rt, region);
+ })().finally(() => { rt.groupRecovery = null; });
+ rt.groupRecovery = run;
+ return run;
+}
+
+/** Missing shares are not removed until an enabled region has answered successfully. */
+export async function waitForCrossRegionReceived(): Promise<boolean> {
+ const rt = runtime;
+ if (!rt) return true;
+ if (!current(rt)) return false;
+ await rt.groupRecovery;
+ const state = rt.regions.get(peerRegion());
+ await state?.refreshing;
+ return current(rt) && isCrossRegionReceivedReady() && !state?.failures;
+}
+
export function getCrossRegionReceived(): ProviderShareReceived[] {
return runtime ? [...runtime.regions.values()].flatMap((state) => state.shares) : [];
}
diff --git a/apps/desktop/src/main/device-link/providerShareGuest.ts b/apps/desktop/src/main/device-link/providerShareGuest.ts
index e606538ae0..a71cce756a 100644
--- a/apps/desktop/src/main/device-link/providerShareGuest.ts
+++ b/apps/desktop/src/main/device-link/providerShareGuest.ts
@@ -39,6 +39,8 @@ import {
isCrossRegionReceivedReady,
ensureCrossRegionReceivedForFavorites,
refreshProviderShareCrossRegion,
+ restoreCrossRegionReceivedForRemoteGroup,
+ waitForCrossRegionReceived,
startProviderShareCrossRegion,
stopProviderShareCrossRegion,
} from './providerShareCrossRegion.js';
@@ -79,6 +81,7 @@ interface Runtime {
timer: ReturnType<typeof setTimeout> | null;
refreshing: Promise<void> | null;
pending: Map<string, PendingRequest>;
+ groupRecoveries: Set<Promise<void>>;
stopped: boolean;
}
@@ -196,14 +199,42 @@ export function resolveRemoteAgentTarget(agentDeviceId: string): string {
* 未登录或设备互联未就绪时按连不上处理。
*/
export async function resolveRemoteAgentTargetWhenReady(agentDeviceId: string): Promise<string> {
- if (!parseProviderShareAgentDeviceId(agentDeviceId)) return agentDeviceId;
+ const shareId = parseProviderShareAgentDeviceId(agentDeviceId);
+ if (!shareId) return agentDeviceId;
const rt = runtime;
if (!rt || !current(rt)) throw new Error('[DEVICE_LINK_NOT_CONNECTED] provider sharing is not ready');
+ // An already loaded share remains usable even while the other region is unavailable.
+ if (findReceivedShare(shareId)) return resolveRemoteAgentTarget(agentDeviceId);
if (rt.fetchedAt === 0) await refreshReceivedShares('resolve');
- if (rt.fetchedAt === 0) throw new Error('[DEVICE_LINK_NOT_CONNECTED] shared providers are not loaded yet');
+ await Promise.all(rt.groupRecoveries);
+ if (!current(rt)) throw new Error('[DEVICE_LINK_NOT_CONNECTED] provider sharing account changed');
+ if (findReceivedShare(shareId)) return resolveRemoteAgentTarget(agentDeviceId);
+ const crossReady = await waitForCrossRegionReceived();
+ if (!current(rt)) throw new Error('[DEVICE_LINK_NOT_CONNECTED] provider sharing account changed');
+ if (findReceivedShare(shareId)) return resolveRemoteAgentTarget(agentDeviceId);
+ if (rt.fetchedAt === 0 || !crossReady) throw new Error('[DEVICE_LINK_NOT_CONNECTED] shared providers are not loaded yet');
return resolveRemoteAgentTarget(agentDeviceId);
}
+/** Capture before reading a same-account group, so a late reply cannot activate another account. */
+export function captureProviderShareGroupRecovery(): (agentDeviceIds: readonly string[]) => Promise<void> {
+ const rt = runtime;
+ return (agentDeviceIds) => {
+ if (!rt || !current(rt)) return Promise.resolve();
+ const missing = agentDeviceIds.map(parseProviderShareAgentDeviceId)
+ .filter((id): id is string => !!id && !findReceivedShare(id));
+ if (missing.length === 0) return Promise.resolve();
+ const recovery = (async () => {
+ // Check the local service first: a recently accepted same-region share needs no peer lookup.
+ await refreshReceivedShares('remote-group');
+ if (!current(rt)) return;
+ await restoreCrossRegionReceivedForRemoteGroup(missing.filter((id) => !findReceivedShare(id)));
+ })();
+ rt.groupRecoveries.add(recovery);
+ return recovery.finally(() => { rt.groupRecoveries.delete(recovery); });
+ };
+}
+
// ─── 已收到的分享 ────────────────────────────────────────────────
function schedule(rt: Runtime): void {
@@ -227,6 +258,7 @@ export function startProviderShareGuest(events: ProviderShareGuestEvents, option
timer: null,
refreshing: null,
pending: new Map(),
+ groupRecoveries: new Set(),
stopped: false,
};
runtime = rt;
diff --git a/apps/desktop/src/main/provider-group/remoteClient.ts b/apps/desktop/src/main/provider-group/remoteClient.ts
index 2759a39a19..b8e2ae64a7 100644
--- a/apps/desktop/src/main/provider-group/remoteClient.ts
+++ b/apps/desktop/src/main/provider-group/remoteClient.ts
@@ -61,7 +61,10 @@ export class ProviderGroupRemoteUnsupportedError extends Error {
}
}
-export function createProviderGroupRemoteClient(invoke: ProviderGroupRemoteInvoke): ProviderGroupRemoteClient {
+export function createProviderGroupRemoteClient(invoke: ProviderGroupRemoteInvoke, options: {
+ /** Capture the account before the request; only verified same-account group responses can restore shares. */
+ captureShareRecovery?(): (agentDeviceIds: readonly string[]) => Promise<void>;
+} = {}): ProviderGroupRemoteClient {
async function call(ownerDeviceId: string, request: Record<string, unknown>, preSend?: () => void): Promise<unknown> {
const result = preSend
? await invoke(ownerDeviceId, PROVIDER_GROUP_REMOTE_CHANNEL, [request], { preSend })
@@ -76,6 +79,7 @@ export function createProviderGroupRemoteClient(invoke: ProviderGroupRemoteInvok
return {
async pick(ownerDeviceId, input) {
+ const recoverShares = options.captureShareRecovery?.();
try {
const raw = await call(ownerDeviceId, {
action: 'pick',
@@ -89,7 +93,11 @@ export function createProviderGroupRemoteClient(invoke: ProviderGroupRemoteInvok
// 旧组所在电脑可能忽略这个可选约束:只有明确执行并回显的结果才用于主动换号。
if (input.quotaRebalance && (!raw || typeof raw !== 'object'
|| (raw as { quotaRebalance?: unknown }).quotaRebalance !== true)) return { kind: 'none' };
- return parseProviderGroupRemotePick(raw, input.providerId);
+ const pick = parseProviderGroupRemotePick(raw, input.providerId);
+ if (pick.kind === 'member' && pick.member.kind === 'share' && pick.member.agentDeviceId) {
+ await recoverShares?.([pick.member.agentDeviceId]);
+ }
+ return pick;
} catch (error) {
if (error instanceof ProviderGroupRemoteUnsupportedError) return { kind: 'none' };
throw error;
@@ -121,16 +129,24 @@ export function createProviderGroupRemoteClient(invoke: ProviderGroupRemoteInvok
},
async view(ownerDeviceId, providerId, modelOrOptions) {
+ const recoverShares = options.captureShareRecovery?.();
const model = typeof modelOrOptions === 'string' ? modelOrOptions : modelOrOptions?.model;
const agentKind = typeof modelOrOptions === 'object' ? modelOrOptions?.agentKind : undefined;
const includeGuestSupport = typeof modelOrOptions === 'object' && modelOrOptions?.includeGuestSupport === true;
- return parseProviderGroupRemoteView(await call(ownerDeviceId, {
+ const view = parseProviderGroupRemoteView(await call(ownerDeviceId, {
action: 'view',
providerId,
...(model ? { model } : {}),
...(agentKind ? { agentKind } : {}),
...(includeGuestSupport ? { includeGuestSupport: true } : {}),
}), providerId);
+ const usable = new Set(view.members.filter((member) => member.state === 'available' || member.state === 'full').map((member) => member.key));
+ const shares = view.config?.members.filter((member) => member.kind === 'share' && usable.has(member.key))
+ .flatMap((member) => member.agentDeviceId ? [member.agentDeviceId] : []) ?? [];
+ // Keep the owner snapshot responsive. Catalog resolution waits for this recovery,
+ // within the existing per-member reachability deadline used by the settings page.
+ void recoverShares?.(shares).catch(() => undefined);
+ return view;
},
async usage(ownerDeviceId, report, beforeSend) {
diff --git a/apps/desktop/src/main/provider-group/runtime.ts b/apps/desktop/src/main/provider-group/runtime.ts
index 011ec34a04..d7abb88735 100644
--- a/apps/desktop/src/main/provider-group/runtime.ts
+++ b/apps/desktop/src/main/provider-group/runtime.ts
@@ -17,7 +17,7 @@ import {
type ProviderGroupRebalanceSuggestion,
type ProviderGroupSessionGroup,
} from '../../shared/providerGroup.js';
-import { getReceivedShares } from '../device-link/providerShareGuest.js';
+import { captureProviderShareGroupRecovery, getReceivedShares } from '../device-link/providerShareGuest.js';
import { handleListDevices, defaultDeps as deviceDirectoryDeps } from '../device-link/ipc.js';
import { remoteBackgroundInvoke } from '../device-link/index.js';
import { isMobilePlatform } from '../device-link/controllerPlatform.js';
@@ -214,7 +214,9 @@ let remoteClient: ProviderGroupRemoteClient | null = null;
/** 问其他电脑上的组(无状态,按调用时的账号经设备互联发出)。 */
export function getProviderGroupRemoteClient(): ProviderGroupRemoteClient {
- remoteClient ??= createProviderGroupRemoteClient(remoteBackgroundInvoke);
+ remoteClient ??= createProviderGroupRemoteClient(remoteBackgroundInvoke, {
+ captureShareRecovery: captureProviderShareGroupRecovery,
+ });
return remoteClient;
}
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index fa003519f5..59b0046122 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -1892,6 +1892,13 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
## 供应商组:同账号直连(P2a)
+跨区组员恢复(2026-10-26):控制端 Main 仅在同账号 `provider-group:remote` 的有效 `view` / `pick`
+回包引用分享时,恢复本机缺失的区域标记并通过既有 `/provider-shares/x/session` 核验成员关系。
+不新增 wire 字段、channel 或权限,兼容旧组所在电脑;手机仍由任务所在电脑执行。旧控制端保留原行为。
+本机已加载的分享直接使用;尚在恢复或请求失败时不按已移除处理。Renderer 收藏和任意分享 ID 不能触发
+跨区激活。凭证只留内存、区域标记格式不变,降级后已恢复的分享沿原连接路径继续使用。
+回归:`device-link/__tests__/providerShareCrossRegion.test.ts`。
+
产品规则见 [`provider-groups.md`](../product-rules/provider-groups.md) §4、§5、§6.1、§10。组所在电脑 O 把某个供应商建成组后,
同账号另一台电脑 C 上选了 O 的这个供应商的新任务:C 问 O 该用哪台,再自己直接连到选中的组内电脑运行。
diff --git a/docs/dev-rules/remote-and-mobile-adaptation.md b/docs/dev-rules/remote-and-mobile-adaptation.md
index 5c9bd2e96c..a9423afd77 100644
--- a/docs/dev-rules/remote-and-mobile-adaptation.md
+++ b/docs/dev-rules/remote-and-mobile-adaptation.md
@@ -92,6 +92,16 @@ Mobile `useSessionListActions`、`SessionMenuSheet`、`orphanSessionActions.test
## 恢复动作先回答故障半径(device-link 共享链路)
+### 供应商组的跨区分享恢复
+
+2026-10-26:① 故障是任务所在电脑没有加载同账号组已能用的跨区分享;② 仅恢复当前账号在另一
+官方区域的分享列表与专用连接,不重启本区 relay、不重放任务、不扩大分享权限。首次请求合并,失败
+沿用现有退避,重复的组查询不绕过退避;组视图先返回,成员目录仍受原有 3 秒读取上限约束;③ 回归
+通过真实组 `view` / `pick` 与分享路由入口验证恢复,同时核对本区分享仍可用、暂停与撤销仍拒绝、
+换账号后的迟到组回包和服务端回包不能激活新账号。手机及桌面远控共用任务所在电脑的这条路径,
+SSH 与跨账号组中转不变。实现见 `provider-group/remoteClient.ts`、`device-link/providerShareGuest.ts`
+与 `providerShareCrossRegion.ts`。
+
### 文件通道慢速回退
Desktop 与 Mobile 的整文件 peer 下载共用 `fileTransferPolicy.ts`。数字按职责分开:
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index cf40c955b6..9ace7cc8a0 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -110,7 +110,9 @@
所以按名称比较,不只比 ID。名称不同时提示「这个链接分享的是 {对方供应商},不是 {本供应商}」,
把两台电脑上的名称改成一样即可。
- 判断所需的品牌信息取远端供应商目录里已有的去敏字段,不新增协议字段。
-- 组内电脑必须与组所在电脑在同一区域(跨区域分享默认关闭,见供应商分享 §8)。
+- 同账号电脑经本账号的设备互联服务加入;别人分享的供应商可以来自另一个官方区域,是否开放由
+ 供应商分享 §8 的服务端开关决定。同账号其他电脑使用该组时,应恢复已有跨区分享的连接,不能因
+ 本机尚无区域标记而要求重新申请或判成分享已移除(2026-10-26)。
- 分享关系属于账号:组所在电脑账号收到的分享,这个账号的其他电脑也能直接用。被组所在电脑加进组之后,
这个账号的其他电脑上不再单独列出它,只列组那一项(与同账号电脑被收进组同一条规则,§10);组所在电脑离线时
它重新单独出现。组设置本身仍只存在组所在电脑本机。
diff --git a/docs/product-rules/provider-sharing.md b/docs/product-rules/provider-sharing.md
index 42573cec2e..83409eef78 100644
--- a/docs/product-rules/provider-sharing.md
+++ b/docs/product-rules/provider-sharing.md
@@ -182,6 +182,9 @@ Desktop 与 Mobile 使用同一写法。
该分享为前提。Desktop 复用控制端的已收到列表与分享读取通道,并通过既有
`maker:provider-share:received-catalogs` 核对任务所在电脑也已加载且未暂停该分享;跨区域连接的启用
标记保存在各电脑本地,不能仅凭控制端名单认定被控端可用,也不自动替被控端开启跨区连接。
+同账号供应商组是已加入分享的另一条有效来源:任务所在电脑从组所在电脑的 `view` / `pick` 回包确认
+分享引用后,可自行向另一区域的官方分享服务核验已有授权并恢复连接,无需再次申请;不从 Renderer
+自报的分享 ID 或收藏恢复联网资格。名单仍由服务端裁决,暂停、撤销与账号切换照常生效。
本区和跨区名单独立可用:返回名单里已加载且有效的分享立即参与候选筛选;仍有区域尚未就绪时,
控制端继续有上限地退避查询,补上稍后加载的分享,不让单一区域故障阻塞另一区域。
查询失败或旧主机不支持时不新增分享候选,当前 / 待切换位置仍保留。模型选择和执行仍由任务所在电脑校验;
@@ -384,6 +387,11 @@ Desktop「设置 → 模型供应商」的左栏(2026-10-08 用户裁决):
区域公钥验签后,才把申请交给分享者;分享者看到的身份与同区域一样经过核实。
- **专用凭证**:分享建立后,分享者区域的服务为受邀者签发只限这个分享的凭证,只能用于远程 Agent,
不能访问分享者区域的其他服务或能力。
+- **同账号换电脑**:另一台电脑使用已建供应商组时,组中获准使用的跨区分享必须可正常连接。
+ 本机没有区域标记时,以同账号组的有效回包触发核验,复用既有身份名片与分享连接凭证,不重新申请。
+ 标记仍只保存区域;加载期间或查询失败不得误报「分享已移除」,已加载区域的分享仍可独立使用。
+ 实现与回归见 `providerShareGuest.ts`、`providerShareCrossRegion.ts`、`provider-group/remoteClient.ts`
+ 与 `device-link/__tests__/providerShareCrossRegion.test.ts`(2026-10-26)。
- **合规开关**:跨区会让用户内容跨境流动,并让一方用户通过分享使用另一区域的模型。跨区分享须经
公司合规确认后,由服务端开关开启;开关关闭时跨区链接提示暂不支持,同区域分享不受影响。
- **网络**:跨区连接质量不能保证时,需要服务端评估区域间转发;客户端对跨区连接的断线与重试沿用