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。

feat(provider-share): 分享来的供应商经组转给他人需原主人逐人同意 (#6100)

Lizi4f26df40fa0d
diff --git a/apps/desktop/src/main/bootstrap-electron.ts b/apps/desktop/src/main/bootstrap-electron.ts
index ab9f2d6dfd..95c3ac6508 100644
--- a/apps/desktop/src/main/bootstrap-electron.ts
+++ b/apps/desktop/src/main/bootstrap-electron.ts
@@ -605,6 +605,7 @@ import { registerSharedTaskIpc } from './device-link/sharedTaskIpc.js';
import { registerProviderShareIpc } from './device-link/providerShareRuntime.js';
import { registerProviderGroupIpc } from './provider-group/ipc.js';
import { registerProviderGroupRemoteHandler } from './provider-group/remoteRegistration.js';
+import { providerGroupReshare, registerProviderGroupReshare } from './provider-group/reshareRuntime.js';
import {
getUpdateRelaunchControllers,
hasInFlightRemoteInvokes,
@@ -9691,8 +9692,9 @@ app.on('ready', async () => {
);
registerSharedTaskIpc(isSharedTaskAvailable, () => getDeviceLinkStatus() === 'online');
registerProviderShareIpc();
- registerProviderGroupIpc();
+ registerProviderGroupIpc({ reshare: providerGroupReshare });
registerProviderGroupRemoteHandler();
+ registerProviderGroupReshare();
registerFilePeerIpc();
registerRemoteDesktopIpc(isGlobalVoiceInputOverlaySender, {
name: getControllerName,
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareDispatch.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareDispatch.test.ts
index ed113befe0..c052b25f49 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareDispatch.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareDispatch.test.ts
@@ -281,7 +281,8 @@ describe('provider share invoke', () => {
expect(sharedGroupStatus).not.toHaveBeenCalled();
const explicit = await runInvoke(GUEST, { channel: 'maker:provider:list', args: [{ includeSharedGroupStatus: true, providerId: 'private-provider' }] });
expect(explicit).toMatchObject({ ok: true, result: { providers: [{ id: 'anthropic', groupStatus: ['busy', 'needs-update'] }] } });
- expect(sharedGroupStatus).toHaveBeenCalledWith('anthropic');
+ // 带上读状态的受邀者:分享来的组内电脑按它的主人是否同意过这个人显示(转分享,provider-sharing.md §4.3)。
+ expect(sharedGroupStatus).toHaveBeenCalledWith('anthropic', GUEST);
expect(JSON.stringify(explicit)).not.toContain('private-provider');
// An old host or failed status read still supplies its ordinary model catalog.
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareReshare.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareReshare.test.ts
new file mode 100644
index 0000000000..5dc545ef26
--- /dev/null
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareReshare.test.ts
@@ -0,0 +1,183 @@
+/**
+ * 转分享的同意(分享者这台电脑,docs/product-rules/provider-sharing.md §4.3):受邀者的组所在电脑整体报上它分享的人,
+ * 新出现的人等主人处理;主人的决定保留到那个人不再被报上来;同意只认报上来的那台组所在电脑与那个人。
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { providerShareGuestPeer } from '@cindy/device-link';
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'provider-share-reshare-test-'));
+const access = vi.hoisted(() => ({ active: true }));
+
+vi.mock('electron', () => ({ app: { getPath: () => tmpDir } }));
+vi.mock('../../logger.js', () => ({ createLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn() }) }));
+vi.mock('../../appSessionState.js', () => ({
+ ownerScopedUserDataPath: (name: string) => path.join(tmpDir, name),
+ activeOwnerScopeKey: () => 'owner-test',
+}));
+vi.mock('../providerShareHost.js', () => ({
+ providerShareGuestAccess: () => (access.active ? { shareId: 'a-share', memberId: 'b-member', providerId: 'anthropic' } : null),
+}));
+
+const reshare = await import('../providerShareReshare.js');
+afterAll(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+const B_GROUP = providerShareGuestPeer('a-share', 'b-member', 'b-device');
+const B_OTHER_DEVICE = providerShareGuestPeer('a-share', 'b-member', 'b-laptop');
+const CAROL = 'c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1';
+const DAVE = 'd1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1';
+
+function manyEntries(count: number): Array<{ key: string; name: string }> {
+ return Array.from({ length: count }, (_, index) => ({
+ key: index.toString(16).padStart(32, '0'),
+ name: 'Person ' + index,
+ }));
+}
+
+beforeEach(async () => {
+ access.active = true;
+ reshare.setProviderShareReshareEvents(null);
+ await reshare.pruneProviderShareReshares(() => true);
+});
+
+describe('provider share reshare consent (sharer computer)', () => {
+ it('records newly reported people as pending and tells the owner once', async () => {
+ const requested = vi.fn();
+ reshare.setProviderShareReshareEvents({ requested, changed: vi.fn(), revoked: vi.fn() });
+ expect(await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol', avatar: 'https://cdn.example.com/c.png' }]))
+ .toEqual({ entries: [{ key: CAROL, state: 'pending' }] });
+ expect(requested).toHaveBeenCalledTimes(1);
+ expect(requested.mock.calls[0][0]).toEqual([expect.objectContaining({
+ shareId: 'a-share', memberId: 'b-member', deviceId: 'b-device', key: CAROL, name: 'Carol', state: 'pending',
+ })]);
+ // 同一份再报一次:不重复提醒。
+ await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol' }]);
+ expect(requested).toHaveBeenCalledTimes(1);
+ expect(reshare.providerShareReshareAllows(B_GROUP, CAROL)).toBe(false);
+ });
+
+ it('allows a relayed task only after the owner agrees, only for that group computer and that person', async () => {
+ await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol' }, { key: DAVE, name: 'Dave' }]);
+ const carol = reshare.listProviderShareReshares().find((record) => record.key === CAROL)!;
+ expect(await reshare.decideProviderShareReshare(carol.id, 'approve')).toMatchObject({ previous: 'pending', record: { state: 'approved' } });
+ expect(reshare.providerShareReshareAllows(B_GROUP, CAROL)).toBe(true);
+ expect(reshare.providerShareReshareAllows(B_GROUP, DAVE)).toBe(false);
+ expect(reshare.providerShareReshareAllows(B_GROUP, undefined)).toBe(false);
+ // 同一个受邀者的另一台电脑没有报过这个人。
+ expect(reshare.providerShareReshareAllows(B_OTHER_DEVICE, CAROL)).toBe(false);
+ expect(reshare.providerShareReshareAllows('same-account-mac', CAROL)).toBe(false);
+ // 主人的决定在重新报上来时保留。
+ expect(await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol (new name)' }, { key: DAVE, name: 'Dave' }]))
+ .toEqual({ entries: [{ key: CAROL, state: 'approved' }, { key: DAVE, state: 'pending' }] });
+ expect(reshare.listProviderShareReshares().find((record) => record.key === CAROL)?.name).toBe('Carol (new name)');
+ });
+
+ it('withdrawing or no longer reporting an agreed person ends their relayed tasks', async () => {
+ const revoked = vi.fn();
+ reshare.setProviderShareReshareEvents({ requested: vi.fn(), changed: vi.fn(), revoked });
+ await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol' }, { key: DAVE, name: 'Dave' }]);
+ for (const record of reshare.listProviderShareReshares()) await reshare.decideProviderShareReshare(record.id, 'approve');
+ // 主人撤回(拒绝已同意的):调用方据 previous 结束任务。
+ const dave = reshare.listProviderShareReshares().find((record) => record.key === DAVE)!;
+ expect(await reshare.decideProviderShareReshare(dave.id, 'reject')).toMatchObject({ previous: 'approved', record: { state: 'rejected' } });
+ expect(reshare.providerShareReshareAllows(B_GROUP, DAVE)).toBe(false);
+ // 组所在电脑不再报上 Carol(那人已不在它的分享里):删掉并结束她的任务。
+ await reshare.handleProviderShareReshare(B_GROUP, [{ key: DAVE, name: 'Dave' }]);
+ expect(revoked).toHaveBeenCalledWith([expect.objectContaining({ key: CAROL, state: 'approved' })]);
+ expect(reshare.listProviderShareReshares().map((record) => record.key)).toEqual([DAVE]);
+ // 拒绝过的人照旧保留主人的决定。
+ expect(reshare.listProviderShareReshares()[0]?.state).toBe('rejected');
+ });
+
+ it('notifies the owner when pending or rejected people disappear from the report', async () => {
+ const changed = vi.fn();
+ reshare.setProviderShareReshareEvents({ requested: vi.fn(), changed, revoked: vi.fn() });
+ await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol' }, { key: DAVE, name: 'Dave' }]);
+ const dave = reshare.listProviderShareReshares().find((record) => record.key === DAVE)!;
+ await reshare.decideProviderShareReshare(dave.id, 'reject');
+ changed.mockClear();
+
+ await reshare.handleProviderShareReshare(B_GROUP, []);
+
+ expect(changed).toHaveBeenCalledOnce();
+ expect(reshare.listProviderShareReshares()).toEqual([]);
+ });
+
+ it('only accepts reports from an active shared user', async () => {
+ access.active = false;
+ await expect(reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol' }])).rejects.toThrow(/REMOTE_AGENT_INVALID/);
+ access.active = true;
+ await expect(reshare.handleProviderShareReshare('same-account-mac', [])).rejects.toThrow(/REMOTE_AGENT_INVALID/);
+ expect(reshare.listProviderShareReshares()).toEqual([]);
+ });
+
+ it('drops everything a removed member reported', async () => {
+ await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol' }]);
+ const removed = await reshare.pruneProviderShareReshares((record) => record.memberId === 'b-member');
+ expect(removed.map((record) => record.key)).toEqual([CAROL]);
+ expect(reshare.listProviderShareReshares()).toEqual([]);
+ expect(await reshare.decideProviderShareReshare(removed[0]!.id, 'approve')).toBeNull();
+ });
+
+ it('stages out-of-order reshare batches and replaces records only after all chunks arrive', async () => {
+ const entries = manyEntries(257);
+ const batchId = 'batch-a1b2c3d4e5f6';
+ const first = await reshare.handleProviderShareReshare(B_GROUP, entries.slice(256), { id: batchId, index: 1, count: 2 });
+ expect(first.batch).toEqual({ id: batchId, index: 1, count: 2, complete: false });
+ expect(reshare.listProviderShareReshares()).toEqual([]);
+
+ const complete = await reshare.handleProviderShareReshare(B_GROUP, entries.slice(0, 256), { id: batchId, index: 0, count: 2 });
+ expect(complete.batch).toEqual({ id: batchId, index: 0, count: 2, complete: true });
+ expect(complete.entries).toHaveLength(256);
+ expect(reshare.listProviderShareReshares()).toHaveLength(257);
+ expect(reshare.listProviderShareReshares().every((record) => record.state === 'pending')).toBe(true);
+
+ // 已完成片段重发仍回完成状态,不会重新创建一个未完成批次。
+ const duplicate = await reshare.handleProviderShareReshare(B_GROUP, entries.slice(0, 256), { id: batchId, index: 0, count: 2 });
+ expect(duplicate.batch).toEqual({ id: batchId, index: 0, count: 2, complete: true });
+ expect(duplicate.entries).toHaveLength(256);
+ expect(reshare.listProviderShareReshares()).toHaveLength(257);
+ });
+
+ it('rejects conflicting duplicate chunks instead of replacing an earlier chunk', async () => {
+ const batch = { id: 'batch-112233445566', index: 0, count: 2 } as const;
+ await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol' }], batch);
+ await expect(reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Changed' }], batch))
+ .rejects.toThrow(/REMOTE_AGENT_INVALID/);
+ });
+
+ it('keeps the previous approvals when a reshare batch is missing a chunk', async () => {
+ await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol' }]);
+ const carol = reshare.listProviderShareReshares()[0]!;
+ await reshare.decideProviderShareReshare(carol.id, 'approve');
+ const entries = [{ key: CAROL, name: 'Carol' }, ...manyEntries(256)];
+ const result = await reshare.handleProviderShareReshare(B_GROUP, entries.slice(0, 256), {
+ id: 'batch-f6e5d4c3b2a1', index: 0, count: 2,
+ });
+ expect(result.batch?.complete).toBe(false);
+ expect(reshare.listProviderShareReshares()).toEqual([expect.objectContaining({ key: CAROL, state: 'approved' })]);
+ });
+
+ it('ignores damaged records on disk', () => {
+ expect(reshare.__testing.normalize({ records: [
+ { id: 'not-a-uuid', shareId: 'a', memberId: 'b', deviceId: 'c', key: CAROL, name: 'x', state: 'approved', requestedAt: 1 },
+ { id: '11111111-1111-4111-8111-111111111111', shareId: 'a', memberId: 'b', deviceId: 'c', key: CAROL, name: 'Carol', state: 'maybe', requestedAt: 1 },
+ { id: '22222222-2222-4222-8222-222222222222', shareId: 'a', memberId: 'b', deviceId: 'c', key: CAROL, name: 'Carol', avatar: 'http://x', state: 'approved', requestedAt: 1 },
+ ] })).toEqual({ records: [{
+ id: '22222222-2222-4222-8222-222222222222', shareId: 'a', memberId: 'b', deviceId: 'c', key: CAROL, name: 'Carol', avatar: null, state: 'approved', requestedAt: 1,
+ }] });
+ });
+
+ it('does not silently truncate a valid record list at a fixed person count', () => {
+ const records = Array.from({ length: 4097 }, (_, index) => ({
+ id: index.toString(16).padStart(32, '0') + '0000',
+ shareId: 'a', memberId: 'b', deviceId: 'c',
+ key: index.toString(16).padStart(32, '0'),
+ name: 'Person', state: 'pending', requestedAt: 1,
+ }));
+ expect(reshare.__testing.normalize({ records }).records).toHaveLength(4097);
+ });
+});
diff --git a/apps/desktop/src/main/device-link/dispatch.ts b/apps/desktop/src/main/device-link/dispatch.ts
index 3f62dca9b7..fc83281b2b 100644
--- a/apps/desktop/src/main/device-link/dispatch.ts
+++ b/apps/desktop/src/main/device-link/dispatch.ts
@@ -392,14 +392,19 @@ export interface RemoteAgentHandler {
abortAll(): void;
/** 结束匹配控制端的任务(供应商分享被关闭)。 */
abortControllers?(match: (controller: string) => boolean): Promise<void>;
+ /** 结束匹配控制端替某个人(转分享键)转来的任务(转分享的同意被撤回)。 */
+ abortReshare?(match: (controller: string) => boolean, reshareKey: string): Promise<void>;
/** 结束并清理匹配控制端留在本机的数据(供应商分享被删除)。 */
purgeControllers?(match: (controller: string) => boolean): Promise<void>;
/** 有进行中任务的控制端。 */
activeControllers?(): string[];
/** 正在运行一轮的任务的控制端(每个任务一项)。 */
turnRunningControllers?(): string[];
- /** 分享详情的匿名组状态;不开放同账号组管理通道。 */
- sharedGroupStatus?(providerId: string): Promise<ProviderShareGroupState[] | null>;
+ /**
+ * 分享详情的匿名组状态;不开放同账号组管理通道。guestController 是读状态的受邀者:分享来的组内电脑按它的
+ * 主人是否同意过这个人显示(转分享)。
+ */
+ sharedGroupStatus?(providerId: string, guestController?: string): Promise<ProviderShareGroupState[] | null>;
}
let remoteAgentHandler: RemoteAgentHandler | null = null;
@@ -4189,7 +4194,7 @@ async function projectProviderShareRead(
const providers = result && typeof result === 'object' ? (result as { providers?: unknown }).providers : null;
const offered = Array.isArray(providers) && providers.some((p) => p?.id === providerId && p.remoteInvocationEnabled === true);
const states = wantsStatus && offered
- ? await remoteAgentHandler?.sharedGroupStatus?.(providerId).catch(() => null) ?? null
+ ? await remoteAgentHandler?.sharedGroupStatus?.(providerId, src).catch(() => null) ?? null
: null;
return { ok: true, value: projectProviderListForShare(result, providerId, providerShareGuestRunning(src), states) };
}
@@ -4348,6 +4353,17 @@ export async function revokeProviderShareControllers(
await (purge ? handler?.purgeControllers?.(guarded) : handler?.abortControllers?.(guarded));
}
+/**
+ * 转分享的同意被撤回(provider-sharing.md §4.3):结束受邀者的组替那个人转来的任务。连接不断(受邀者自己与它
+ * 分享的其他人照常用);只有分享的受邀者对端能匹配。
+ */
+export async function abortProviderShareReshareRuns(
+ match: (controller: string) => boolean,
+ reshareKey: string,
+): Promise<void> {
+ await remoteAgentHandler?.abortReshare?.((controller) => isProviderSharePeer(controller) && match(controller), reshareKey);
+}
+
async function runAuthorizedInvoke(
src: string, payload: InvokePayload | undefined, timing: RemoteInvokeTiming,
): Promise<InvokeResultPayload> {
diff --git a/apps/desktop/src/main/device-link/providerShareCrossRegion.ts b/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
index 752960de99..f4e9cf8b35 100644
--- a/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
+++ b/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
@@ -426,6 +426,17 @@ export function ensureCrossRegionReceivedForFavorites(regions: readonly Region[]
if (!state?.loaded && !state?.refreshing && !state?.timer) void refreshRegion(rt, region);
}
+/**
+ * 对方区域里本账号可能有的分享都已确认:标记过的对方区域(本账号在那里申请或加入过分享)名单都已成功返回。
+ * 没有标记的区域本来就没有分享。运行时没起来或已换账号时为 false(说不准)。
+ */
+export function isCrossRegionReceivedComplete(): boolean {
+ const rt = runtime;
+ if (!rt || !current(rt)) return false;
+ const marked = (readMarkers()[rt.account] ?? []).filter((region) => region === peerRegion());
+ return marked.every((region) => rt.regions.get(region)?.loaded === true);
+}
+
/** 只确认已成功返回名单的区域,失败区域不能阻塞其它区域的收藏。 */
export function getConfirmedCrossRegionReceivedRegions(): Region[] {
const rt = runtime;
diff --git a/apps/desktop/src/main/device-link/providerShareGuest.ts b/apps/desktop/src/main/device-link/providerShareGuest.ts
index a1bc81c173..56dc229581 100644
--- a/apps/desktop/src/main/device-link/providerShareGuest.ts
+++ b/apps/desktop/src/main/device-link/providerShareGuest.ts
@@ -35,6 +35,7 @@ import {
crossRegionWithdraw,
getCrossRegionReceived,
getConfirmedCrossRegionReceivedRegions,
+ isCrossRegionReceivedComplete,
isCrossRegionReceivedReady,
ensureCrossRegionReceivedForFavorites,
refreshProviderShareCrossRegion,
@@ -103,6 +104,9 @@ function allReceived(rt: Runtime | null): ProviderShareReceived[] {
return rt ? [...rt.received, ...getCrossRegionReceived()] : [];
}
+/** 已收到的分享变化的旁听者(见 onProviderShareReceivedChanged)。 */
+const receivedListeners = new Set<() => void>();
+
/** 已拿到权威名单的区域(本区域要拉到过一次;对方区域按跨区域运行时的已加载状态)。 */
function confirmedRegions(rt: Runtime): Region[] {
return [...(rt.fetchedAt > 0 ? [getActiveAuthRealm()] : []), ...getConfirmedCrossRegionReceivedRegions()];
@@ -114,12 +118,41 @@ function emitChanged(rt: Runtime): Promise<void> | void {
// 分享被分享者删除后,它在这台电脑上的本机偏好一起清掉;还没加载的区域不动。
const pruning = pruneProviderShareGuestPrefs(new Set(received.map((share) => share.shareId)), confirmedRegions(rt));
const notify = () => {
- if (current(rt)) rt.events.changed(received);
+ if (!current(rt)) return;
+ rt.events.changed(received);
+ for (const listener of receivedListeners) {
+ try {
+ listener();
+ } catch (error) {
+ log.warn('received shares listener failed', { error: error instanceof Error ? error.message : String(error) });
+ }
+ }
};
if (pruning) return pruning.then(notify);
notify();
}
+/**
+ * 已收到的分享变了:供应商组据此把已被删除或已退出的分享移出组(provider-groups.md §3)。只通知,不带内容;
+ * 读名单用 {@link getConfirmedReceivedShareIds}。
+ */
+export function onProviderShareReceivedChanged(listener: () => void): () => void {
+ receivedListeners.add(listener);
+ return () => {
+ receivedListeners.delete(listener);
+ };
+}
+
+/**
+ * 完整可信的已收到分享名单:本区域已拉到过,本账号可能有分享的对方区域也都已确认。只有这时才能据此认定某个分享
+ * 已被删除或已退出;说不准时为 null(还没拉到、拉取失败、换账号中)。
+ */
+export function getConfirmedReceivedShareIds(): ReadonlySet<string> | null {
+ const rt = runtime;
+ if (!rt || !current(rt) || rt.fetchedAt === 0 || !isCrossRegionReceivedComplete()) return null;
+ return new Set(allReceived(rt).map((share) => share.shareId));
+}
+
// ─── 任务绑定 ────────────────────────────────────────────────────
/** 任务记录里表示「Agent 在某个分享者的电脑上」的值。 */
diff --git a/apps/desktop/src/main/device-link/providerShareHost.ts b/apps/desktop/src/main/device-link/providerShareHost.ts
index e5635aa3e8..080d8017e6 100644
--- a/apps/desktop/src/main/device-link/providerShareHost.ts
+++ b/apps/desktop/src/main/device-link/providerShareHost.ts
@@ -69,6 +69,8 @@ interface Runtime {
}
let runtime: Runtime | null = null;
+/** 分享快照变化的旁听者(见 onProviderShareHostChanged)。 */
+const snapshotListeners = new Set<() => void>();
function current(rt: Runtime): boolean {
return runtime === rt && !rt.stopped && getAuthState().isAuthenticated && !isAppSessionBoundaryPending()
@@ -116,6 +118,31 @@ function applySnapshot(rt: Runtime, next: ProviderShareOwned[]): void {
}
}
rt.events.changed(next);
+ for (const listener of snapshotListeners) {
+ try {
+ listener();
+ } catch (error) {
+ log.warn('provider share snapshot listener failed', { error: error instanceof Error ? error.message : String(error) });
+ }
+ }
+}
+
+/**
+ * 分享快照变了(成员加入、暂停、删除等):供应商组的转分享据此重新报上分享的人(provider-sharing.md §4.3)。
+ * 只通知,不带内容;读最新的用 {@link getProviderShareHostLoadedSnapshot}。
+ */
+export function onProviderShareHostChanged(listener: () => void): () => void {
+ snapshotListeners.add(listener);
+ return () => {
+ snapshotListeners.delete(listener);
+ };
+}
+
+/** 已拉到过、仍属于当前账号的分享快照;还没拉到或已换账号时为 null(不能当成「没有分享给任何人」)。 */
+export function getProviderShareHostLoadedSnapshot(): readonly ProviderShareOwned[] | null {
+ const rt = runtime;
+ if (!rt || rt.fetchedAt === 0 || !current(rt)) return null;
+ return rt.shares;
}
export function startProviderShareHost(events: ProviderShareHostEvents): void {
diff --git a/apps/desktop/src/main/device-link/providerShareReshare.ts b/apps/desktop/src/main/device-link/providerShareReshare.ts
new file mode 100644
index 0000000000..1defdab604
--- /dev/null
+++ b/apps/desktop/src/main/device-link/providerShareReshare.ts
@@ -0,0 +1,454 @@
+/**
+ * 供应商分享 · 转分享的同意(分享者这台电脑;docs/product-rules/provider-sharing.md §4.3)。
+ *
+ * 受邀者把这里分享出去的供应商加进了它自己的供应商组,又把那个组分享给了别人:组转来的受邀者任务要在这台
+ * 运行,必须先由这台的主人逐人同意。受邀者的组所在电脑经远程 Agent 的 op `reshare` 把它分享的人整体报上来
+ * (整体替换那台上一份),新出现的人记成待处理;主人在「远程与分享」页同意或拒绝,之后随时可以撤回或改成同意。
+ *
+ * 记录按账号存在本机 `provider-share-reshare.json`,不经服务端:分享、成员与组所在电脑的设备 id、组所在电脑给的
+ * 不透明键,以及它转述的昵称与头像(只用来让主人认出是谁)。成员被删除或退出时,删掉它名下的全部记录。
+ */
+import { randomUUID } from 'node:crypto';
+
+import {
+ REMOTE_AGENT_RELAY_KEY_PATTERN,
+ REMOTE_AGENT_RESHARE_STATES,
+ parseProviderSharePeer,
+ type RemoteAgentReshareBatch,
+ type RemoteAgentReshareEntry,
+ type RemoteAgentReshareResult,
+ type RemoteAgentReshareState,
+} from '@cindy/device-link';
+
+import { activeOwnerScopeKey, ownerScopedUserDataPath } from '../appSessionState.js';
+import { createLogger } from '../logger.js';
+import { createOverrideSettingsFile } from '../maker-host/override-settings-file.js';
+import { providerShareGuestAccess } from './providerShareHost.js';
+
+const log = createLogger('provider-share:reshare');
+
+/** 组所在电脑(受邀者那台电脑)的身份:分享、成员与那台的设备 id(本地 peer key 里的三项)。 */
+export interface ProviderShareResharePeer {
+ shareId: string;
+ memberId: string;
+ deviceId: string;
+}
+
+export interface ProviderShareReshareRecord extends ProviderShareResharePeer {
+ /** 本机给这条记录取的 id(管理页操作用)。 */
+ id: string;
+ /** 组所在电脑为它分享的那个人取的不透明键(打开中转任务时随载荷带来)。 */
+ key: string;
+ name: string;
+ avatar: string | null;
+ state: RemoteAgentReshareState;
+ requestedAt: number;
+ decidedAt?: number;
+}
+
+interface ReshareFile {
+ records: ProviderShareReshareRecord[];
+}
+
+/** 文件按字节设硬上限;人数不按固定条数截断,超限时原子写入失败并保留旧快照。 */
+const RESHARE_STORE_MAX_BYTES = 4 * 1024 * 1024;
+/** 未收齐的分片只在内存保留一小段时间;新批次会替换同一组所在电脑的旧批次。 */
+const RESHARE_BATCH_TTL_MS = 10 * 60_000;
+/** 未完成批次按序列化后的条目字节数计入全局预算,避免多个来源共同耗尽主进程内存。 */
+const RESHARE_BATCH_MEMORY_BUDGET_BYTES = 16 * 1024 * 1024;
+const RESHARE_BATCH_METADATA_BYTES = 512;
+const ID_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
+const RECORD_ID = /^[0-9a-f-]{36}$/;
+
+function text(value: unknown, max: number): string | null {
+ if (typeof value !== 'string') return null;
+ const trimmed = value.trim();
+ // eslint-disable-next-line no-control-regex -- 控制字符是显式拒绝目标
+ return trimmed && trimmed.length <= max && !/[\u0000-\u001f\u007f]/.test(trimmed) ? trimmed : null;
+}
+
+function avatar(value: unknown): string | null {
+ if (typeof value !== 'string' || !value || value.length > 2048) return null;
+ try {
+ return new URL(value).protocol === 'https:' ? value : null;
+ } catch {
+ return null;
+ }
+}
+
+function normalizeRecord(raw: unknown): ProviderShareReshareRecord | null {
+ if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+ const value = raw as Record<string, unknown>;
+ const name = text(value.name, 128);
+ if (
+ typeof value.id !== 'string' || !RECORD_ID.test(value.id)
+ || typeof value.shareId !== 'string' || !ID_PATTERN.test(value.shareId)
+ || typeof value.memberId !== 'string' || !ID_PATTERN.test(value.memberId)
+ || typeof value.deviceId !== 'string' || !ID_PATTERN.test(value.deviceId)
+ || typeof value.key !== 'string' || !REMOTE_AGENT_RELAY_KEY_PATTERN.test(value.key)
+ || !name
+ || !(REMOTE_AGENT_RESHARE_STATES as readonly unknown[]).includes(value.state)
+ || typeof value.requestedAt !== 'number' || !Number.isFinite(value.requestedAt)
+ ) return null;
+ return {
+ id: value.id,
+ shareId: value.shareId,
+ memberId: value.memberId,
+ deviceId: value.deviceId,
+ key: value.key,
+ name,
+ avatar: avatar(value.avatar),
+ state: value.state as RemoteAgentReshareState,
+ requestedAt: value.requestedAt,
+ ...(typeof value.decidedAt === 'number' && Number.isFinite(value.decidedAt) ? { decidedAt: value.decidedAt } : {}),
+ };
+}
+
+function normalize(raw: unknown): ReshareFile {
+ const source = (raw as Partial<ReshareFile> | null)?.records;
+ if (!Array.isArray(source)) return { records: [] };
+ const records: ProviderShareReshareRecord[] = [];
+ const seen = new Set<string>();
+ for (const entry of source) {
+ const record = normalizeRecord(entry);
+ if (!record) continue;
+ const scope = `${scopeOf(record)}\0${record.key}`;
+ if (seen.has(record.id) || seen.has(scope)) continue;
+ seen.add(record.id);
+ seen.add(scope);
+ records.push(record);
+ }
+ return { records };
+}
+
+function scopeOf(peer: ProviderShareResharePeer): string {
+ return `${peer.shareId}\0${peer.memberId}\0${peer.deviceId}`;
+}
+
+function samePeer(record: ProviderShareResharePeer, peer: ProviderShareResharePeer): boolean {
+ return record.shareId === peer.shareId && record.memberId === peer.memberId && record.deviceId === peer.deviceId;
+}
+
+const store = createOverrideSettingsFile<ReshareFile>({
+ filePath: () => ownerScopedUserDataPath('provider-share-reshare.json'),
+ scopeKey: activeOwnerScopeKey,
+ defaults: { records: [] },
+ normalize,
+ log,
+ label: 'provider-share-reshare',
+ maxBytes: RESHARE_STORE_MAX_BYTES,
+ // 记录里有别人的昵称与头像:不进日志。
+ logLoadedValue: false,
+});
+
+function read(): ProviderShareReshareRecord[] {
+ store.invalidateIfChanged();
+ return store.read().records;
+}
+
+export interface ProviderShareReshareSyncResult {
+ result: RemoteAgentReshareResult;
+ /** 新出现、等主人处理的人。 */
+ added: ProviderShareReshareRecord[];
+ /** 组所在电脑不再报上来的人里已经同意过的(要结束他们经组转来的任务)。 */
+ droppedApproved: ProviderShareReshareRecord[];
+ /** 管理页可见的记录集合或展示字段发生变化。 */
+ changed: boolean;
+}
+
+/**
+ * 组所在电脑报上它此刻分享的人(整体替换这台组所在电脑上一份):已有的人保留主人的决定,只更新昵称与头像;
+ * 新出现的人记成待处理;不再报上来的人删掉(那人已不在它的分享里,或那台已把这台移出组)。
+ */
+export async function syncProviderShareReshare(
+ peer: ProviderShareResharePeer,
+ entries: readonly RemoteAgentReshareEntry[],
+ now = Date.now(),
+): Promise<ProviderShareReshareSyncResult> {
+ const added: ProviderShareReshareRecord[] = [];
+ const droppedApproved: ProviderShareReshareRecord[] = [];
+ let changed = false;
+ const next = await store.updateAtomic(({ value }) => {
+ const wanted = new Map(entries.map((entry) => [entry.key, entry]));
+ const records: ProviderShareReshareRecord[] = [];
+ for (const record of value.records) {
+ if (!samePeer(record, peer)) {
+ records.push(record);
+ continue;
+ }
+ const entry = wanted.get(record.key);
+ if (!entry) {
+ changed = true;
+ if (record.state === 'approved') droppedApproved.push(record);
+ continue;
+ }
+ wanted.delete(record.key);
+ const nextRecord = { ...record, name: entry.name, avatar: entry.avatar ?? null };
+ if (nextRecord.name !== record.name || nextRecord.avatar !== record.avatar) changed = true;
+ records.push(nextRecord);
+ }
+ for (const entry of wanted.values()) {
+ const record: ProviderShareReshareRecord = {
+ id: randomUUID(),
+ ...peer,
+ key: entry.key,
+ name: entry.name,
+ avatar: entry.avatar ?? null,
+ state: 'pending',
+ requestedAt: now,
+ };
+ added.push(record);
+ changed = true;
+ records.push(record);
+ }
+ return { records };
+ });
+ const states = new Map(next.records.filter((record) => samePeer(record, peer)).map((record) => [record.key, record.state]));
+ return {
+ result: {
+ entries: entries.flatMap((entry) => {
+ const state = states.get(entry.key);
+ return state ? [{ key: entry.key, state }] : [];
+ }),
+ },
+ added,
+ droppedApproved,
+ changed,
+ };
+}
+
+/** 组转来的受邀者任务能不能在这台运行:主人同意过这台组所在电脑报上来的这个人。 */
+export function isProviderShareReshareApproved(peer: ProviderShareResharePeer, key: string | undefined): boolean {
+ if (!key) return false;
+ return read().some((record) => samePeer(record, peer) && record.key === key && record.state === 'approved');
+}
+
+/** 主人同意或拒绝(拒绝已同意的 = 撤回)。返回改动后的记录与之前的状态;记录不在了返回 null。 */
+export async function decideProviderShareReshare(
+ id: string,
+ decision: 'approve' | 'reject',
+ now = Date.now(),
+): Promise<{ record: ProviderShareReshareRecord; previous: RemoteAgentReshareState } | null> {
+ let changed: { record: ProviderShareReshareRecord; previous: RemoteAgentReshareState } | null = null;
+ await store.updateAtomic(({ value }) => ({
+ records: value.records.map((record) => {
+ if (record.id !== id) return record;
+ const next: ProviderShareReshareRecord = {
+ ...record,
+ state: decision === 'approve' ? 'approved' : 'rejected',
+ decidedAt: now,
+ };
+ changed = { record: next, previous: record.state };
+ return next;
+ }),
+ }));
+ return changed;
+}
+
+export function listProviderShareReshares(): readonly ProviderShareReshareRecord[] {
+ return read();
+}
+
+/** 删掉匹配的记录(成员被删除或退出、分享已不在这台)。返回删掉的。 */
+export async function pruneProviderShareReshares(
+ match: (record: ProviderShareReshareRecord) => boolean,
+): Promise<ProviderShareReshareRecord[]> {
+ if (!read().some(match)) return [];
+ const removed: ProviderShareReshareRecord[] = [];
+ await store.updateAtomic(({ value }) => ({
+ records: value.records.filter((record) => {
+ if (!match(record)) return true;
+ removed.push(record);
+ return false;
+ }),
+ }));
+ return removed;
+}
+
+// ─── 远程 Agent op `reshare` 与本机接线 ─────────────────────────────
+
+export interface ProviderShareReshareEvents {
+ /** 新出现、等主人处理的人(待处理一栏与系统通知)。 */
+ requested(records: readonly ProviderShareReshareRecord[]): void;
+ /** 记录变了(管理页重读)。 */
+ changed(): void;
+ /** 这些人不再被同意(撤回、组所在电脑不再报上来):结束他们经组转来的任务。 */
+ revoked(records: readonly ProviderShareReshareRecord[]): void;
+}
+
+let events: ProviderShareReshareEvents | null = null;
+
+interface PendingReshareBatch {
+ batch: RemoteAgentReshareBatch;
+ chunks: Map<number, RemoteAgentReshareEntry[]>;
+ bytes: number;
+ touchedAt: number;
+}
+
+const pendingBatches = new Map<string, PendingReshareBatch>();
+const completedBatches = new Map<string, { batch: RemoteAgentReshareBatch; touchedAt: number }>();
+/** 同一来源的片段按到达顺序处理,避免旧批次完成回写覆盖刚开始的新批次。 */
+const reshareLocks = new Map<string, Promise<void>>();
+let pendingBatchBytes = 0;
+
+function entriesBytes(entries: readonly RemoteAgentReshareEntry[]): number {
+ return Buffer.byteLength(JSON.stringify(entries), 'utf8');
+}
+
+function removePendingBatch(batchKey: string): void {
+ const pending = pendingBatches.get(batchKey);
+ if (!pending) return;
+ pendingBatches.delete(batchKey);
+ pendingBatchBytes -= pending.bytes + RESHARE_BATCH_METADATA_BYTES;
+}
+
+function pruneBatchState(now: number): void {
+ for (const [batchKey, pending] of pendingBatches) {
+ if (now - pending.touchedAt > RESHARE_BATCH_TTL_MS) removePendingBatch(batchKey);
+ }
+ for (const [batchKey, completed] of completedBatches) {
+ if (now - completed.touchedAt > RESHARE_BATCH_TTL_MS) completedBatches.delete(batchKey);
+ }
+}
+
+function sameEntries(left: readonly RemoteAgentReshareEntry[], right: readonly RemoteAgentReshareEntry[]): boolean {
+ return left.length === right.length && left.every((entry, index) => {
+ const other = right[index];
+ return !!other && entry.key === other.key && entry.name === other.name && entry.avatar === other.avatar;
+ });
+}
+
+function provisionalStates(
+ peer: ProviderShareResharePeer,
+ entries: readonly RemoteAgentReshareEntry[],
+): RemoteAgentReshareResult['entries'] {
+ const states = new Map(read().filter((record) => samePeer(record, peer)).map((record) => [record.key, record.state]));
+ return entries.map((entry) => ({ key: entry.key, state: states.get(entry.key) ?? 'pending' }));
+}
+
+/** providerShareRuntime 启动时接上,停止时清掉。 */
+export function setProviderShareReshareEvents(next: ProviderShareReshareEvents | null): void {
+ events = next;
+ if (!next) {
+ pendingBatches.clear();
+ completedBatches.clear();
+ pendingBatchBytes = 0;
+ }
+}
+
+/** 受邀者对端 → 组所在电脑的身份;不是受邀者返回 null。 */
+export function providerShareResharePeerOf(controller: string): ProviderShareResharePeer | null {
+ const peer = parseProviderSharePeer(controller);
+ return peer?.role === 'guest' ? { shareId: peer.shareId, memberId: peer.memberId, deviceId: peer.deviceId } : null;
+}
+
+/**
+ * 远程 Agent 的 op `reshare`(调用方已按分享准入):记下组所在电脑此刻分享的人,返回每个人的结果。
+ * 只有受邀者能报,同账号电脑经组使用不需要同意。
+ */
+async function handleProviderShareReshareNow(
+ controller: string,
+ entries: readonly RemoteAgentReshareEntry[],
+ batch?: RemoteAgentReshareBatch,
+): Promise<RemoteAgentReshareResult> {
+ const peer = providerShareResharePeerOf(controller);
+ if (!peer || !providerShareGuestAccess(controller)) throw new Error('[REMOTE_AGENT_INVALID] reshare is only for shared users');
+ if (batch) {
+ const batchKey = scopeOf(peer);
+ const now = Date.now();
+ pruneBatchState(now);
+ const completed = completedBatches.get(batchKey);
+ if (completed && completed.batch.id === batch.id && completed.batch.count === batch.count) {
+ // 完成后的重发只需重读当前条目的已落盘状态,避免再次替换或新增待处理记录。
+ return { entries: provisionalStates(peer, entries), batch: { ...batch, complete: true } };
+ }
+ const previous = pendingBatches.get(batchKey);
+ const expired = previous && now - previous.touchedAt > RESHARE_BATCH_TTL_MS;
+ if (!previous || expired || previous.batch.id !== batch.id || previous.batch.count !== batch.count) {
+ if (previous) removePendingBatch(batchKey);
+ const firstChunkBytes = entriesBytes(entries);
+ if (pendingBatchBytes + RESHARE_BATCH_METADATA_BYTES + firstChunkBytes > RESHARE_BATCH_MEMORY_BUDGET_BYTES) {
+ throw new Error('[REMOTE_AGENT_BUSY] reshare batch memory budget exceeded');
+ }
+ pendingBatches.set(batchKey, { batch, chunks: new Map(), bytes: 0, touchedAt: now });
+ pendingBatchBytes += RESHARE_BATCH_METADATA_BYTES;
+ }
+ const pending = pendingBatches.get(batchKey)!;
+ pending.touchedAt = now;
+ const existing = pending.chunks.get(batch.index);
+ if (existing) {
+ if (!sameEntries(existing, entries)) throw new Error('[REMOTE_AGENT_INVALID] conflicting duplicate reshare batch chunk');
+ } else {
+ const chunk = [...entries];
+ const chunkBytes = entriesBytes(chunk);
+ if (pendingBatchBytes + chunkBytes > RESHARE_BATCH_MEMORY_BUDGET_BYTES) {
+ throw new Error('[REMOTE_AGENT_BUSY] reshare batch memory budget exceeded');
+ }
+ pending.chunks.set(batch.index, chunk);
+ pending.bytes += chunkBytes;
+ pendingBatchBytes += chunkBytes;
+ }
+ if (pending.chunks.size < pending.batch.count) {
+ return { entries: provisionalStates(peer, entries), batch: { ...batch, complete: false } };
+ }
+ const allEntries: RemoteAgentReshareEntry[] = [];
+ for (let index = 0; index < pending.batch.count; index += 1) {
+ const chunk = pending.chunks.get(index);
+ if (!chunk) return { entries: provisionalStates(peer, entries), batch: { ...batch, complete: false } };
+ allEntries.push(...chunk);
+ }
+ if (new Set(allEntries.map((entry) => entry.key)).size !== allEntries.length) {
+ removePendingBatch(batchKey);
+ throw new Error('[REMOTE_AGENT_INVALID] duplicate reshare key across batch');
+ }
+ const synced = await syncProviderShareReshare(peer, allEntries);
+ removePendingBatch(batchKey);
+ completedBatches.set(batchKey, { batch, touchedAt: now });
+ if (synced.droppedApproved.length > 0) events?.revoked(synced.droppedApproved);
+ if (synced.added.length > 0) events?.requested(synced.added);
+ else if (synced.changed) events?.changed();
+ const states = new Map(synced.result.entries.map((entry) => [entry.key, entry.state]));
+ return {
+ entries: entries.flatMap((entry) => {
+ const state = states.get(entry.key);
+ return state ? [{ key: entry.key, state }] : [];
+ }),
+ batch: { ...batch, complete: true },
+ };
+ }
+ const synced = await syncProviderShareReshare(peer, entries);
+ if (synced.droppedApproved.length > 0) events?.revoked(synced.droppedApproved);
+ if (synced.added.length > 0) events?.requested(synced.added);
+ else if (synced.changed) events?.changed();
+ return synced.result;
+}
+
+/** 同一来源上的并发片段必须串行,避免旧批次的慢落盘结果覆盖后到的新批次。 */
+export function handleProviderShareReshare(
+ controller: string,
+ entries: readonly RemoteAgentReshareEntry[],
+ batch?: RemoteAgentReshareBatch,
+): Promise<RemoteAgentReshareResult> {
+ const peer = providerShareResharePeerOf(controller);
+ if (!peer || !providerShareGuestAccess(controller)) {
+ return Promise.reject(new Error('[REMOTE_AGENT_INVALID] reshare is only for shared users'));
+ }
+ const batchKey = scopeOf(peer);
+ const previous = reshareLocks.get(batchKey) ?? Promise.resolve();
+ let release!: () => void;
+ const current = new Promise<void>((resolve) => { release = resolve; });
+ reshareLocks.set(batchKey, current);
+ const run = previous.then(() => handleProviderShareReshareNow(controller, entries, batch));
+ return run.finally(() => {
+ release();
+ if (reshareLocks.get(batchKey) === current) reshareLocks.delete(batchKey);
+ });
+}
+
+/** 组转来的受邀者任务能不能在这台运行(远程 Agent 打开任务时核对)。 */
+export function providerShareReshareAllows(controller: string, key: string | undefined): boolean {
+ const peer = providerShareResharePeerOf(controller);
+ return !!peer && isProviderShareReshareApproved(peer, key);
+}
+
+export const __testing = { normalize };
diff --git a/apps/desktop/src/main/device-link/providerShareRuntime.ts b/apps/desktop/src/main/device-link/providerShareRuntime.ts
index cc83860f09..848fdbb880 100644
--- a/apps/desktop/src/main/device-link/providerShareRuntime.ts
+++ b/apps/desktop/src/main/device-link/providerShareRuntime.ts
@@ -42,6 +42,7 @@ import { rememberIssuedClipboardText } from '../textClipboard.js';
import { ownerScopedUserDataPath } from '../appSessionState.js';
import { throwIpcError } from '../utils/ipcValidate.js';
import {
+ abortProviderShareReshareRuns,
getControllerDisplayName,
providerShareActiveControllers,
revokeProviderShareControllers,
@@ -82,6 +83,15 @@ import {
startProviderShareHost,
stopProviderShareHost,
} from './providerShareHost.js';
+import {
+ decideProviderShareReshare,
+ listProviderShareReshares,
+ pruneProviderShareReshares,
+ setProviderShareReshareEvents,
+ type ProviderShareResharePeer,
+ type ProviderShareReshareEvents,
+ type ProviderShareReshareRecord,
+} from './providerShareReshare.js';
import { getProviderShareUsageStore } from './providerShareUsageStore.js';
import { readDeviceLinkSettings, readLastKnownDeviceNames } from './settings-store.js';
import { currentProviderPartyUsageStore, type ProviderPartyUsage } from '../usage/providerPartyUsageStore.js';
@@ -151,12 +161,63 @@ function revoke(match: (controller: string) => boolean, purge: boolean): void {
});
}
+/** 转分享记录所属的那台组所在电脑(受邀者对端)。 */
+function reshareControllerMatcher(record: ProviderShareResharePeer): (controller: string) => boolean {
+ return (controller) => {
+ const peer = parseProviderSharePeer(controller);
+ return peer?.role === 'guest' && peer.shareId === record.shareId && peer.memberId === record.memberId
+ && peer.deviceId === record.deviceId;
+ };
+}
+
+/** 撤回了对这些人的同意:结束受邀者的组替他们转来的任务(provider-sharing.md §4.3)。 */
+function abortReshares(records: readonly ProviderShareReshareRecord[]): void {
+ for (const record of records) {
+ void abortProviderShareReshareRuns(reshareControllerMatcher(record), record.key).catch((error) => {
+ log.warn('provider share reshare abort failed', { error: error instanceof Error ? error.message : String(error) });
+ });
+ }
+}
+
+/** 删掉成员(或已不在这台的分享)名下的转分享记录;删了就让管理页重读。 */
+function pruneReshares(match: (record: ProviderShareReshareRecord) => boolean): void {
+ void pruneProviderShareReshares(match).then((removed) => {
+ if (removed.length > 0) emit(PROVIDER_SHARE_IPC.OWNED_CHANGED, null);
+ }).catch((error: unknown) => {
+ log.warn('provider share reshare cleanup failed', { error: error instanceof Error ? error.message : String(error) });
+ });
+}
+
+const reshareEvents: ProviderShareReshareEvents = {
+ requested(records) {
+ emit(PROVIDER_SHARE_IPC.OWNED_CHANGED, null);
+ emit(PROVIDER_SHARE_IPC.RESHARE_REQUESTED, null);
+ const first = records[0];
+ if (!first) return;
+ const share = getProviderShareHostSnapshot().find((item) => item.shareId === first.shareId);
+ const owner = share?.members.find((member) => member.memberId === first.memberId)?.displayName ?? '';
+ if (!share) return;
+ void notify(
+ t('providerShare.notification.reshareTitle'),
+ format(t('providerShare.notification.reshareBody'), { owner, name: first.name, provider: share.providerLabel }),
+ () => emit(PROVIDER_SHARE_IPC.OPEN_MANAGE, { providerId: share.providerId }),
+ );
+ },
+ changed() {
+ emit(PROVIDER_SHARE_IPC.OWNED_CHANGED, null);
+ },
+ revoked(records) {
+ abortReshares(records);
+ },
+};
+
/** 设备互联连上(本实例持有连接)时启动;断开、登出或失去持有权时停止。 */
export function startProviderShareRuntime(broadcast: Broadcast, options: { invoke?: ShareInvoke } = {}): void {
invalidateProviderShareGuestPrefsCache();
broadcastFn = broadcast;
shareInvoke = options.invoke ?? null;
running = true;
+ setProviderShareReshareEvents(reshareEvents);
startProviderShareHost({
changed() {
emit(PROVIDER_SHARE_IPC.OWNED_CHANGED, null);
@@ -174,6 +235,8 @@ export function startProviderShareRuntime(broadcast: Broadcast, options: { invok
},
revoked(member, purge) {
revoke(providerShareMemberMatcher(member), purge);
+ // 成员被删除或退出:他报上来的转分享请求一并删掉(暂停时保留,恢复后照旧)。
+ if (purge) pruneReshares((record) => record.shareId === member.shareId && record.memberId === member.memberId);
},
reconcile(owned) {
// 分享者电脑离线期间被删除或退出的成员:清理他们留在本机的会话数据。
@@ -183,6 +246,8 @@ export function startProviderShareRuntime(broadcast: Broadcast, options: { invok
const members = owned.get(peer.shareId);
return !!members && !members.has(peer.memberId);
}, true);
+ // 转分享记录按账号存放,只会属于这台电脑上的分享:已不在快照里的成员与分享一并删掉。
+ pruneReshares((record) => !owned.get(record.shareId)?.has(record.memberId));
},
});
startProviderShareGuest({
@@ -207,6 +272,7 @@ export function stopProviderShareRuntime(): void {
invalidateProviderShareGuestPrefsCache();
running = false;
shareInvoke = null;
+ setProviderShareReshareEvents(null);
stopProviderShareHost();
stopProviderShareGuest();
emit(PROVIDER_SHARE_IPC.OWNED_CHANGED, null);
@@ -247,6 +313,11 @@ function parseCommand(raw: unknown): ProviderShareCommand {
if (status !== 'pause' && status !== 'resume' && status !== 'remove') throwIpcError('INVALID_PARAMS', 'Invalid status');
return { action: 'set-member', memberId: text(value.memberId, 'memberId', 128), status };
}
+ case 'reshare-decide': {
+ const decision = value.decision;
+ if (decision !== 'approve' && decision !== 'reject') throwIpcError('INVALID_PARAMS', 'Invalid decision');
+ return { action: 'reshare-decide', id: text(value.id, 'id', 64), decision };
+ }
case 'received':
return { action: 'received' };
case 'received-snapshot': {
@@ -292,6 +363,7 @@ async function ownerState(range: ProviderShareUsageRange): Promise<ProviderShare
if (!running) return { ready: false, shares: [] };
const shares = getProviderShareHostSnapshot();
const usage = getProviderShareUsageStore()?.query(new Set(shares.map((share) => share.shareId)), range) ?? [];
+ const reshares = listProviderShareReshares();
const runningTasks = new Map<string, number>();
for (const controller of providerShareActiveControllers()) {
const peer = parseProviderSharePeer(controller);
@@ -313,6 +385,16 @@ async function ownerState(range: ProviderShareUsageRange): Promise<ProviderShare
...member,
lastUsedAt: record?.lastUsedAt ?? null,
runningTasks: runningTasks.get(`${share.shareId}\u0000${member.memberId}`) ?? 0,
+ reshares: reshares
+ .filter((item) => item.shareId === share.shareId && item.memberId === member.memberId)
+ .map((item) => ({
+ id: item.id,
+ name: item.name,
+ avatarUrl: item.avatar,
+ state: item.state,
+ requestedAt: item.requestedAt,
+ decidedAt: item.decidedAt ?? null,
+ })),
models: await Promise.all((record?.models ?? []).map(async (model) => ({
kind: model.kind,
providerId: model.providerId,
@@ -415,6 +497,14 @@ async function execute(command: ProviderShareCommand): Promise<unknown> {
void refreshProviderShareHost('member');
return { ok: true };
}
+ case 'reshare-decide': {
+ // 只改本机记录(不经服务端);撤回立即结束这个人经组转来的任务。
+ const decided = await decideProviderShareReshare(command.id, command.decision);
+ if (!decided) throwIpcError('NOT_FOUND', 'This request is no longer pending');
+ if (decided.previous === 'approved' && decided.record.state !== 'approved') abortReshares([decided.record]);
+ emit(PROVIDER_SHARE_IPC.OWNED_CHANGED, null);
+ return { ok: true };
+ }
case 'received':
if (running) void refreshReceivedShares('ui');
return getReceivedShares();
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/providerHandlers.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/providerHandlers.test.ts
index 3e459df325..39e100e102 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/providerHandlers.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/providerHandlers.test.ts
@@ -3348,7 +3348,9 @@ describe('provider:custom:* CRUD handlers', () => {
const harness = new IpcHarness();
const calls: string[] = [];
const keys = new Map<AgentKind, string>();
+ const kickProviderGroupReshare = vi.fn();
const deps = makeDeps({
+ kickProviderGroupReshare,
oauthCancel: vi.fn(() => calls.push('cancel')),
removeOAuthCredentials: vi.fn(() => {
calls.push('clear');
@@ -3378,6 +3380,7 @@ describe('provider:custom:* CRUD handlers', () => {
expect(await listCustomProviders()).toEqual([]);
expect(keys.size).toBe(0);
expect(calls).toEqual(['cancel', 'clear']);
+ expect(kickProviderGroupReshare).toHaveBeenCalledWith('provider-delete');
expect(deps.stageClearProviderModelPriceOverrides).toHaveBeenCalledWith('openrouter');
expect(deps.broadcastPricingChanged).toHaveBeenCalled();
diff --git a/apps/desktop/src/main/maker-ipc/providerHandlers.ts b/apps/desktop/src/main/maker-ipc/providerHandlers.ts
index 98d308c78f..4ff55184ba 100644
--- a/apps/desktop/src/main/maker-ipc/providerHandlers.ts
+++ b/apps/desktop/src/main/maker-ipc/providerHandlers.ts
@@ -289,6 +289,11 @@ export interface ProviderHandlerDeps {
beginRouteMutation(providerId: string): (() => void) & { commit?: () => void };
/** CRUD 成功后广播变更(生产 = 向所有窗口 send PROVIDER_CHANGED)。 */
broadcastChanged(): void;
+ /**
+ * 自定义供应商删除后立即让供应商组转分享同步;删除组配置本身是异步落盘,不能等下一轮轮询。
+ * 生产接线为 providerGroupReshare.kick,单测可注入内存桩。
+ */
+ kickProviderGroupReshare?(reason: string): void;
/** Non-sensitive spawn-config signature for one custom Provider config. */
codexCustomProviderConfigSignature?(config: CustomProviderConfig): string;
/** Force-retire the shared local Codex Host and hold its change guard before mutation. */
@@ -2270,7 +2275,10 @@ export function registerProviderHandlers(
deps.broadcastPricingChanged();
// 删除连接即删除它的供应商组(provider-groups.md §3):同名重建会得到同一个 id,不能让旧组复活。
await writeProviderGroup(providerId, null)
- .then(() => pruneProviderGroupBindings(providerId, null))
+ .then(() => {
+ deps.kickProviderGroupReshare?.('provider-delete');
+ return pruneProviderGroupBindings(providerId, null);
+ })
.catch((error) => {
log.warn('provider group cleanup after provider deletion failed', {
providerId,
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 04f2b1432d..3e55773f70 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -71,6 +71,7 @@ import { createProviderGroupHeldTurnErrors } from '../provider-group/heldTurnErr
import { createProviderGroupHeldWorkerTerminals } from '../provider-group/heldWorkerTerminals.js';
import { providerGroupSwitchCause } from '../provider-group/failurePolicy.js';
import { listProviderGroups, readProviderGroup } from '../provider-group/store.js';
+import { providerGroupReshare } from '../provider-group/reshareRuntime.js';
import {
isRemoteProviderInvocationAllowed,
setRemoteProviderInvocationEnabled,
@@ -6651,6 +6652,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
cancelCodexCustomProviderHostChange: cancelCodexAuthModeChange,
beginRouteMutation: (providerId) => beginProviderRouteMutation(providerId),
broadcastChanged: () => broadcastToAllWindows(MAKER_PUSH.PROVIDER_CHANGED, {}),
+ kickProviderGroupReshare: (reason) => providerGroupReshare.kick(reason),
listProviderIds: () => getDesktopSelectableCatalog().providers.map((provider) => provider.id),
setProviderOrder: (providerIds) => setProviderOrder(providerIds),
getProviderOrder: () => readProviderOrder(),
diff --git a/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts b/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
index 069f88102d..4f6c9f387b 100644
--- a/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/guestRelay.test.ts
@@ -6,7 +6,7 @@ import { describe, expect, it, vi } from 'vitest';
import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/providerGroup';
import { createProviderGroupExternalLoad } from '../externalLoad';
-import { createProviderGroupGuestRelay, PROVIDER_GROUP_GUEST_INCAPABLE_MS } from '../guestRelay';
+import { createProviderGroupGuestRelay, PROVIDER_GROUP_GUEST_INCAPABLE_MS, type ProviderGroupGuestRelayDeps } from '../guestRelay';
import { PROVIDER_GROUP_MAX_REMOTE_COOLDOWN_MS } from '../remoteHandler';
import { PROVIDER_GROUP_DEFAULT_COOLDOWN_MS, type ProviderGroupPickInput, type ProviderGroupRouter } from '../router';
@@ -19,7 +19,11 @@ const MINI = member('device:mini:anthropic-2', 'device', 'mini', 'anthropic-2');
const FRIEND = member('share:s1:anthropic', 'share', 'share:s1', 'anthropic');
const CONFIG: ProviderGroupConfig = { strategy: 'order', autoSwitch: true, members: [LOCAL, MINI, FRIEND] };
-function setup(picks: ProviderGroupMember[], config: ProviderGroupConfig = CONFIG) {
+function setup(
+ picks: ProviderGroupMember[],
+ config: ProviderGroupConfig = CONFIG,
+ extra: Partial<Pick<ProviderGroupGuestRelayDeps, 'reshareAllows' | 'noteReshareDenied' | 'reshareNeedsUpdate'>> = {},
+) {
let now = 1_000;
let current = true;
const router = {
@@ -44,6 +48,7 @@ function setup(picks: ProviderGroupMember[], config: ProviderGroupConfig = CONFI
connect: () => ({ invoke, poller: {} as never }),
now: () => now,
log: { warn: vi.fn() },
+ ...extra,
});
return {
relay,
@@ -80,6 +85,28 @@ describe('provider group guest relay planner', () => {
expect((await env.relay.plan(PLAN))).toMatchObject({ memberKey: MINI.key });
});
+ // 转分享(provider-sharing.md §4.3):分享来的电脑只给它的主人同意过的人;同账号电脑与本机不受影响。
+ it('skips a shared-in computer whose owner has not agreed to this shared user', async () => {
+ const allowed = new Set<string>();
+ const reshareAllows = vi.fn((agentDeviceId: string, key: string | undefined) => !!key && allowed.has(`${agentDeviceId}|${key}`));
+ const env = setup([FRIEND, MINI], CONFIG, { reshareAllows });
+ const KEY = 'a1b2c3d4e5f60718293a4b5c6d7e8f90';
+ expect(await env.relay.plan({ ...PLAN, reshareKey: KEY })).toMatchObject({ memberKey: MINI.key });
+ expect(env.router.pick.mock.calls[0][0].exclude.has(FRIEND.key)).toBe(true);
+ // 不知道是谁(没有键)时一律不选分享来的电脑。
+ expect(await env.relay.plan(PLAN)).toMatchObject({ memberKey: MINI.key });
+ allowed.add(`share:s1|${KEY}`);
+ expect(await env.relay.plan({ ...PLAN, reshareKey: KEY })).toMatchObject({ memberKey: FRIEND.key, sameAccount: false });
+ expect(await env.relay.plan({ ...PLAN, reshareKey: 'b1b2c3d4e5f60718293a4b5c6d7e8f90' })).toMatchObject({ memberKey: MINI.key });
+ });
+
+ it('passes a refusal from the shared-in computer on so consent is checked again', () => {
+ const noteReshareDenied = vi.fn();
+ const env = setup([FRIEND], CONFIG, { noteReshareDenied });
+ env.relay.noteReshareDenied?.('share:s1', 'a1b2c3d4e5f60718293a4b5c6d7e8f90');
+ expect(noteReshareDenied).toHaveBeenCalledWith('share:s1', 'a1b2c3d4e5f60718293a4b5c6d7e8f90');
+ });
+
it('cools a computer only for problems with its account, not when it cannot be reached', async () => {
const env = setup([MINI]);
const mini = { memberKey: MINI.key, agentDeviceId: 'mini', providerId: MINI.providerId, sameAccount: true };
diff --git a/apps/desktop/src/main/provider-group/__tests__/removedShares.test.ts b/apps/desktop/src/main/provider-group/__tests__/removedShares.test.ts
new file mode 100644
index 0000000000..5b195bb6e8
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/removedShares.test.ts
@@ -0,0 +1,93 @@
+/**
+ * 原分享被删除或已退出(provider-groups.md §3):已收到的分享名单完整可信时,组里指向已不在的分享的电脑移出组;
+ * 名单说不准时什么都不动,分享只是暂停(仍在名单里)时保留。
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/providerGroup';
+import { pruneRemovedShareMembers, type PruneRemovedShareMembersDeps } from '../removedShares';
+
+function member(key: string, kind: ProviderGroupMember['kind'], agentDeviceId: string | null): ProviderGroupMember {
+ return { key, kind, agentDeviceId, providerId: 'anthropic', limit: 4, weight: 1, paused: false };
+}
+
+const LOCAL = member('local', 'local', null);
+const MINI = member('device:mini:anthropic', 'device', 'mini');
+const FROM_A = member('share:a1:anthropic', 'share', 'share:a1');
+const FROM_D = member('share:d1:anthropic', 'share', 'share:d1');
+
+function setup(received: ReadonlySet<string> | null) {
+ let groups: Record<string, ProviderGroupConfig> = {
+ anthropic: { strategy: 'least', autoSwitch: true, members: [LOCAL, MINI, FROM_A, FROM_D] },
+ openai: { strategy: 'least', autoSwitch: true, members: [{ ...LOCAL, providerId: 'openai' }] },
+ };
+ const writeGroup = vi.fn(async (providerId: string, config: unknown) => {
+ groups = { ...groups, [providerId]: config as ProviderGroupConfig };
+ return config;
+ });
+ const deps: PruneRemovedShareMembersDeps = {
+ confirmedShareIds: () => received,
+ listGroups: () => groups,
+ writeGroup,
+ pruneBindings: vi.fn(async () => undefined),
+ ownerKey: () => 'owner',
+ changed: vi.fn(),
+ };
+ return { deps, writeGroup, groups: () => groups };
+}
+
+describe('removing computers whose share is gone', () => {
+ it('removes only the shared-in computers whose share is no longer received, and their task bindings', async () => {
+ const env = setup(new Set(['d1']));
+ expect(await pruneRemovedShareMembers(env.deps)).toEqual([FROM_A.key]);
+ expect(env.groups().anthropic.members.map((m) => m.key)).toEqual([LOCAL.key, MINI.key, FROM_D.key]);
+ expect(env.deps.pruneBindings).toHaveBeenCalledWith('anthropic', new Set([LOCAL.key, MINI.key, FROM_D.key]));
+ expect(env.deps.changed).toHaveBeenCalledWith('anthropic');
+ // 没有变化的组不写。
+ expect(env.writeGroup).toHaveBeenCalledTimes(1);
+ });
+
+ it('does nothing while the received list is not known to be complete', async () => {
+ const env = setup(null);
+ expect(await pruneRemovedShareMembers(env.deps)).toEqual([]);
+ expect(env.writeGroup).not.toHaveBeenCalled();
+ });
+
+ it('keeps everything when every share is still received (paused shares stay in the list)', async () => {
+ const env = setup(new Set(['a1', 'd1']));
+ expect(await pruneRemovedShareMembers(env.deps)).toEqual([]);
+ expect(env.writeGroup).not.toHaveBeenCalled();
+ });
+
+ it('stops when the account changes before writing', async () => {
+ const env = setup(new Set());
+ let owner = 'owner';
+ env.deps.ownerKey = () => owner;
+ env.deps.listGroups = () => {
+ owner = 'someone-else';
+ return env.groups();
+ };
+ expect(await pruneRemovedShareMembers(env.deps)).toEqual([]);
+ expect(env.writeGroup).not.toHaveBeenCalled();
+ });
+
+ it('does not prune the new account bindings when the account changes while the group write completes', async () => {
+ const env = setup(new Set());
+ let owner = 'owner';
+ env.deps.ownerKey = () => owner;
+ env.writeGroup.mockImplementationOnce(async () => { owner = 'new-owner'; return null; });
+ expect(await pruneRemovedShareMembers(env.deps)).toEqual([]);
+ expect(env.deps.pruneBindings).not.toHaveBeenCalled();
+ expect(env.deps.changed).not.toHaveBeenCalled();
+ });
+
+ it('does not publish old account changes or continue with other groups after binding cleanup changes account', async () => {
+ const env = setup(new Set());
+ let owner = 'owner';
+ env.deps.ownerKey = () => owner;
+ env.deps.pruneBindings = vi.fn(async () => { owner = 'new-owner'; });
+ expect(await pruneRemovedShareMembers(env.deps)).toEqual([]);
+ expect(env.deps.pruneBindings).toHaveBeenCalledTimes(1);
+ expect(env.deps.changed).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/reshare.test.ts b/apps/desktop/src/main/provider-group/__tests__/reshare.test.ts
new file mode 100644
index 0000000000..9956d7c0eb
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/reshare.test.ts
@@ -0,0 +1,393 @@
+/**
+ * 供应商组的转分享(组所在电脑这一边,provider-sharing.md §4.3):组里有分享来的电脑、组所在的供应商又分享给了别人时,
+ * 把分享的人整体报给那台,按那台回来的结果决定能不能分给这个人;没问到之前一律当作没同意。
+ */
+import type { ProviderShareOwned, RemoteAgentCaps } from '@cindy/device-link';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { ProviderGroupConfig, ProviderGroupMember } from '../../../shared/providerGroup';
+import { reshareKeyFor } from '../../remote-agent/host/groupRelay';
+import { createProviderGroupReshare, PROVIDER_GROUP_RESHARE_IDLE_POLL_MS, PROVIDER_GROUP_RESHARE_PENDING_POLL_MS, type ProviderGroupReshare } from '../reshare';
+
+const instances: ProviderGroupReshare[] = [];
+
+function member(key: string, kind: ProviderGroupMember['kind'], agentDeviceId: string | null): ProviderGroupMember {
+ return { key, kind, agentDeviceId, providerId: 'anthropic', limit: 4, weight: 1, paused: false };
+}
+
+const LOCAL = member('local', 'local', null);
+const FRIEND = member('share:a1:anthropic', 'share', 'share:a1');
+const MINI = member('device:mini:anthropic', 'device', 'mini');
+
+function owned(members: Array<{ memberId: string; displayName: string }>, providerId = 'anthropic'): ProviderShareOwned {
+ return {
+ shareId: 'b-share',
+ providerId,
+ providerLabel: 'Anthropic',
+ hostDeviceId: 'b-device',
+ createdAt: '2026-10-15T00:00:00.000Z',
+ members: members.map((m) => ({
+ ...m,
+ avatarUrl: null,
+ region: 'global',
+ status: 'active',
+ joinedAt: '2026-10-15T00:00:00.000Z',
+ })),
+ requests: [],
+ };
+}
+
+const CAPS: RemoteAgentCaps = {
+ version: 1,
+ agents: [],
+ maxRuns: 16,
+ uploadChunkBytes: 1024,
+ maxPayloadBytes: 2048,
+ reshareConsent: true,
+ reshareBatch: true,
+};
+const CAROL = reshareKeyFor('b-share', 'carol');
+const DAVE = reshareKeyFor('b-share', 'dave');
+
+function setup(options: {
+ groups?: Record<string, ProviderGroupConfig>;
+ shares?: ProviderShareOwned[] | null;
+ caps?: RemoteAgentCaps;
+ states?: Record<string, 'pending' | 'approved' | 'rejected'>;
+} = {}) {
+ let now = 1_000;
+ let groups = options.groups ?? { anthropic: { strategy: 'least', autoSwitch: true, members: [LOCAL, FRIEND, MINI] } };
+ let shares: ProviderShareOwned[] | null = options.shares === undefined
+ ? [owned([{ memberId: 'carol', displayName: 'Carol' }, { memberId: 'dave', displayName: 'Dave' }])]
+ : options.shares;
+ let states = { ...(options.states ?? {}) };
+ const responses: unknown[] = [];
+ const cleanups: Record<string, string> = {};
+ let cleanupSeq = 0;
+ const invoke = vi.fn(async (_agentDeviceId: string, request: unknown) => {
+ const input = request as { entries: Array<{ key: string }>; batch?: { id: string; index: number; count: number } };
+ const entries = input.entries;
+ if (entries.length === 0) states = {};
+ const response = {
+ entries: entries.map((entry) => ({ key: entry.key, state: states[entry.key] ?? 'pending' as const })),
+ ...(input.batch ? { batch: { ...input.batch, complete: input.batch.index === input.batch.count - 1 } } : {}),
+ };
+ responses.push(response);
+ return response;
+ });
+ const readCaps = vi.fn(async () => options.caps ?? CAPS);
+ const changed = vi.fn();
+ const completeCleanup = vi.fn(async (device: string, token: string) => {
+ if (cleanups[device] === token) delete cleanups[device];
+ });
+ const deps = {
+ listGroups: () => groups,
+ ownedShares: () => shares,
+ pendingCleanups: () => cleanups,
+ completeCleanup,
+ readCaps,
+ invoke,
+ changed,
+ now: () => now,
+ log: { warn: vi.fn() },
+ };
+ let reshare = createProviderGroupReshare(deps);
+ instances.push(reshare);
+ return {
+ get reshare() { return reshare; },
+ invoke,
+ responses,
+ readCaps,
+ changed,
+ completeCleanup,
+ cleanups,
+ setGroups: (next: Record<string, ProviderGroupConfig>) => {
+ // 生产中由 writeProviderGroup 与移出组同一事务持久记下(真实落盘回归在 stores.test.ts)。
+ const shared = (configs: Record<string, ProviderGroupConfig>) => new Set(Object.values(configs)
+ .flatMap((config) => config.members.filter((m) => m.kind === 'share').map((m) => m.agentDeviceId!)));
+ const remaining = shared(next);
+ for (const device of shared(groups)) if (!remaining.has(device)) cleanups[device] = `cleanup-${++cleanupSeq}`;
+ groups = next;
+ },
+ restart: () => {
+ reshare.stop();
+ reshare = createProviderGroupReshare(deps);
+ instances.push(reshare);
+ },
+ setShares: (next: ProviderShareOwned[] | null) => { shares = next; },
+ setStates: (next: Record<string, 'pending' | 'approved' | 'rejected'>) => { states = { ...next }; },
+ advance: (ms: number) => { now += ms; },
+ };
+}
+
+afterEach(() => {
+ for (const instance of instances.splice(0)) instance.stop();
+ vi.useRealTimers();
+});
+
+describe('provider group reshare (group computer side)', () => {
+ it('reports the people this computer shares the group with only to shared-in computers, and follows their answers', async () => {
+ const env = setup({ states: { [CAROL]: 'approved', [DAVE]: 'pending' } });
+ // 没问到之前一律当作没同意。
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(false);
+ await env.reshare.sync('test');
+ expect(env.invoke).toHaveBeenCalledTimes(1);
+ expect(env.invoke).toHaveBeenCalledWith('share:a1', {
+ op: 'reshare',
+ entries: [{ key: CAROL, name: 'Carol' }, { key: DAVE, name: 'Dave' }],
+ });
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(true);
+ expect(env.reshare.allows('share:a1', DAVE)).toBe(false);
+ expect(env.reshare.allows('share:a1', undefined)).toBe(false);
+ // 同账号电脑与本机不需要同意,也不会被问。
+ expect(env.invoke.mock.calls.some(([id]) => id === 'mini')).toBe(false);
+ expect(env.reshare.summary('anthropic', 'share:a1')).toEqual({
+ support: 'supported',
+ guests: [
+ { memberId: 'carol', displayName: 'Carol', avatarUrl: null, state: 'approved' },
+ { memberId: 'dave', displayName: 'Dave', avatarUrl: null, state: 'pending' },
+ ],
+ });
+ expect(env.changed).toHaveBeenCalled();
+ });
+
+ it('does not report anything before this computer has read whom it shares with (an empty list would wipe consents)', async () => {
+ const env = setup({ shares: null });
+ await env.reshare.sync('test');
+ expect(env.invoke).not.toHaveBeenCalled();
+ expect(env.reshare.summary('anthropic', 'share:a1')).toBeNull();
+ });
+
+ it('treats an older shared-in computer as unable to agree', async () => {
+ const env = setup({ caps: { ...CAPS, reshareConsent: undefined } });
+ await env.reshare.sync('test');
+ expect(env.invoke).not.toHaveBeenCalled();
+ expect(env.reshare.needsUpdate('share:a1')).toBe(true);
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(false);
+ expect(env.reshare.summary('anthropic', 'share:a1')?.support).toBe('needs-update');
+ });
+
+ it('sends a large report in ordered batches and aggregates the final states', async () => {
+ const members = Array.from({ length: 257 }, (_, index) => ({ memberId: 'member-' + index, displayName: 'Member ' + index }));
+ const approvedKey = reshareKeyFor('b-share', 'member-0');
+ const env = setup({ shares: [owned(members)], states: { [approvedKey]: 'approved' } });
+ await env.reshare.sync('large');
+
+ expect(env.invoke).toHaveBeenCalledTimes(2);
+ const requests = env.invoke.mock.calls.map(([, request]) => request as { op: string; entries: unknown[]; batch?: { id: string; index: number; count: number } });
+ expect(requests.map((request) => request.entries.length)).toEqual([256, 1]);
+ expect(requests.map((request) => request.batch?.index)).toEqual([0, 1]);
+ expect(requests[0]?.batch?.id).toBe(requests[1]?.batch?.id);
+ expect(requests.every((request) => request.batch?.count === 2)).toBe(true);
+ expect(env.responses).toEqual([
+ expect.objectContaining({ batch: expect.objectContaining({ index: 0, count: 2, complete: false }) }),
+ expect.objectContaining({ batch: expect.objectContaining({ index: 1, count: 2, complete: true }) }),
+ ]);
+ expect(env.reshare.summary('anthropic', 'share:a1')?.guests).toHaveLength(257);
+ expect(env.reshare.allows('share:a1', approvedKey)).toBe(true);
+ expect(env.reshare.summary('anthropic', 'share:a1')?.guests.at(-1)?.state).toBe('pending');
+ });
+
+ it('does not partially send a large report to an older computer', async () => {
+ const members = Array.from({ length: 257 }, (_, index) => ({ memberId: 'member-' + index, displayName: 'Member ' + index }));
+ const env = setup({ shares: [owned(members)], caps: { ...CAPS, reshareBatch: undefined } });
+ await env.reshare.sync('old');
+ expect(env.invoke).not.toHaveBeenCalled();
+ expect(env.reshare.needsUpdate('share:a1')).toBe(true);
+ });
+
+ it('keeps the last answers when the shared-in computer cannot be reached, and asks again later', async () => {
+ const env = setup({ states: { [CAROL]: 'approved' } });
+ await env.reshare.sync('test');
+ env.readCaps.mockRejectedValueOnce(new Error('offline'));
+ await env.reshare.sync('test', { force: true });
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(true);
+ });
+
+ it('only asks again when the people change or the check interval passes, unless forced', async () => {
+ const env = setup({ states: { [CAROL]: 'approved', [DAVE]: 'approved' } });
+ await env.reshare.sync('test');
+ expect(env.invoke).toHaveBeenCalledTimes(1);
+ await env.reshare.sync('poll');
+ expect(env.invoke).toHaveBeenCalledTimes(1);
+ env.setShares([owned([{ memberId: 'carol', displayName: 'Carol' }])]);
+ await env.reshare.sync('owned');
+ expect(env.invoke).toHaveBeenCalledTimes(2);
+ expect(env.invoke).toHaveBeenLastCalledWith('share:a1', { op: 'reshare', entries: [{ key: CAROL, name: 'Carol' }] });
+ await env.reshare.sync('view', { force: true });
+ expect(env.invoke).toHaveBeenCalledTimes(3);
+ });
+
+ it('tells a computer that left every group to drop the people it was told about', async () => {
+ const env = setup({ states: { [CAROL]: 'approved' } });
+ await env.reshare.sync('test');
+ env.setGroups({ anthropic: { strategy: 'least', autoSwitch: true, members: [LOCAL, MINI] } });
+ await env.reshare.sync('group');
+ expect(env.invoke).toHaveBeenLastCalledWith('share:a1', { op: 'reshare', entries: [] });
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(false);
+ });
+
+ it('retries an offline cleanup until confirmed without letting that computer reuse its approval', async () => {
+ vi.useFakeTimers();
+ const env = setup({ states: { [CAROL]: 'approved' } });
+ await env.reshare.sync('initial');
+ env.setGroups({});
+ // 移出当下就拦住缓存里的同意,不等 debounce 或远端回包。
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(false);
+ env.invoke.mockRejectedValueOnce(new Error('offline'));
+ await env.reshare.sync('removed');
+ expect(env.cleanups['share:a1']).toBeDefined();
+ expect(env.completeCleanup).not.toHaveBeenCalled();
+ env.advance(PROVIDER_GROUP_RESHARE_PENDING_POLL_MS);
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_RESHARE_PENDING_POLL_MS);
+ expect(env.invoke).toHaveBeenCalledTimes(3);
+ expect(env.invoke).toHaveBeenLastCalledWith('share:a1', { op: 'reshare', entries: [] });
+ expect(env.cleanups).toEqual({});
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it('resumes persisted cleanup after restart even before the owned share snapshot is available', async () => {
+ const env = setup({ states: { [CAROL]: 'approved' } });
+ await env.reshare.sync('initial');
+ env.setGroups({});
+ env.invoke.mockRejectedValueOnce(new Error('offline'));
+ await env.reshare.sync('removed');
+ env.restart();
+ env.setShares(null);
+ await env.reshare.sync('startup');
+ expect(env.invoke).toHaveBeenLastCalledWith('share:a1', { op: 'reshare', entries: [] });
+ expect(env.cleanups).toEqual({});
+ });
+
+ it('clears old consent before reporting people after the same shared computer rejoins', async () => {
+ const env = setup({ states: { [CAROL]: 'approved' } });
+ await env.reshare.sync('initial');
+ env.setGroups({});
+ env.invoke.mockRejectedValueOnce(new Error('offline'));
+ await env.reshare.sync('removed');
+ env.setGroups({ anthropic: { strategy: 'least', autoSwitch: true, members: [LOCAL, FRIEND] } });
+ env.restart();
+ await env.reshare.sync('rejoined');
+ expect(env.invoke.mock.calls.slice(2).map(([, request]) => request)).toEqual([
+ { op: 'reshare', entries: [] },
+ { op: 'reshare', entries: [{ key: CAROL, name: 'Carol' }, { key: DAVE, name: 'Dave' }] },
+ ]);
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(false);
+ expect(env.reshare.summary('anthropic', 'share:a1')?.guests[0].state).toBe('pending');
+ });
+
+ it('keeps a cleanup while the shared computer is downgraded and cannot confirm clearing its records', async () => {
+ const env = setup({ states: { [CAROL]: 'approved' } });
+ await env.reshare.sync('initial');
+ env.setGroups({});
+ env.readCaps.mockResolvedValueOnce({ ...CAPS, reshareConsent: undefined });
+ await env.reshare.sync('removed');
+ expect(env.completeCleanup).not.toHaveBeenCalled();
+ expect(env.cleanups['share:a1']).toBeDefined();
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(false);
+ });
+
+ it('retains cleanup when the remote clear succeeds but saving its acknowledgement fails', async () => {
+ vi.useFakeTimers();
+ const env = setup({ states: { [CAROL]: 'approved' } });
+ await env.reshare.sync('initial');
+ env.setGroups({});
+ env.completeCleanup.mockRejectedValueOnce(new Error('disk busy'));
+ await env.reshare.sync('removed');
+ expect(env.cleanups['share:a1']).toBeDefined();
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(false);
+ env.advance(PROVIDER_GROUP_RESHARE_PENDING_POLL_MS);
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_RESHARE_PENDING_POLL_MS);
+ expect(env.completeCleanup).toHaveBeenCalledTimes(2);
+ expect(env.cleanups).toEqual({});
+ });
+
+ it('does not send a stale report or restore consent when the computer leaves during capability lookup', async () => {
+ vi.useFakeTimers();
+ const env = setup({ states: { [CAROL]: 'approved' } });
+ await env.reshare.sync('initial');
+ let release!: () => void;
+ env.readCaps.mockImplementationOnce(() => new Promise((resolve) => { release = () => resolve(CAPS); }));
+ const reporting = env.reshare.sync('view', { force: true });
+ env.setGroups({});
+ release();
+ await reporting;
+ expect(env.invoke).toHaveBeenCalledTimes(1);
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(false);
+ await vi.advanceTimersByTimeAsync(0);
+ expect(env.invoke).toHaveBeenLastCalledWith('share:a1', { op: 'reshare', entries: [] });
+ expect(env.cleanups).toEqual({});
+ });
+
+ it('forgets an approval right away when the shared-in computer refuses the person, then re-checks', async () => {
+ const env = setup({ states: { [CAROL]: 'approved' } });
+ await env.reshare.sync('test');
+ env.setStates({ [CAROL]: 'rejected' });
+ env.reshare.noteDenied('share:a1', CAROL);
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(false);
+ await vi.waitFor(() => expect(env.invoke).toHaveBeenCalledTimes(2));
+ await env.reshare.sync('test');
+ expect(env.reshare.summary('anthropic', 'share:a1')?.guests[0]?.state).toBe('rejected');
+ });
+
+ it('polls every minute while someone is still waiting', async () => {
+ vi.useFakeTimers();
+ const env = setup({ states: { [CAROL]: 'pending' } });
+ await env.reshare.sync('test');
+ expect(env.invoke).toHaveBeenCalledTimes(1);
+ env.setStates({ [CAROL]: 'approved' });
+ env.advance(PROVIDER_GROUP_RESHARE_PENDING_POLL_MS);
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_RESHARE_PENDING_POLL_MS);
+ expect(env.invoke).toHaveBeenCalledTimes(2);
+ expect(env.reshare.allows('share:a1', CAROL)).toBe(true);
+ env.reshare.stop();
+ });
+
+ it('does not lose a change that arrives while a report is in flight', async () => {
+ vi.useFakeTimers();
+ const env = setup({ states: { [CAROL]: 'approved', [DAVE]: 'approved' } });
+ let release!: () => void;
+ env.readCaps.mockImplementationOnce(() => new Promise((resolve) => { release = () => resolve(CAPS); }));
+ const first = env.reshare.sync('test');
+ // 报告进行中又有人变了:合并的报告不能被报告结束时重排的定时核对吞掉。
+ env.setShares([owned([{ memberId: 'carol', displayName: 'Carol' }])]);
+ env.reshare.kick('owned');
+ release();
+ await first;
+ await vi.advanceTimersByTimeAsync(1_000);
+ expect(env.invoke).toHaveBeenLastCalledWith('share:a1', { op: 'reshare', entries: [{ key: CAROL, name: 'Carol' }] });
+ env.reshare.stop();
+ });
+
+ it('shows nothing when this computer shares the provider with nobody', async () => {
+ const env = setup({ shares: [] });
+ await env.reshare.sync('test');
+ // 没有分享的人也报一份空的:清掉那台上可能留着的旧请求。
+ expect(env.invoke).toHaveBeenCalledWith('share:a1', { op: 'reshare', entries: [] });
+ expect(env.reshare.summary('anthropic', 'share:a1')).toBeNull();
+ });
+
+ it('does not poll a confirmed empty list after ten minutes', async () => {
+ vi.useFakeTimers();
+ const env = setup({ shares: [] });
+ await env.reshare.sync('initial');
+ expect(vi.getTimerCount()).toBe(0);
+ env.advance(PROVIDER_GROUP_RESHARE_IDLE_POLL_MS * 2);
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_RESHARE_IDLE_POLL_MS * 2);
+ expect(env.invoke).toHaveBeenCalledTimes(1);
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it('retries an empty list that failed, even if an earlier empty list succeeded', async () => {
+ vi.useFakeTimers();
+ const env = setup({ shares: [] });
+ await env.reshare.sync('initial');
+ env.invoke.mockRejectedValueOnce(new Error('offline'));
+ await env.reshare.sync('view', { force: true });
+ expect(vi.getTimerCount()).toBe(1);
+ env.advance(PROVIDER_GROUP_RESHARE_PENDING_POLL_MS);
+ await vi.advanceTimersByTimeAsync(PROVIDER_GROUP_RESHARE_PENDING_POLL_MS);
+ expect(env.invoke).toHaveBeenCalledTimes(3);
+ expect(vi.getTimerCount()).toBe(0);
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/sharedStatus.test.ts b/apps/desktop/src/main/provider-group/__tests__/sharedStatus.test.ts
index 7eddb4bfd4..0c7e81d9bc 100644
--- a/apps/desktop/src/main/provider-group/__tests__/sharedStatus.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/sharedStatus.test.ts
@@ -192,12 +192,31 @@ describe('anonymous shared group status', () => {
const env = setup(['available', 'available']);
env.readCaps.mockResolvedValue({ virtualWorkspace: true } as RemoteAgentCaps);
expect(await readSharedGroupStatus(env.deps, 'anthropic')).toEqual(['available', 'needs-update']);
- // A shared member is already isolated by its host and does not require guestRelay.
+ // A shared member is isolated by its host, but still needs reshareConsent so
+ // the anonymous status matches the actual guest-task admission check.
env.view.config!.members[1].kind = 'share';
- expect(await readSharedGroupStatus(env.deps, 'anthropic')).toEqual(['available', 'busy']);
- env.readCaps.mockResolvedValue({ guestRelay: true } as RemoteAgentCaps);
- await vi.advanceTimersByTimeAsync(15_000);
expect(await readSharedGroupStatus(env.deps, 'anthropic')).toEqual(['available', 'needs-update']);
+ env.readCaps.mockResolvedValue({ virtualWorkspace: true, reshareConsent: true } as RemoteAgentCaps);
+ await vi.advanceTimersByTimeAsync(15_000);
+ expect(await readSharedGroupStatus(env.deps, 'anthropic')).toEqual(['available', 'busy']);
+ });
+
+ // 转分享(provider-sharing.md §4.3):主人没同意过读状态的这个人时,分享来的电脑对他显示暂不可用,与实际分配一致。
+ it('shows a shared-in computer as unavailable to a shared user its owner has not agreed to', async () => {
+ const env = setup(['available', 'available', 'offline']);
+ env.view.config!.members[1].kind = 'share';
+ env.view.config!.members[2].kind = 'share';
+ let agreed = false;
+ const reshareState: NonNullable<SharedGroupStatusDeps['reshareState']> = vi.fn((member) =>
+ (member.kind === 'share' && !agreed ? 'unavailable' : null));
+ expect(await readSharedGroupStatus({ ...env.deps, reshareState }, 'anthropic')).toEqual(['available', 'unavailable', 'offline']);
+ // 离线的照实显示离线;不再为没同意的那台探测能力。
+ expect(reshareState).toHaveBeenCalledTimes(2);
+ expect(env.readCaps).not.toHaveBeenCalled();
+ agreed = true;
+ env.readCaps.mockResolvedValue({ virtualWorkspace: true, reshareConsent: true } as RemoteAgentCaps);
+ // 同意后照常显示(这台在跑任务,显示忙碌)。
+ expect(await readSharedGroupStatus({ ...env.deps, reshareState }, 'anthropic')).toEqual(['available', 'busy', 'offline']);
});
it('reflects the same temporary exclusion as the guest router without probing or changing it', async () => {
diff --git a/apps/desktop/src/main/provider-group/__tests__/stores.test.ts b/apps/desktop/src/main/provider-group/__tests__/stores.test.ts
index d53489b608..738b8aaa60 100644
--- a/apps/desktop/src/main/provider-group/__tests__/stores.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/stores.test.ts
@@ -5,21 +5,26 @@ import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
-import { describe, expect, it, vi } from 'vitest';
+import { afterAll, afterEach, describe, expect, it, vi } from 'vitest';
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'provider-group-store-test-'));
+let activeOwner = 'owner-test';
vi.mock('electron', () => ({ app: { getPath: () => tmpDir } }));
vi.mock('../../maker-host/logger-adapter.js', () => ({
desktopMakerLogger: { child: () => ({ info: () => {}, warn: () => {}, error: () => {} }) },
}));
vi.mock('../../appSessionState.js', () => ({
- ownerScopedUserDataPath: (name: string) => path.join(tmpDir, name),
- activeOwnerScopeKey: () => 'owner-test',
+ ownerScopedUserDataPath: (name: string) => activeOwner === 'owner-test' ? path.join(tmpDir, name) : path.join(tmpDir, activeOwner, name),
+ activeOwnerScopeKey: () => activeOwner,
}));
const store = await import('../store.js');
const bindings = await import('../bindings.js');
+const locks = await import('../../device-link/crossProcessLock.js');
+
+afterEach(() => { activeOwner = 'owner-test'; vi.restoreAllMocks(); });
+afterAll(async () => { await fs.promises.rm(tmpDir, { recursive: true, force: true }); });
describe('provider group store', () => {
it('drops invalid groups and empty groups when reading', () => {
@@ -50,6 +55,52 @@ describe('provider group store', () => {
await store.writeProviderGroup('anthropic', null);
expect(store.readProviderGroup('anthropic')).toBeNull();
});
+
+ it('persists cleanup with group removal and retains it through restart, rejoin, and stale acknowledgements', async () => {
+ const config = { strategy: 'least', members: [{ kind: 'local' }, { kind: 'share', agentDeviceId: 'share:a1', providerId: 'anthropic' }] };
+ await store.writeProviderGroup('anthropic', config);
+ await store.writeProviderGroup('anthropic', null);
+ const token = store.listProviderGroupReshareCleanups()['share:a1'];
+ expect(token).toBeDefined();
+ const file = path.join(tmpDir, 'provider-group-prefs.json');
+ expect(JSON.parse(fs.readFileSync(file, 'utf8'))).toMatchObject({ reshareCleanups: { 'share:a1': token } });
+ // 重新创建存储实例,不复用缓存,证明清理来自磁盘。
+ vi.resetModules();
+ const restarted = await import('../store.js');
+ expect(restarted.listProviderGroupReshareCleanups()['share:a1']).toBe(token);
+ await restarted.writeProviderGroup('anthropic', config);
+ expect(restarted.listProviderGroupReshareCleanups()['share:a1']).toBe(token);
+ await restarted.writeProviderGroup('anthropic', null);
+ const nextToken = restarted.listProviderGroupReshareCleanups()['share:a1'];
+ expect(nextToken).not.toBe(token);
+ await restarted.completeProviderGroupReshareCleanup('share:a1', token);
+ expect(restarted.listProviderGroupReshareCleanups()['share:a1']).toBe(nextToken);
+ await restarted.completeProviderGroupReshareCleanup('share:a1', nextToken);
+ expect(restarted.listProviderGroupReshareCleanups()).toEqual({});
+ });
+
+ it('only queues cleanup when a shared computer leaves its last group', async () => {
+ const config = { members: [{ kind: 'share', agentDeviceId: 'share:overlap', providerId: 'anthropic' }] };
+ await store.writeProviderGroup('anthropic', config);
+ await store.writeProviderGroup('openai', config);
+ await store.writeProviderGroup('anthropic', null);
+ expect(store.listProviderGroupReshareCleanups()['share:overlap']).toBeUndefined();
+ await store.writeProviderGroup('openai', null);
+ expect(store.listProviderGroupReshareCleanups()['share:overlap']).toBeDefined();
+ });
+
+ it('preserves an unreadable file instead of overwriting its pending cleanups', async () => {
+ const file = path.join(tmpDir, 'provider-group-prefs.json');
+ const previous = fs.readFileSync(file, 'utf8');
+ fs.writeFileSync(file, '{broken-json');
+ try {
+ store.listProviderGroupReshareCleanups();
+ await expect(store.writeProviderGroup('anthropic', null)).rejects.toThrow(/unreadable/);
+ expect(fs.readFileSync(file, 'utf8')).toBe('{broken-json');
+ } finally {
+ fs.writeFileSync(file, previous);
+ }
+ });
});
describe('provider group bindings', () => {
@@ -93,6 +144,25 @@ describe('provider group bindings', () => {
expect(bindings.readProviderGroupBinding('c')).not.toBeNull();
});
+ it('does not write old cleanup releases into the new account after the binding write lock is released', async () => {
+ activeOwner = 'new-owner';
+ await bindings.writeProviderGroupBinding('scope-task', { providerId: 'anthropic', memberKey: 'local' }, 1);
+ activeOwner = 'owner-test';
+ await bindings.writeProviderGroupBinding('scope-task', { providerId: 'anthropic', memberKey: 'local' }, 1);
+ const withLock = locks.withCrossProcessLock;
+ vi.spyOn(locks, 'withCrossProcessLock').mockImplementationOnce(async (...args) => {
+ const result = await withLock(...args);
+ // 落盘成功,但释放锁的异步收尾返回前切账号。
+ activeOwner = 'new-owner';
+ return result;
+ });
+ await bindings.pruneProviderGroupBindings('anthropic', null, 10);
+ expect(bindings.readProviderGroupBinding('scope-task')).not.toBeNull();
+ expect(bindings.isProviderGroupReleased('scope-task', { providerId: 'anthropic' })).toBe(false);
+ activeOwner = 'owner-test';
+ expect(bindings.readProviderGroupBinding('scope-task')).toBeNull();
+ });
+
it('remembers, per group, the tasks released by removing a computer or deleting the group', async () => {
await bindings.writeProviderGroupBinding('x1', { providerId: 'anthropic', memberKey: 'device:mini:x' }, 1);
await bindings.writeProviderGroupBinding('x2', { providerId: 'anthropic', memberKey: 'local' }, 2);
diff --git a/apps/desktop/src/main/provider-group/bindings.ts b/apps/desktop/src/main/provider-group/bindings.ts
index e26974ac79..22730ecc14 100644
--- a/apps/desktop/src/main/provider-group/bindings.ts
+++ b/apps/desktop/src/main/provider-group/bindings.ts
@@ -241,6 +241,7 @@ export async function pruneProviderGroupBindings(
keepMemberKeys: ReadonlySet<string> | null,
now: number = Date.now(),
): Promise<void> {
+ const owner = activeOwnerScopeKey();
const released: string[] = [];
await store.updateAtomic(({ value }) => {
const sessions = { ...value.sessions };
@@ -253,6 +254,8 @@ export async function pruneProviderGroupBindings(
}
return released.length > 0 ? { sessions } : {};
});
+ // 原子写落盘后的锁释放也会等待;旧账号的解除记录不能落到此时切入的新账号。
+ if (activeOwnerScopeKey() !== owner) return;
await writeReleases(released, { providerId }, now);
}
diff --git a/apps/desktop/src/main/provider-group/failurePolicy.ts b/apps/desktop/src/main/provider-group/failurePolicy.ts
index fad0156799..eb0f02c45b 100644
--- a/apps/desktop/src/main/provider-group/failurePolicy.ts
+++ b/apps/desktop/src/main/provider-group/failurePolicy.ts
@@ -100,6 +100,8 @@ const CONNECTION_CHECK_CODES = new Set([
/** 那台本身现在不能接这个任务(不是连接的问题):直接换。 */
const MEMBER_UNAVAILABLE_CODES = new Set([
'REMOTE_AGENT_PROVIDER_NOT_ALLOWED',
+ // 分享来的那台的主人没同意这个受邀者经组使用(转分享):换组里别的电脑。
+ 'REMOTE_AGENT_RESHARE_NOT_ALLOWED',
'REMOTE_AGENT_MODEL_UNAVAILABLE',
'REMOTE_AGENT_SHARE_PAUSED',
'REMOTE_AGENT_SHARE_REMOVED',
diff --git a/apps/desktop/src/main/provider-group/guestRelay.ts b/apps/desktop/src/main/provider-group/guestRelay.ts
index 108ea68a23..b52e372b4a 100644
--- a/apps/desktop/src/main/provider-group/guestRelay.ts
+++ b/apps/desktop/src/main/provider-group/guestRelay.ts
@@ -11,7 +11,7 @@ import type { AgentKind } from '@cindy/maker-core';
import type { ProviderShareGroupState } from '@cindy/device-link';
import type { ProviderGroupConfig } from '../../shared/providerGroup.js';
-import type { RelayRunFailure } from '../remote-agent/host/groupRelay.js';
+import { reshareKeyForGuest, type RelayRunFailure } from '../remote-agent/host/groupRelay.js';
import type { GroupRelayLoad, GroupRelayMember, RemoteAgentGroupRelayDeps } from '../remote-agent/host/runHost.js';
import type { RemoteAgentInvoke, RemoteAgentPoller } from '../remote-agent/controller/runClient.js';
import { RemoteAgentRunClient } from '../remote-agent/controller/runClient.js';
@@ -31,6 +31,15 @@ export interface ProviderGroupGuestRelayDeps {
connect(agentDeviceId: string): { invoke: RemoteAgentInvoke; poller: RemoteAgentPoller };
/** 组内电脑报错里的用量重置时刻(unix ms);不提供时用量上限一律按默认时长冷却。 */
readResetAt?(failure: RelayRunFailure): number | null;
+ /**
+ * 转分享(provider-sharing.md §4.3):分享来的那台电脑的主人是否同意过这个受邀者(按转分享键)。提供时,没同意过
+ * (或不知道是谁)的一律不选、匿名状态里写暂不可用;不提供时不按同意过滤(测试)。
+ */
+ reshareAllows?(agentDeviceId: string, reshareKey: string | undefined): boolean;
+ /** 分享来的那台拒绝了这个人:重新核对同意情况。 */
+ noteReshareDenied?(agentDeviceId: string, reshareKey: string): void;
+ /** 分享来的那台给不出同意(版本太旧):匿名状态里写需要更新。 */
+ reshareNeedsUpdate?(agentDeviceId: string): boolean;
now(): number;
log: { info?(message: string, meta?: Record<string, unknown>): void; warn(message: string, meta?: Record<string, unknown>): void };
}
@@ -40,7 +49,8 @@ function errorText(error: unknown): string {
}
export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps): RemoteAgentGroupRelayDeps & {
- sharedStatus(providerId: string): Promise<ProviderShareGroupState[] | null>;
+ /** 给某个受邀者看的匿名状态;guestController 是读目录的那个受邀者(分享来的电脑按它是否被同意)。 */
+ sharedStatus(providerId: string, guestController?: string): Promise<ProviderShareGroupState[] | null>;
} {
/** 不支持接受受邀者任务的同账号电脑 → 到何时前不再试。 */
const incapable = new Map<string, number>();
@@ -55,20 +65,37 @@ export function createProviderGroupGuestRelay(deps: ProviderGroupGuestRelayDeps)
return true;
}
+ /** 分享来的电脑:它的主人没同意过这个受邀者时不能给他用(没接同意核对时不过滤)。 */
+ function reshareBlocked(member: ProviderGroupConfig['members'][number], reshareKey: string | undefined): boolean {
+ if (member.kind !== 'share' || !member.agentDeviceId || !deps.reshareAllows) return false;
+ return !deps.reshareAllows(member.agentDeviceId, reshareKey);
+ }
+
return {
- sharedStatus: (providerId) => readSharedGroupStatus({
- scope: deps.scope,
- readGroup: deps.readGroup,
- isIncapable,
- readCaps: (member) => RemoteAgentRunClient.caps(deps.connect(member.agentDeviceId!).invoke),
- }, providerId),
+ sharedStatus: (providerId, guestController) => {
+ const reshareKey = guestController ? reshareKeyForGuest(guestController) : undefined;
+ return readSharedGroupStatus({
+ scope: deps.scope,
+ readGroup: deps.readGroup,
+ isIncapable,
+ readCaps: (member) => RemoteAgentRunClient.caps(deps.connect(member.agentDeviceId!).invoke),
+ reshareState: (member) => {
+ if (!reshareBlocked(member, reshareKey)) return null;
+ return member.agentDeviceId && deps.reshareNeedsUpdate?.(member.agentDeviceId) ? 'needs-update' : 'unavailable';
+ },
+ }, providerId);
+ },
+
+ noteReshareDenied: (agentDeviceId, reshareKey) => deps.noteReshareDenied?.(agentDeviceId, reshareKey),
- async plan({ kind, model, providerId, exclude, reserve }) {
+ async plan({ kind, model, providerId, exclude, reserve, reshareKey }) {
const config = deps.readGroup(providerId);
if (!config) return null;
const skip = new Set(exclude);
for (const member of config.members) {
if (member.kind === 'device' && member.agentDeviceId && isIncapable(member.agentDeviceId)) skip.add(member.key);
+ // 转分享:分享来的电脑只给它的主人同意过的人(provider-sharing.md §4.3)。
+ if (reshareBlocked(member, reshareKey)) skip.add(member.key);
}
const scope = deps.scope();
let load: GroupRelayLoad | undefined;
diff --git a/apps/desktop/src/main/provider-group/ipc.ts b/apps/desktop/src/main/provider-group/ipc.ts
index 23d3667ac8..b5205b876a 100644
--- a/apps/desktop/src/main/provider-group/ipc.ts
+++ b/apps/desktop/src/main/provider-group/ipc.ts
@@ -11,6 +11,7 @@ import {
normalizeProviderGroupConfig,
type ProviderGroupCommand,
type ProviderGroupConfig,
+ type ProviderGroupReshareSummary,
type ProviderGroupSessionGroup,
type ProviderGroupView,
} from '../../shared/providerGroup.js';
@@ -52,6 +53,31 @@ export interface ProviderGroupCommandDeps {
/** 这个任务此刻归哪个组(只读本机记录)。 */
sessionGroup(sessionId: string): Promise<ProviderGroupSessionGroup>;
changed(providerId: string): void;
+ /**
+ * 转分享(provider-sharing.md §4.3):分享来的组内电脑的主人对本机分享出去的人逐人同意的结果,设置页据此显示;
+ * 设置页打开时顺带核对一次。不提供时不显示(测试)。
+ */
+ reshare?: {
+ summary(providerId: string, agentDeviceId: string): ProviderGroupReshareSummary | null;
+ refreshIfStale(): void;
+ };
+}
+
+/** 本机自己的组:分享来的组内电脑补上转分享的结果(只给本机设置页,不经设备互联发出)。 */
+function withReshare(deps: ProviderGroupCommandDeps, view: ProviderGroupView): ProviderGroupView {
+ const reshare = deps.reshare;
+ if (!reshare || !view.config) return view;
+ reshare.refreshIfStale();
+ const members = view.config.members;
+ return {
+ ...view,
+ members: view.members.map((status) => {
+ const member = members.find((m) => m.key === status.key);
+ if (member?.kind !== 'share' || !member.agentDeviceId) return status;
+ const summary = reshare.summary(view.providerId, member.agentDeviceId);
+ return summary ? { ...status, reshare: summary } : status;
+ }),
+ };
}
const REMOTE_DEVICE_ID_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
@@ -137,7 +163,7 @@ export async function executeProviderGroupCommand(deps: ProviderGroupCommandDeps
const { providerId } = command;
switch (command.action) {
case 'get':
- return deps.router.view(providerId, { includeGuestSupport: true });
+ return withReshare(deps, await deps.router.view(providerId, { includeGuestSupport: true }));
case 'remote-view':
return markMembersUnreachableHere(
await deps.remoteView(command.deviceId, providerId),
@@ -179,12 +205,23 @@ export async function executeProviderGroupCommand(deps: ProviderGroupCommandDeps
const written = await deps.writeGroup(providerId, next);
await deps.pruneBindings(providerId, written ? new Set(written.members.map((m) => m.key)) : null);
deps.changed(providerId);
- return deps.router.view(providerId, { includeGuestSupport: true });
+ return withReshare(deps, await deps.router.view(providerId, { includeGuestSupport: true }));
}
}
}
-export function registerProviderGroupIpc(): void {
+/**
+ * 转分享(provider-sharing.md §4.3)由 bootstrap 接上(reshareRuntime.ts):组里的电脑变了就重新报分享的人,
+ * 设置页显示分享来的电脑对每个人的同意情况。
+ */
+export interface ProviderGroupIpcReshare {
+ summary(providerId: string, agentDeviceId: string): ProviderGroupReshareSummary | null;
+ refreshIfStale(): void;
+ kick(reason: string): void;
+}
+
+export function registerProviderGroupIpc(options: { reshare?: ProviderGroupIpcReshare } = {}): void {
+ const reshare = options.reshare;
const deps: ProviderGroupCommandDeps = {
router: getProviderGroupRouter(),
directory: getProviderGroupDirectory(),
@@ -197,6 +234,8 @@ export function registerProviderGroupIpc(): void {
listGroups: listProviderGroups,
sessionGroup: readProviderGroupOfSession,
changed: (providerId) => {
+ // 组里的电脑变了:重新报转分享(加进来的分享来的电脑要请它的主人同意,移出的不再列着)。
+ reshare?.kick('group');
try {
broadcast(PROVIDER_GROUP_IPC.CHANGED, { providerId });
// 同账号其他电脑的模型列表按本机目录里的组摘要收起组内电脑:组变化后让它们重读目录。
@@ -205,6 +244,7 @@ export function registerProviderGroupIpc(): void {
log.warn('provider group broadcast failed', { error: String(error) });
}
},
+ ...(reshare ? { reshare } : {}),
};
ipcMain.handle(PROVIDER_GROUP_IPC.COMMAND, async (event, raw: unknown) => {
diff --git a/apps/desktop/src/main/provider-group/removedShares.ts b/apps/desktop/src/main/provider-group/removedShares.ts
new file mode 100644
index 0000000000..4f0ab8ab54
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/removedShares.ts
@@ -0,0 +1,51 @@
+/**
+ * 原分享被删除或已退出(docs/product-rules/provider-groups.md §3、provider-sharing.md §4.3):这个账号收到的分享里
+ * 已经没有它了,组里指向它的电脑移出组,本机自己与本机分享的人都不再用到它。
+ * 只在已收到的分享名单完整可信时判断(说不准时什么都不做);分享只是暂停时仍在名单里,不动。
+ */
+import type { ProviderGroupConfig } from '../../shared/providerGroup.js';
+import { isProviderShareAgentDeviceId, PROVIDER_SHARE_AGENT_DEVICE_PREFIX } from '../../shared/providerShare.js';
+
+export interface PruneRemovedShareMembersDeps {
+ /** 完整可信的已收到分享名单(分享 id);说不准时为 null。 */
+ confirmedShareIds(): ReadonlySet<string> | null;
+ listGroups(): Record<string, ProviderGroupConfig>;
+ writeGroup(providerId: string, config: unknown): Promise<unknown>;
+ /** 解除指向已不在组里的电脑的任务绑定;keep 为 null = 整个组已删除。 */
+ pruneBindings(providerId: string, keep: ReadonlySet<string> | null): Promise<void>;
+ /** 当前账号:读名单与写入之间换了账号时停下。 */
+ ownerKey(): string;
+ changed(providerId: string): void;
+}
+
+function goneMembers(config: ProviderGroupConfig, received: ReadonlySet<string>) {
+ return config.members.filter((member) =>
+ member.kind === 'share'
+ && member.agentDeviceId !== null
+ && isProviderShareAgentDeviceId(member.agentDeviceId)
+ && !received.has(member.agentDeviceId.slice(PROVIDER_SHARE_AGENT_DEVICE_PREFIX.length)));
+}
+
+/** 移出指向已不在的分享的组内电脑并解除对应的任务绑定,返回移出的组内电脑的键。 */
+export async function pruneRemovedShareMembers(deps: PruneRemovedShareMembersDeps): Promise<string[]> {
+ const owner = deps.ownerKey();
+ const received = deps.confirmedShareIds();
+ if (!received) return [];
+ const removed: string[] = [];
+ for (const providerId of Object.keys(deps.listGroups())) {
+ if (deps.ownerKey() !== owner) break;
+ // 每个组写之前现读一次:前一个组的写入期间设置页可能改过这个组。
+ const config = deps.listGroups()[providerId];
+ if (!config) continue;
+ const gone = goneMembers(config, received);
+ if (gone.length === 0) continue;
+ const keep = config.members.filter((member) => !gone.includes(member));
+ await deps.writeGroup(providerId, keep.length > 0 ? { ...config, members: keep } : null);
+ if (deps.ownerKey() !== owner) break;
+ await deps.pruneBindings(providerId, keep.length > 0 ? new Set(keep.map((member) => member.key)) : null);
+ if (deps.ownerKey() !== owner) break;
+ removed.push(...gone.map((member) => member.key));
+ deps.changed(providerId);
+ }
+ return removed;
+}
diff --git a/apps/desktop/src/main/provider-group/reshare.ts b/apps/desktop/src/main/provider-group/reshare.ts
new file mode 100644
index 0000000000..173d94f70c
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/reshare.ts
@@ -0,0 +1,393 @@
+/**
+ * 供应商组的转分享(组所在电脑这一边;docs/product-rules/provider-sharing.md §4.3)。
+ *
+ * 组里有别人分享来的电脑,而组所在的这个供应商又分享给了别人:别人的任务要经组跑到那台电脑上,必须先由那台的
+ * 主人逐人同意。这里按本机的组设置与本机分享出去的人,算出每台分享来的电脑该报上哪些人,经远程 Agent 的
+ * op `reshare` 整体报给那台(本机是那台的受邀者),记下每个人此刻的结果;给受邀者选电脑时只选同意过这个人的那台。
+ *
+ * 结果只在内存里,以那台电脑为准:组或分享的人变化后马上报一次;还有人等着、或那台读不到时每分钟再问一次,
+ * 其余每 10 分钟核对一次;那台拒绝了某个人的任务时马上重问。没问到之前一律当作没同意(不分给那台)。
+ * 本机分享出去的人还没读到时不报:整体替换会把那台上已有的同意清掉。
+ * 移出全部组的清理与组设置一起持久保存,空名单确认后才删除;离线每分钟重试,重启与重新加入都先完成清理。
+ */
+import { randomUUID } from 'node:crypto';
+
+import {
+ REMOTE_AGENT_MAX_RESHARE_ENTRIES,
+ parseRemoteAgentReshareResult,
+ type ProviderShareOwned,
+ type RemoteAgentCaps,
+ type RemoteAgentReshareBatch,
+ type RemoteAgentReshareEntry,
+ type RemoteAgentReshareState,
+} from '@cindy/device-link';
+
+import type { ProviderGroupConfig, ProviderGroupReshareGuest, ProviderGroupReshareSummary } from '../../shared/providerGroup.js';
+import { reshareKeyFor } from '../remote-agent/host/groupRelay.js';
+
+/** 还有人等着同意、或那台读不到时,多久再问一次。 */
+export const PROVIDER_GROUP_RESHARE_PENDING_POLL_MS = 60_000;
+/** 都有结果时多久核对一次(主人可能撤回)。 */
+export const PROVIDER_GROUP_RESHARE_IDLE_POLL_MS = 10 * 60_000;
+/** 变化后合并成一次报告的等待。 */
+export const PROVIDER_GROUP_RESHARE_DEBOUNCE_MS = 1_000;
+/** 设置页打开时,上次核对超过这么久就再问一次。 */
+export const PROVIDER_GROUP_RESHARE_VIEW_REFRESH_MS = 15_000;
+
+export interface ProviderGroupReshareDeps {
+ listGroups(): Record<string, ProviderGroupConfig>;
+ /** 本机分享出去的供应商与其成员;还没读到(或读不到)时为 null。 */
+ ownedShares(): readonly ProviderShareOwned[] | null;
+ /** 与移出组一起持久保存的清理代次;重新加入也须先清空旧同意。 */
+ pendingCleanups(): Readonly<Record<string, string>>;
+ completeCleanup(agentDeviceId: string, token: string): Promise<void>;
+ readCaps(agentDeviceId: string): Promise<RemoteAgentCaps>;
+ /** 经远程 Agent 通道发给那台电脑(本机是那台的受邀者),返回回包;失败抛错。 */
+ invoke(agentDeviceId: string, request: unknown): Promise<unknown>;
+ /** 结果有变化(设置页重读)。 */
+ changed?(): void;
+ now(): number;
+ log: { info?(message: string, meta?: Record<string, unknown>): void; warn(message: string, meta?: Record<string, unknown>): void };
+}
+
+type DeviceSupport = 'supported' | 'needs-update' | 'unknown';
+
+interface DeviceState {
+ support: DeviceSupport;
+ states: Map<string, ProviderGroupReshareGuest['state']>;
+ /** 上次成功报上去的内容;变了才需要立即再报。 */
+ sentSignature: string | null;
+ checkedAt: number;
+ failed: boolean;
+ cleanupToken?: string;
+}
+
+interface DesiredGuest {
+ memberId: string;
+ displayName: string;
+ avatarUrl: string | null;
+ entry: RemoteAgentReshareEntry;
+}
+
+export interface ProviderGroupReshare {
+ /** 分享来的那台电脑的主人是否同意过这个受邀者。 */
+ allows(agentDeviceId: string, reshareKey: string | undefined): boolean;
+ /** 那台给不出同意(版本太旧)。 */
+ needsUpdate(agentDeviceId: string): boolean;
+ /** 设置页:这个供应商的组里这台分享来的电脑对本机分享的每个人的结果;本机没分享给任何人时为 null。 */
+ summary(providerId: string, agentDeviceId: string): ProviderGroupReshareSummary | null;
+ /** 组或分享的人变了:合并后报一次。 */
+ kick(reason: string): void;
+ /** 设置页打开:上次核对较久时再问一次。 */
+ refreshIfStale(): void;
+ /** 那台拒绝了这个人的任务:先当作没同意,马上重问。 */
+ noteDenied(agentDeviceId: string, reshareKey: string): void;
+ /** 立即报一次(测试与调用方需要等结果时)。force:每台都现问。 */
+ sync(reason: string, options?: { force?: boolean }): Promise<void>;
+ stop(): void;
+}
+
+function signatureOf(entries: readonly RemoteAgentReshareEntry[]): string {
+ return JSON.stringify([...entries].sort((a, b) => a.key.localeCompare(b.key)).map((e) => [e.key, e.name, e.avatar ?? null]));
+}
+
+export function createProviderGroupReshare(deps: ProviderGroupReshareDeps): ProviderGroupReshare {
+ const devices = new Map<string, DeviceState>();
+ /** 下一次定时核对。 */
+ let timer: ReturnType<typeof setTimeout> | null = null;
+ /** 变化后合并成一次报告(与定时核对分开:报告结束时重排定时核对不能吞掉刚来的变化)。 */
+ let kickTimer: ReturnType<typeof setTimeout> | null = null;
+ let running: Promise<void> | null = null;
+ let again = false;
+ let againForce = false;
+ let stopped = false;
+
+ /** 每台分享来的电脑该报上的人(按转分享键去重);本机分享出去的人还没读到时为 null。 */
+ function desired(): Map<string, Map<string, DesiredGuest>> | null {
+ const owned = deps.ownedShares();
+ if (!owned) return null;
+ const out = new Map<string, Map<string, DesiredGuest>>();
+ for (const [providerId, config] of Object.entries(deps.listGroups())) {
+ const shareMembers = config.members.filter((m) => m.kind === 'share' && m.agentDeviceId);
+ if (shareMembers.length === 0) continue;
+ const guests: DesiredGuest[] = owned
+ .filter((share) => share.providerId === providerId)
+ .flatMap((share) => share.members.map((member) => ({
+ memberId: member.memberId,
+ displayName: member.displayName,
+ avatarUrl: member.avatarUrl,
+ entry: {
+ key: reshareKeyFor(share.shareId, member.memberId),
+ name: member.displayName,
+ ...(member.avatarUrl ? { avatar: member.avatarUrl } : {}),
+ },
+ })));
+ for (const member of shareMembers) {
+ const list = out.get(member.agentDeviceId!) ?? new Map<string, DesiredGuest>();
+ for (const guest of guests) list.set(guest.entry.key, guest);
+ out.set(member.agentDeviceId!, list);
+ }
+ }
+ return out;
+ }
+
+ async function syncDevice(agentDeviceId: string, entries: RemoteAgentReshareEntry[], cleanupToken?: string): Promise<boolean> {
+ const state: DeviceState = devices.get(agentDeviceId) ?? {
+ support: 'unknown', states: new Map(), sentSignature: null, checkedAt: 0, failed: false,
+ } satisfies DeviceState;
+ devices.set(agentDeviceId, state);
+ const before = JSON.stringify([state.support, [...state.states]]);
+ const signature = signatureOf(entries);
+ if (cleanupToken) {
+ state.cleanupToken = cleanupToken;
+ state.states.clear();
+ state.sentSignature = null;
+ }
+ try {
+ const caps = await deps.readCaps(agentDeviceId);
+ if (stopped) return false;
+ if (!cleanupToken && deps.pendingCleanups()[agentDeviceId]) return false;
+ if (caps.reshareConsent !== true || (entries.length > REMOTE_AGENT_MAX_RESHARE_ENTRIES && caps.reshareBatch !== true)) {
+ // 旧版本给不出同意:这台不分给受邀者,设置页提示那台需要更新。
+ state.support = 'needs-update';
+ state.states = new Map();
+ // 降级的电脑不能确认已清空;保留清理,升级或恢复后再报。
+ if (cleanupToken) throw new Error('The shared computer cannot confirm reshare cleanup yet');
+ } else {
+ const batchId = entries.length > REMOTE_AGENT_MAX_RESHARE_ENTRIES ? randomUUID() : null;
+ const batches: Array<{ entries: RemoteAgentReshareEntry[]; batch?: RemoteAgentReshareBatch }> = [];
+ if (!batchId) batches.push({ entries });
+ else {
+ for (let index = 0; index < entries.length; index += REMOTE_AGENT_MAX_RESHARE_ENTRIES) {
+ batches.push({
+ entries: entries.slice(index, index + REMOTE_AGENT_MAX_RESHARE_ENTRIES),
+ batch: { id: batchId, index: batches.length, count: Math.ceil(entries.length / REMOTE_AGENT_MAX_RESHARE_ENTRIES) },
+ });
+ }
+ }
+ const states = new Map<string, RemoteAgentReshareState>();
+ for (const current of batches) {
+ const request = { op: 'reshare', entries: current.entries, ...(current.batch ? { batch: current.batch } : {}) };
+ const result = parseRemoteAgentReshareResult(
+ await deps.invoke(agentDeviceId, request),
+ current.batch && current.batch.index === current.batch.count - 1
+ ? new Set(entries.map((entry) => entry.key))
+ : new Set(current.entries.map((entry) => entry.key)),
+ );
+ if (current.batch) {
+ if (!result.batch || result.batch.id !== current.batch.id || result.batch.index !== current.batch.index || result.batch.count !== current.batch.count) {
+ throw new Error('Invalid reshare batch response');
+ }
+ // 重试已完成批次时,接收端会对任意重复片段回 complete=true;只要求最后一片
+ // 的正常回包必须表示已整体替换,不能把幂等重试误判成协议错误。
+ if (current.batch.index === current.batch.count - 1 && !result.batch.complete) {
+ throw new Error('Incomplete reshare batch response');
+ }
+ }
+ for (const entry of result.entries) states.set(entry.key, entry.state);
+ }
+ const result = { entries: [...states].map(([key, state]) => ({ key, state })) };
+ if (stopped) return false;
+ if (cleanupToken) {
+ await deps.completeCleanup(agentDeviceId, cleanupToken);
+ if (stopped) return false;
+ devices.delete(agentDeviceId);
+ return true;
+ }
+ if (deps.pendingCleanups()[agentDeviceId]) {
+ state.states.clear();
+ return true;
+ }
+ state.support = 'supported';
+ state.states = new Map(result.entries.map((entry) => [entry.key, entry.state]));
+ }
+ state.sentSignature = signature;
+ state.failed = false;
+ } catch (error) {
+ // 读不到(离线、分享暂停等):保留上次的结果(那台本来也选不上),稍后再问。
+ state.failed = true;
+ deps.log.info?.('provider group: reshare sync failed', {
+ device: agentDeviceId,
+ error: error instanceof Error ? error.message : String(error),
+ });
+ }
+ state.checkedAt = deps.now();
+ if (!devices.has(agentDeviceId)) return false;
+ return JSON.stringify([state.support, [...state.states]]) !== before;
+ }
+
+ /** 这台多久再问一次:还有人等着、或上次读不到时每分钟,其余每 10 分钟。 */
+ function intervalFor(agentDeviceId: string, guests: ReadonlyMap<string, DesiredGuest>): number {
+ const state = devices.get(agentDeviceId);
+ if (!state || state.failed) return PROVIDER_GROUP_RESHARE_PENDING_POLL_MS;
+ if (state.support === 'supported') {
+ for (const key of guests.keys()) {
+ const value = state.states.get(key);
+ if (value === undefined || value === 'pending') return PROVIDER_GROUP_RESHARE_PENDING_POLL_MS;
+ }
+ }
+ return PROVIDER_GROUP_RESHARE_IDLE_POLL_MS;
+ }
+
+ function nextDelay(want: Map<string, Map<string, DesiredGuest>> | null): number | null {
+ let delay: number | null = want ? null : PROVIDER_GROUP_RESHARE_PENDING_POLL_MS;
+ const cleanups = deps.pendingCleanups();
+ for (const [agentDeviceId, token] of Object.entries(cleanups)) {
+ const state = devices.get(agentDeviceId);
+ const elapsed = state?.cleanupToken === token ? deps.now() - state.checkedAt : Infinity;
+ const remaining = Math.max(0, PROVIDER_GROUP_RESHARE_PENDING_POLL_MS - elapsed);
+ delay = delay === null ? remaining : Math.min(delay, remaining);
+ }
+ for (const [agentDeviceId, guests] of want ?? []) {
+ if (cleanups[agentDeviceId]) continue;
+ const state = devices.get(agentDeviceId);
+ // 空名单已确认后无须轮询;失败的空名单仍按一分钟重试。
+ if (guests.size === 0 && state?.sentSignature === signatureOf([]) && !state.failed) continue;
+ const elapsed = state ? deps.now() - state.checkedAt : Infinity;
+ const remaining = Math.max(0, intervalFor(agentDeviceId, guests) - elapsed);
+ delay = delay === null ? remaining : Math.min(delay, remaining);
+ }
+ return delay;
+ }
+
+ function schedule(delay: number | null): void {
+ if (timer) clearTimeout(timer);
+ timer = null;
+ if (stopped || delay === null) return;
+ timer = setTimeout(() => {
+ timer = null;
+ void sync('poll');
+ }, delay);
+ (timer as { unref?: () => void }).unref?.();
+ }
+
+ /** force:每台都现问(设置页打开、那台刚拒绝了人);否则只问报上的人变了的、或到了核对时间的。 */
+ async function runOnce(force: boolean): Promise<void> {
+ let changed = false;
+ // 清理先于重新报人;即使分享名单尚未读到,也能继续已持久保存的清理。
+ const cleanups = Object.entries(deps.pendingCleanups());
+ if (cleanups.length > 0) {
+ await Promise.all(cleanups.map(async ([agentDeviceId, token]) => {
+ const state = devices.get(agentDeviceId);
+ if (!force && state?.cleanupToken === token
+ && deps.now() - state.checkedAt < PROVIDER_GROUP_RESHARE_PENDING_POLL_MS) return;
+ if (await syncDevice(agentDeviceId, [], token)) changed = true;
+ }));
+ }
+ if (stopped) return;
+ const want = desired();
+ if (!want) {
+ if (changed) deps.changed?.();
+ schedule(nextDelay(null));
+ return;
+ }
+ // 待清理的电脑必须继续留在调度里;其余已移出的缓存不再保留。
+ for (const agentDeviceId of devices.keys()) {
+ if (want.has(agentDeviceId) || deps.pendingCleanups()[agentDeviceId]) continue;
+ devices.delete(agentDeviceId);
+ changed = true;
+ }
+ await Promise.all([...want].map(async ([agentDeviceId, guests]) => {
+ if (deps.pendingCleanups()[agentDeviceId]) return;
+ const entries = [...guests.values()].map((guest) => guest.entry);
+ const state = devices.get(agentDeviceId);
+ const signature = signatureOf(entries);
+ // 没有分享给任何人、空名单也已报过:没有要问的。
+ if (!force && entries.length === 0 && state?.sentSignature === signature && !state.failed) return;
+ const due = force || !state || state.sentSignature !== signature
+ || deps.now() - state.checkedAt >= intervalFor(agentDeviceId, guests);
+ if (!due) return;
+ if (await syncDevice(agentDeviceId, entries)) changed = true;
+ }));
+ if (stopped) return;
+ if (changed) deps.changed?.();
+ schedule(nextDelay(desired()));
+ }
+
+ async function sync(reason: string, options: { force?: boolean } = {}): Promise<void> {
+ if (stopped) return;
+ if (running) {
+ again = true;
+ againForce ||= options.force === true;
+ return running;
+ }
+ let force = options.force === true;
+ running = (async () => {
+ try {
+ do {
+ again = false;
+ againForce = false;
+ await runOnce(force);
+ force = againForce;
+ } while (again && !stopped);
+ } catch (error) {
+ deps.log.warn('provider group: reshare sync crashed', { reason, error: error instanceof Error ? error.message : String(error) });
+ schedule(PROVIDER_GROUP_RESHARE_PENDING_POLL_MS);
+ } finally {
+ running = null;
+ }
+ })();
+ return running;
+ }
+
+ return {
+ allows(agentDeviceId, reshareKey) {
+ if (!reshareKey || deps.pendingCleanups()[agentDeviceId]) return false;
+ return devices.get(agentDeviceId)?.states.get(reshareKey) === 'approved';
+ },
+ needsUpdate(agentDeviceId) {
+ return devices.get(agentDeviceId)?.support === 'needs-update';
+ },
+ summary(providerId, agentDeviceId) {
+ const owned = deps.ownedShares();
+ if (!owned) return null;
+ const shares = owned.filter((share) => share.providerId === providerId);
+ const people = shares.flatMap((share) => share.members.map((member) => ({ share, member })));
+ if (people.length === 0) return null;
+ const state = deps.pendingCleanups()[agentDeviceId] ? undefined : devices.get(agentDeviceId);
+ return {
+ support: state?.support ?? 'unknown',
+ guests: people.map(({ share, member }): ProviderGroupReshareGuest => ({
+ memberId: member.memberId,
+ displayName: member.displayName,
+ avatarUrl: member.avatarUrl,
+ state: state?.support === 'supported'
+ ? state.states.get(reshareKeyFor(share.shareId, member.memberId)) ?? 'unknown'
+ : 'unknown',
+ })),
+ };
+ },
+ kick(reason) {
+ if (stopped) return;
+ if (kickTimer) clearTimeout(kickTimer);
+ kickTimer = setTimeout(() => {
+ kickTimer = null;
+ void sync(reason);
+ }, PROVIDER_GROUP_RESHARE_DEBOUNCE_MS);
+ (kickTimer as { unref?: () => void }).unref?.();
+ },
+ refreshIfStale() {
+ const now = deps.now();
+ const stale = [...devices.values()].some((state) => now - state.checkedAt >= PROVIDER_GROUP_RESHARE_VIEW_REFRESH_MS);
+ if (stale) void sync('view', { force: true });
+ else if (devices.size === 0) void sync('view');
+ },
+ noteDenied(agentDeviceId, reshareKey) {
+ const state = devices.get(agentDeviceId);
+ if (state?.states.get(reshareKey) === 'approved') {
+ state.states.delete(reshareKey);
+ deps.changed?.();
+ }
+ void sync('denied', { force: true });
+ },
+ sync,
+ stop() {
+ stopped = true;
+ if (timer) clearTimeout(timer);
+ if (kickTimer) clearTimeout(kickTimer);
+ timer = null;
+ kickTimer = null;
+ devices.clear();
+ },
+ };
+}
diff --git a/apps/desktop/src/main/provider-group/reshareRuntime.ts b/apps/desktop/src/main/provider-group/reshareRuntime.ts
new file mode 100644
index 0000000000..2135224524
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/reshareRuntime.ts
@@ -0,0 +1,119 @@
+/**
+ * 供应商组与供应商分享之间的接线(组所在电脑这一边):
+ * - 转分享(provider-sharing.md §4.3):组里分享来的电脑的主人逐人同意本机分享出去的人,结果按账号放在内存里
+ * (reshare.ts);组或分享的人变化时重新报给那台;
+ * - 原分享被删除或已退出(provider-groups.md §3):已收到的分享名单完整可信时,把组里指向它的电脑移出组。
+ * 两者都只看本机自己的组;按调用时的账号转发,换账号后另起一份。
+ */
+import { REMOTE_AGENT_CHANNEL, parseRemoteAgentCaps } from '@cindy/device-link';
+
+import { activeOwnerScopeKey } from '../appSessionState.js';
+import { PROVIDER_GROUP_IPC } from '../../shared/providerGroup.js';
+import { tapWindowBroadcast } from '../device-link/broadcast-tap.js';
+import { broadcast, remoteBackgroundInvoke } from '../device-link/index.js';
+import { getConfirmedReceivedShareIds, onProviderShareReceivedChanged } from '../device-link/providerShareGuest.js';
+import { getProviderShareHostLoadedSnapshot, onProviderShareHostChanged } from '../device-link/providerShareHost.js';
+import { createLogger } from '../logger.js';
+import { MAKER_PUSH } from '../maker-ipc/channels.js';
+import { pruneProviderGroupBindings } from './bindings.js';
+import { pruneRemovedShareMembers } from './removedShares.js';
+import { createProviderGroupReshare, type ProviderGroupReshare } from './reshare.js';
+import { completeProviderGroupReshareCleanup, listProviderGroupReshareCleanups, listProviderGroups, writeProviderGroup } from './store.js';
+
+const log = createLogger('provider-group:reshare');
+
+let current: { owner: string; reshare: ProviderGroupReshare } | null = null;
+
+function broadcastChanged(providerId: string): void {
+ try {
+ broadcast(PROVIDER_GROUP_IPC.CHANGED, { providerId });
+ } catch (error) {
+ log.warn('provider group broadcast failed', { error: String(error) });
+ }
+}
+
+function reshareForActiveOwner(): ProviderGroupReshare {
+ const owner = activeOwnerScopeKey();
+ if (current?.owner === owner) return current.reshare;
+ current?.reshare.stop();
+ const isCurrent = () => activeOwnerScopeKey() === owner;
+ const invoke = async (agentDeviceId: string, request: unknown): Promise<unknown> => {
+ if (!isCurrent()) throw new Error('The account changed');
+ const reply = await remoteBackgroundInvoke(agentDeviceId, REMOTE_AGENT_CHANNEL, [request]);
+ if (!isCurrent()) throw new Error('The account changed');
+ if (!reply.ok) throw new Error(reply.error.message || reply.error.code);
+ return reply.result;
+ };
+ const reshare = createProviderGroupReshare({
+ listGroups: () => (isCurrent() ? listProviderGroups() : {}),
+ ownedShares: () => (isCurrent() ? getProviderShareHostLoadedSnapshot() : null),
+ pendingCleanups: () => (isCurrent() ? listProviderGroupReshareCleanups() : {}),
+ completeCleanup: async (agentDeviceId, token) => {
+ if (!isCurrent()) throw new Error('The account changed');
+ await completeProviderGroupReshareCleanup(agentDeviceId, token);
+ if (!isCurrent()) throw new Error('The account changed');
+ },
+ readCaps: async (agentDeviceId) => parseRemoteAgentCaps(await invoke(agentDeviceId, { op: 'caps' })),
+ invoke,
+ changed: () => {
+ if (!isCurrent()) return;
+ for (const [providerId, config] of Object.entries(listProviderGroups())) {
+ if (config.members.some((member) => member.kind === 'share')) broadcastChanged(providerId);
+ }
+ },
+ now: () => Date.now(),
+ log,
+ });
+ current = { owner, reshare };
+ return reshare;
+}
+
+/** 转分享:给 guestRelay、设置页与组的变化用的门面(每次按当前账号转发)。 */
+export const providerGroupReshare = {
+ allows: (agentDeviceId: string, reshareKey: string | undefined) => reshareForActiveOwner().allows(agentDeviceId, reshareKey),
+ needsUpdate: (agentDeviceId: string) => reshareForActiveOwner().needsUpdate(agentDeviceId),
+ summary: (providerId: string, agentDeviceId: string) => reshareForActiveOwner().summary(providerId, agentDeviceId),
+ kick: (reason: string) => reshareForActiveOwner().kick(reason),
+ refreshIfStale: () => reshareForActiveOwner().refreshIfStale(),
+ noteDenied: (agentDeviceId: string, reshareKey: string) => reshareForActiveOwner().noteDenied(agentDeviceId, reshareKey),
+};
+
+let registered = false;
+let pruning: Promise<void> | null = null;
+
+function pruneSoon(): void {
+ if (pruning) return;
+ pruning = pruneRemovedShareMembers({
+ confirmedShareIds: getConfirmedReceivedShareIds,
+ listGroups: listProviderGroups,
+ writeGroup: writeProviderGroup,
+ pruneBindings: pruneProviderGroupBindings,
+ ownerKey: activeOwnerScopeKey,
+ changed: (providerId) => {
+ broadcastChanged(providerId);
+ // 同账号其他电脑的模型列表按本机目录里的组摘要收起组内电脑:组变化后让它们重读目录。
+ tapWindowBroadcast(MAKER_PUSH.PROVIDER_CHANGED, {});
+ },
+ }).then((removed) => {
+ if (removed.length > 0) {
+ log.info('provider group: removed computers whose share is gone', { count: removed.length });
+ providerGroupReshare.kick('share-removed');
+ }
+ }).catch((error: unknown) => {
+ log.warn('provider group: removing gone shares failed', { error: error instanceof Error ? error.message : String(error) });
+ }).finally(() => {
+ pruning = null;
+ });
+}
+
+/** 启动时接上:分享快照与已收到的分享变化时,重新报转分享、移出已不在的分享。 */
+export function registerProviderGroupReshare(): void {
+ if (registered) return;
+ registered = true;
+ onProviderShareHostChanged(() => providerGroupReshare.kick('owned'));
+ onProviderShareReceivedChanged(() => {
+ pruneSoon();
+ providerGroupReshare.kick('received');
+ });
+ providerGroupReshare.kick('startup');
+}
diff --git a/apps/desktop/src/main/provider-group/sharedStatus.ts b/apps/desktop/src/main/provider-group/sharedStatus.ts
index 30c7ee4774..dbaa42717e 100644
--- a/apps/desktop/src/main/provider-group/sharedStatus.ts
+++ b/apps/desktop/src/main/provider-group/sharedStatus.ts
@@ -13,6 +13,11 @@ export interface SharedGroupStatusDeps {
readGroup(providerId: string): ProviderGroupConfig | null;
readCaps(member: ProviderGroupMember): Promise<RemoteAgentCaps>;
isIncapable(agentDeviceId: string): boolean;
+ /**
+ * 转分享(provider-sharing.md §4.3):分享来的电脑的主人没同意过读状态的这个受邀者时,他看到的状态
+ * (暂不可用,或那台需要更新才能同意);同意过或不是分享来的电脑返回 null。
+ */
+ reshareState?(member: ProviderGroupMember): ProviderShareGroupState | null;
}
async function readWithin<T>(read: () => Promise<T>): Promise<T | null> {
@@ -81,7 +86,10 @@ export function createGuestSupportReader(readCaps: SharedGroupStatusDeps['readCa
const promise = pending.promise;
const capability = await readWithin(() => promise);
if (!capability) return 'unknown';
- return capability.virtualWorkspace === true && (member.kind !== 'device' || capability.guestRelay === true)
+ return capability.virtualWorkspace === true
+ && (member.kind === 'device'
+ ? capability.guestRelay === true
+ : member.kind !== 'share' || capability.reshareConsent === true)
? 'supported' : 'needs-update';
};
}
@@ -102,6 +110,9 @@ export async function readSharedGroupStatus(deps: SharedGroupStatusDeps, provide
const status = view?.members.find((item) => item.key === member.key);
if (!status) return 'unknown';
if (status.state !== 'available' && status.state !== 'full') return status.state;
+ // 与实际分配一致:主人没同意过这个人的分享来的电脑不会分给他。
+ const reshare = deps.reshareState?.(member) ?? null;
+ if (reshare) return reshare;
if (member.agentDeviceId) {
// 与实际接任务的条件一致;旧版同账号组员可能主人能用,受邀者却不能用。
if (member.kind === 'device' && deps.isIncapable(member.agentDeviceId)) return 'needs-update';
diff --git a/apps/desktop/src/main/provider-group/store.ts b/apps/desktop/src/main/provider-group/store.ts
index 708ccebd49..e25c5c6f8e 100644
--- a/apps/desktop/src/main/provider-group/store.ts
+++ b/apps/desktop/src/main/provider-group/store.ts
@@ -2,6 +2,8 @@
* 供应商组设置:按账号存在本机(`provider-group-prefs.json`),不同步到其他电脑。
* 组只是「这台电脑上这个供应商」的一项设置,没有账号级的组(docs/product-rules/provider-groups.md §3)。
*/
+import { randomUUID } from 'node:crypto';
+
import { activeOwnerScopeKey, ownerScopedUserDataPath } from '../appSessionState.js';
import { desktopMakerLogger } from '../maker-host/logger-adapter.js';
import { createOverrideSettingsFile } from '../maker-host/override-settings-file.js';
@@ -13,22 +15,39 @@ import {
interface ProviderGroupFile {
groups: Record<string, ProviderGroupConfig>;
+ /** 分享来的电脑离开全部组后,等空名单确认再删除;代次防止迟到确认吞掉再次移出的清理。 */
+ reshareCleanups?: Record<string, string>;
}
/** 防止损坏文件无限膨胀的存储边界,远高于实际用量。 */
const MAX_GROUPS = 1024;
function normalize(raw: unknown): ProviderGroupFile {
- const groups = (raw as Partial<ProviderGroupFile> | null)?.groups;
- if (!groups || typeof groups !== 'object' || Array.isArray(groups)) return { groups: {} };
+ const source = raw as Partial<ProviderGroupFile> | null;
+ const groups = source?.groups;
const out: Record<string, ProviderGroupConfig> = {};
- for (const [providerId, value] of Object.entries(groups)) {
+ for (const [providerId, value] of Object.entries(groups && typeof groups === 'object' && !Array.isArray(groups) ? groups : {})) {
if (Object.keys(out).length >= MAX_GROUPS) break;
if (!isProviderGroupProviderId(providerId)) continue;
const config = normalizeProviderGroupConfig(value, providerId);
if (config) out[providerId] = config;
}
- return { groups: out };
+ const reshareCleanups: Record<string, string> = {};
+ if (source?.reshareCleanups && typeof source.reshareCleanups === 'object' && !Array.isArray(source.reshareCleanups)) {
+ for (const [device, token] of Object.entries(source.reshareCleanups)) {
+ if (/^share:[A-Za-z0-9_.:-]{1,128}$/.test(device) && typeof token === 'string' && /^[0-9a-f-]{36}$/.test(token)) {
+ reshareCleanups[device] = token;
+ }
+ }
+ }
+ return { groups: out, ...(Object.keys(reshareCleanups).length > 0 ? { reshareCleanups } : {}) };
+}
+
+/** 同一分享可能同时加入几个组;最后一个引用移出时才清空这台电脑的转分享名单。 */
+function sharedDevices(groups: Record<string, ProviderGroupConfig>): Set<string> {
+ return new Set(Object.values(groups).flatMap((config) => config.members
+ .filter((member) => member.kind === 'share' && member.agentDeviceId)
+ .map((member) => member.agentDeviceId!)));
}
const log = desktopMakerLogger.child('provider-group');
@@ -40,6 +59,8 @@ const store = createOverrideSettingsFile<ProviderGroupFile>({
log,
label: 'provider-group',
maxBytes: 1024 * 1024,
+ preserveUnreadableFile: true,
+ logLoadedValue: false,
});
export function readProviderGroup(providerId: string): ProviderGroupConfig | null {
@@ -64,9 +85,30 @@ export async function writeProviderGroup(
const groups = { ...value.groups };
if (normalized) groups[providerId] = normalized;
else delete groups[providerId];
- return { groups };
+ const remaining = sharedDevices(groups);
+ const reshareCleanups = { ...value.reshareCleanups };
+ for (const device of sharedDevices(value.groups)) {
+ if (!remaining.has(device)) reshareCleanups[device] = randomUUID();
+ }
+ // 与移出组同一把锁、同一次原子替换:崩溃、离线、重新加入都不能丢掉清空旧同意的意图。
+ return { groups, reshareCleanups };
});
return next.groups[providerId] ?? null;
}
+export function listProviderGroupReshareCleanups(): Readonly<Record<string, string>> {
+ store.invalidateIfChanged();
+ return store.read().reshareCleanups ?? {};
+}
+
+/** 空名单已被对端确认,只确认这次清理,保留报告期间新生成的代次。 */
+export async function completeProviderGroupReshareCleanup(agentDeviceId: string, token: string): Promise<void> {
+ await store.updateAtomic(({ value }) => {
+ if (value.reshareCleanups?.[agentDeviceId] !== token) return {};
+ const reshareCleanups = { ...value.reshareCleanups };
+ delete reshareCleanups[agentDeviceId];
+ return { reshareCleanups };
+ });
+}
+
export const __testing = { normalize };
diff --git a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
index 73e7046bd2..edf504591b 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
@@ -10,7 +10,7 @@ import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
-import { REMOTE_AGENT_MAX_RUNS_PER_CONTROLLER } from '@cindy/device-link';
+import { isProviderSharePeer, providerShareGuestPeer, REMOTE_AGENT_MAX_RUNS_PER_CONTROLLER } from '@cindy/device-link';
import type { AgentEvent, AgentSessionHandle } from '@cindy/maker-core';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { createProviderGroupGuestRelay } from '../../provider-group/guestRelay';
@@ -20,7 +20,7 @@ import { decideProviderGroupFailure } from '../../provider-group/failurePolicy';
import { RemoteAgentPoller } from '../controller/poller';
import { RemoteAgentRunClient } from '../controller/runClient';
-import { relayKeyFor, type RelayRunFailure } from '../host/groupRelay';
+import { relayKeyFor, reshareKeyFor, type RelayRunFailure } from '../host/groupRelay';
import {
createRemoteAgentHost,
hostSessionIdFor,
@@ -57,6 +57,9 @@ function fakeAgentHost(name: string, started: Started[], options: {
failStart?: boolean;
/** 这台的 Agent 一启动就结束。 */
endImmediately?: boolean;
+ /** 转分享的同意(本机是分享者)。 */
+ reshare?: Parameters<typeof createRemoteAgentHost>[0]['reshare'];
+ resolveProvider?: NonNullable<Parameters<typeof createRemoteAgentHost>[0]['providerAccess']>['resolve'];
}) {
return createRemoteAgentHost({
isAgentAvailable: () => true,
@@ -110,7 +113,7 @@ function fakeAgentHost(name: string, started: Started[], options: {
isControllerAuthorized: () => true,
controllerTrust: options.trust,
providerAccess: {
- resolve: async (_kind, _model, providerId) => providerId ?? 'shared-provider',
+ resolve: options.resolveProvider ?? (async (_kind, _model, providerId) => providerId ?? 'shared-provider'),
isAllowed: () => true,
},
...(options.guestRelayCapable === false ? {} : {
@@ -118,6 +121,7 @@ function fakeAgentHost(name: string, started: Started[], options: {
}),
...(options.purge ? { purgeHostedTranscripts: options.purge } : {}),
...(options.groupRelay ? { groupRelay: options.groupRelay } : {}),
+ ...(options.reshare ? { reshare: options.reshare } : {}),
captureOwner: () => 'owner',
isOwnerCurrent: () => true,
runsRoot: path.join(root, name),
@@ -235,7 +239,7 @@ function setup(options: {
} satisfies RemoteAgentGroupRelayDeps;
const ownerStarted: Started[] = [];
const owner = fakeAgentHost('owner', ownerStarted, {
- trust: (controller) => (controller.startsWith('share-') ? 'guest' : 'owner'),
+ trust: (controller) => (controller.startsWith('share-') || isProviderSharePeer(controller) ? 'guest' : 'owner'),
purge: async () => undefined,
groupRelay: relay,
...options.owner,
@@ -901,3 +905,193 @@ describe('provider group "switch to another computer" for shared users', () => {
await second.client.close('close', 'navigation');
});
});
+
+// 转分享(docs/product-rules/provider-sharing.md §4.3):受邀者 B 的组替 B 分享的人 C 转来的任务,只在本机主人 A 同意过 C 时运行。
+describe('provider group reshare consent', () => {
+ /** B 的组所在电脑在 A 这台上的身份(A 的受邀者)。 */
+ const B_GROUP = providerShareGuestPeer('a-share', 'b-member', 'b-device');
+ /** C(B 分享的人)在 B 那台上的身份。 */
+ const C_AT_B = providerShareGuestPeer('b-share', 'c-member', 'c-device');
+ const C_KEY = reshareKeyFor('b-share', 'c-member');
+
+ function memberHost(approved: Set<string>, resolveProvider?: NonNullable<Parameters<typeof createRemoteAgentHost>[0]['providerAccess']>['resolve']) {
+ const started: Started[] = [];
+ const sync = vi.fn(async (_controller: string, entries: readonly { key: string }[], batch?: { id: string; index: number; count: number }) => ({
+ entries: entries.map((entry) => ({ key: entry.key, state: approved.has(entry.key) ? 'approved' as const : 'pending' as const })),
+ ...(batch ? { batch: { ...batch, complete: false } } : {}),
+ }));
+ const host = fakeAgentHost('a', started, {
+ trust: (controller) => (isProviderSharePeer(controller) ? 'guest' : 'owner'),
+ reshare: { sync, allows: (controller, key) => controller === B_GROUP && !!key && approved.has(key) },
+ resolveProvider,
+ });
+ const open = (payload: Record<string, unknown>) => host.handle(B_GROUP, {
+ op: 'open',
+ runId: runId(),
+ agentKind: 'claude-code',
+ payload: { json: openPayload('relayed', payload) },
+ });
+ return { host, started, sync, open };
+ }
+
+ it('declares consent support only to shared users and records whom their group computer reports', async () => {
+ const env = memberHost(new Set([C_KEY]));
+ expect(await env.host.handle(B_GROUP, { op: 'caps' })).toMatchObject({ reshareConsent: true, reshareBatch: true });
+ expect(await env.host.handle('same-account-mac', { op: 'caps' })).not.toHaveProperty('reshareConsent');
+ expect(await env.host.handle(B_GROUP, { op: 'reshare', entries: [{ key: C_KEY, name: 'Carol' }] }))
+ .toEqual({ entries: [{ key: C_KEY, state: 'approved' }] });
+ expect(env.sync).toHaveBeenCalledWith(B_GROUP, [{ key: C_KEY, name: 'Carol' }], undefined);
+ const batch = { id: 'batch-a1b2c3d4e5f6', index: 0, count: 2 };
+ expect(await env.host.handle(B_GROUP, { op: 'reshare', entries: [{ key: C_KEY, name: 'Carol' }], batch }))
+ .toEqual({ entries: [{ key: C_KEY, state: 'approved' }], batch: { ...batch, complete: false } });
+ expect(env.sync).toHaveBeenCalledWith(B_GROUP, [{ key: C_KEY, name: 'Carol' }], batch);
+ // 同账号电脑经组使用不需要同意,也不能报人。
+ await expect(env.host.handle('same-account-mac', { op: 'reshare', entries: [] })).rejects.toThrow(/REMOTE_AGENT_INVALID/);
+ });
+
+ it('refuses a relayed task for someone the owner has not agreed to, and runs it once agreed', async () => {
+ const approved = new Set<string>();
+ const env = memberHost(approved);
+ await expect(env.open({ relay: relayKeyFor(C_AT_B), groupAssigned: true, reshareKey: C_KEY }))
+ .rejects.toThrow(/REMOTE_AGENT_RESHARE_NOT_ALLOWED/);
+ // 旧组所在电脑不带转分享键:回已有的错误码,它照常换组里下一台。
+ await expect(env.open({ relay: relayKeyFor(C_AT_B), groupAssigned: true }))
+ .rejects.toThrow(/REMOTE_AGENT_PROVIDER_NOT_ALLOWED/);
+ expect(env.host.runCount()).toBe(0);
+ // 受邀者 B 自己的任务(不是被转来的)不需要同意。
+ await env.open({ groupAssigned: true });
+ await waitFor(() => env.started.length === 1);
+ approved.add(C_KEY);
+ await env.open({ relay: relayKeyFor(C_AT_B), groupAssigned: true, reshareKey: C_KEY });
+ await waitFor(() => env.started.length === 2);
+ expect(env.started[1].input.guest).toBe(true);
+ await env.host.abortAll();
+ });
+
+ it('stops the relayed tasks of a person right away when the owner withdraws agreement', async () => {
+ const approved = new Set([C_KEY]);
+ const env = memberHost(approved);
+ await env.open({ relay: relayKeyFor(C_AT_B), groupAssigned: true, reshareKey: C_KEY });
+ await env.open({ groupAssigned: true });
+ expect(env.host.runCount()).toBe(2);
+ approved.delete(C_KEY);
+ await env.host.abortReshare((controller) => controller === B_GROUP, C_KEY);
+ // 只结束 C 的任务,B 自己的照常运行。
+ await waitFor(() => env.host.runCount() === 1);
+ await env.host.abortAll();
+ });
+
+ it.each([false, true])('does not register a relayed task after consent is withdrawn during provider lookup (resume: %s)', async (resume) => {
+ const approved = new Set([C_KEY]);
+ const resolveProvider = vi.fn(async () => 'shared-provider');
+ const env = memberHost(approved, resolveProvider);
+ const payload = { relay: relayKeyFor(C_AT_B), groupAssigned: true, reshareKey: C_KEY };
+ let resumeSessionId: string | undefined;
+ if (resume) {
+ await env.open(payload);
+ await waitFor(() => env.started.length === 1);
+ resumeSessionId = `sdk-a-${env.started[0].input.hostSessionId}`;
+ await env.host.abortAll();
+ }
+ let release!: () => void;
+ resolveProvider.mockImplementationOnce(() => new Promise<string>((resolve) => { release = () => resolve('shared-provider'); }));
+ const opening = env.open({ ...payload, ...(resumeSessionId ? { options: { resumeSessionId } } : {}) });
+ const rejected = expect(opening).rejects.toThrow(/REMOTE_AGENT_RESHARE_NOT_ALLOWED/);
+ await waitFor(() => !!release);
+ approved.delete(C_KEY);
+ await env.host.abortReshare((controller) => controller === B_GROUP, C_KEY);
+ release();
+ await rejected;
+ expect(env.host.runCount()).toBe(0);
+ expect(env.started).toHaveLength(resume ? 1 : 0);
+ });
+
+ it('asks the group to pick only computers that agreed to this person, and tells a shared-in computer who it is', async () => {
+ const SHARED_IN: GroupRelayMember = { memberKey: 'share:a-share:anthropic', agentDeviceId: 'studio', providerId: 'anthropic', sameAccount: false };
+ const opens: Array<Record<string, unknown>> = [];
+ const env = setup({
+ plans: [{ kind: 'member', ...SHARED_IN }, { kind: 'member', ...MEMBER_MINI }],
+ intercept: async (_agentDeviceId, request, forward) => {
+ if (request.op === 'caps' && _agentDeviceId === 'studio') return { ...await forward() as object, reshareConsent: true };
+ if (request.op === 'open') opens.push((request.payload as { json: Record<string, unknown> }).json);
+ return forward();
+ },
+ });
+ const first = await openAsGuest(env, C_AT_B, openPayload(SESSION, { reshareKey: 'f'.repeat(32) }));
+ expect(env.relay.plan).toHaveBeenCalledWith(expect.objectContaining({ reshareKey: C_KEY }));
+ // 带的是本机按分享与成员派生的键,受邀者自己填的不转发。
+ expect(opens[0]).toMatchObject({ relay: relayKeyFor(C_AT_B), groupAssigned: true, reshareKey: C_KEY });
+ await first.client.close('close', 'navigation');
+ const second = await openAsGuest(env, C_AT_B, openPayload('task-2'));
+ // 同账号的组内电脑不需要同意,不带键。
+ expect(opens[1]).not.toHaveProperty('reshareKey');
+ await second.client.close('close', 'navigation');
+ });
+
+ it('marks consent for re-checking when the shared-in computer refuses the person, then tries the next computer', async () => {
+ const SHARED_IN: GroupRelayMember = { memberKey: 'share:a-share:anthropic', agentDeviceId: 'studio', providerId: 'anthropic', sameAccount: false };
+ const noteReshareDenied = vi.fn();
+ const env = setup({
+ plans: [{ kind: 'member', ...SHARED_IN }, { kind: 'member', ...MEMBER_MINI }],
+ intercept: async (_agentDeviceId, request, forward) => {
+ if (request.op === 'caps' && _agentDeviceId === 'studio') return { ...await forward() as object, reshareConsent: true };
+ if (request.op === 'open' && _agentDeviceId === 'studio') {
+ throw new Error('[REMOTE_AGENT_RESHARE_NOT_ALLOWED] the owner of this computer has not agreed to this user');
+ }
+ return forward();
+ },
+ });
+ (env.relay as RemoteAgentGroupRelayDeps).noteReshareDenied = noteReshareDenied;
+ const { client } = await openAsGuest(env, C_AT_B, openPayload(SESSION));
+ expect(noteReshareDenied).toHaveBeenCalledWith('studio', C_KEY);
+ expect(env.memberStarted.mini).toHaveLength(1);
+ await client.close('close', 'navigation');
+ });
+
+ it('skips an old shared-in computer even when cached consent selected it', async () => {
+ const shared: GroupRelayMember = { memberKey: 'share:a:anthropic', agentDeviceId: 'studio', providerId: 'anthropic', sameAccount: false };
+ const opened: string[] = [];
+ const env = setup({
+ plans: [{ kind: 'member', ...shared }, { kind: 'member', ...MEMBER_MINI }],
+ intercept: async (id, request, forward) => {
+ if (request.op === 'open') opened.push(id);
+ return forward();
+ },
+ });
+ const { client } = await openAsGuest(env, C_AT_B, openPayload(SESSION));
+ expect(opened).toEqual(['mini']);
+ expect(env.memberStarted.studio).toHaveLength(0);
+ expect(env.relay.noteStartFailure).toHaveBeenCalledWith('shared-provider', shared, expect.objectContaining({ message: expect.stringContaining('REMOTE_AGENT_PEER_TOO_OLD') }));
+ await client.close('close', 'navigation');
+ });
+
+ it('checks consent capability again when resuming an existing relay binding after downgrade', async () => {
+ const shared: GroupRelayMember = { memberKey: 'share:a:anthropic', agentDeviceId: 'studio', providerId: 'anthropic', sameAccount: false };
+ let capable = true;
+ let capsChecks = 0;
+ let opens = 0;
+ const env = setup({
+ plans: [{ kind: 'member', ...shared }],
+ intercept: async (id, request, forward) => {
+ if (request.op === 'caps' && id === 'studio') {
+ capsChecks += 1;
+ return { ...await forward() as object, ...(capable ? { reshareConsent: true } : {}) };
+ }
+ if (request.op === 'open' && id === 'studio') opens += 1;
+ return forward();
+ },
+ });
+ const first = await openAsGuest(env, C_AT_B, openPayload(SESSION));
+ const nativeId = first.started.id;
+ await first.client.close('close', 'navigation');
+ capable = false;
+ await expect(openAsGuest(env, C_AT_B, openPayload(SESSION, { options: { resumeSessionId: nativeId } })))
+ .rejects.toThrow(/REMOTE_AGENT_UNAVAILABLE/);
+ expect(capsChecks).toBe(2);
+ expect(opens).toBe(1);
+ expect(env.memberStarted.studio).toHaveLength(1);
+ // 续接使用已有绑定,没有经过 plan,仍必须挡住旧端。
+ expect(env.relay.plan).toHaveBeenCalledTimes(1);
+ await env.owner.abortAll();
+ });
+});
diff --git a/apps/desktop/src/main/remote-agent/host/groupRelay.ts b/apps/desktop/src/main/remote-agent/host/groupRelay.ts
index 092b716e30..497a67162b 100644
--- a/apps/desktop/src/main/remote-agent/host/groupRelay.ts
+++ b/apps/desktop/src/main/remote-agent/host/groupRelay.ts
@@ -10,7 +10,7 @@
*/
import { createHash, randomBytes } from 'node:crypto';
-import { REMOTE_AGENT_GROUP_SWITCH_STATE_KEY, type RemoteAgentErrorInfo } from '@cindy/device-link';
+import { parseProviderSharePeer, REMOTE_AGENT_GROUP_SWITCH_STATE_KEY, type RemoteAgentErrorInfo } from '@cindy/device-link';
import { isTerminalAgentErrorEvent, type AgentEvent } from '@cindy/maker-core';
/** 受邀者在组内电脑上的不透明键(32 位十六进制)。 */
@@ -18,6 +18,20 @@ export function relayKeyFor(guestController: string): string {
return createHash('sha256').update(`provider-group-relay\0${guestController}`).digest('hex').slice(0, 32);
}
+/**
+ * 受邀者的转分享键(32 位十六进制,provider-sharing.md §4.3):按本机分享给他的那个分享与成员派生,同一个人从
+ * 哪台电脑来都相同(relay 键按设备分)。分享来的组内电脑的主人按这个键逐人同意;不含身份信息。
+ */
+export function reshareKeyFor(shareId: string, memberId: string): string {
+ return createHash('sha256').update(`provider-group-reshare\0${shareId}\0${memberId}`).digest('hex').slice(0, 32);
+}
+
+/** 受邀者对端 → 转分享键;不是受邀者返回 undefined。 */
+export function reshareKeyForGuest(guestController: string): string | undefined {
+ const peer = parseProviderSharePeer(guestController);
+ return peer?.role === 'guest' ? reshareKeyFor(peer.shareId, peer.memberId) : undefined;
+}
+
/** 受邀者任务在组内电脑上的任务 id。 */
export function relaySessionIdFor(guestController: string, sessionId: string): string {
return `g${createHash('sha256').update(`${guestController}\0${sessionId}`).digest('hex').slice(0, 40)}`;
@@ -28,7 +42,7 @@ export function relaySessionIdFor(guestController: string, sessionId: string): s
* 对受邀者没有意义,还会透露组内电脑与本机的关系:统一成「暂时不可用」。Agent 本身的报错(用量上限等)
* 在事件流里,不经过这里。
*/
-const LOCATION_CODES = /^REMOTE_AGENT_(?:SHARE_PAUSED|SHARE_REMOVED|SHARE_UNAVAILABLE|PROVIDER_NOT_ALLOWED|ACCOUNT_CHANGED|PEER_TOO_OLD|DEVICE_UNREACHABLE|BUSY|UNAVAILABLE)$|^(?:ACCESS_REVOKED|REMOTE_DISABLED|CHANNEL_NOT_ALLOWED|UNSUPPORTED_CAPABILITY|DEVICE_OFFLINE|PEER_RESET|TIMEOUT|INVOKE_TIMEOUT|LINK_CLOSED|LINK_NOT_OPEN|NOT_CONNECTED)$/;
+const LOCATION_CODES = /^REMOTE_AGENT_(?:SHARE_PAUSED|SHARE_REMOVED|SHARE_UNAVAILABLE|PROVIDER_NOT_ALLOWED|RESHARE_NOT_ALLOWED|ACCOUNT_CHANGED|PEER_TOO_OLD|DEVICE_UNREACHABLE|BUSY|UNAVAILABLE)$|^(?:ACCESS_REVOKED|REMOTE_DISABLED|CHANNEL_NOT_ALLOWED|UNSUPPORTED_CAPABILITY|DEVICE_OFFLINE|PEER_RESET|TIMEOUT|INVOKE_TIMEOUT|LINK_CLOSED|LINK_NOT_OPEN|NOT_CONNECTED)$/;
export const RELAY_UNAVAILABLE_ERROR: RemoteAgentErrorInfo = {
code: 'REMOTE_AGENT_UNAVAILABLE',
diff --git a/apps/desktop/src/main/remote-agent/host/runHost.ts b/apps/desktop/src/main/remote-agent/host/runHost.ts
index 57d6909f86..aa3ee38554 100644
--- a/apps/desktop/src/main/remote-agent/host/runHost.ts
+++ b/apps/desktop/src/main/remote-agent/host/runHost.ts
@@ -39,6 +39,9 @@ import {
type RemoteAgentPayload,
type RemoteAgentPollResult,
type RemoteAgentReply,
+ type RemoteAgentReshareBatch,
+ type RemoteAgentReshareEntry,
+ type RemoteAgentReshareResult,
type RemoteAgentReverseRequest,
type RemoteAgentTeardownReason,
} from '@cindy/device-link';
@@ -58,6 +61,7 @@ import {
relayMemberConnId,
relayRunFailureOf,
relaySessionIdFor,
+ reshareKeyForGuest,
type RelayRunFailure,
} from './groupRelay';
import { PROVIDER_GROUP_LOCAL_MEMBER_KEY } from '../../../shared/providerGroup';
@@ -212,6 +216,15 @@ export interface RemoteAgentHostDeps {
* 组内电脑运行,本机中转。不提供 = 受邀者的任务一律在本机运行(现有接线)。
*/
groupRelay?: RemoteAgentGroupRelayDeps;
+ /**
+ * 转分享(本机是分享者,docs/product-rules/provider-sharing.md §4.3):受邀者把这里分享的供应商放进了它自己的
+ * 供应商组又分享给了别人。组所在电脑(受邀者)经 op `reshare` 报上它分享的人,本机记下等主人逐人同意;组转来的
+ * 受邀者任务(带 relay)只在主人同意过的人上运行。不提供 = 不接受 op `reshare`、也不核对(测试 / 旧接线)。
+ */
+ reshare?: {
+ sync(controller: string, entries: readonly RemoteAgentReshareEntry[], batch?: RemoteAgentReshareBatch): Promise<RemoteAgentReshareResult>;
+ allows(controller: string, reshareKey: string | undefined): boolean;
+ };
captureOwner(): unknown;
isOwnerCurrent(owner: unknown): boolean;
/** 本机存放影子目录与附件的根目录。 */
@@ -270,7 +283,14 @@ export interface RemoteAgentGroupRelayDeps {
providerId: string;
exclude: ReadonlySet<string>;
reserve?: boolean;
+ /**
+ * 这个受邀者的转分享键(provider-sharing.md §4.3):分享来的组内电脑只在它的主人同意过这个人时才选;
+ * 没有时一律不选分享来的电脑。
+ */
+ reshareKey?: string;
}): Promise<GroupRelayPlan | null>;
+ /** 分享来的那台拒绝了这个受邀者(主人没同意或已撤回):组所在电脑据此重新核对同意情况。 */
+ noteReshareDenied?(agentDeviceId: string, reshareKey: string): void;
/** 经设备互联连某台组内电脑的远程 Agent 通道(与本机作为控制端共用拉取器)。 */
connect(agentDeviceId: string): { invoke: RemoteAgentInvoke; poller: RemoteAgentPoller };
/**
@@ -355,6 +375,11 @@ interface Run {
* 会话索引、受邀者目录与运行数都按(控制端, relay)分开。
*/
relayKey?: string;
+ /**
+ * 受邀者(本机的分享成员)的组转来的、它分享的那个人的任务:那个人的转分享键。主人撤回对这个人的同意时
+ * 按它结束任务(abortReshare)。
+ */
+ reshareKey?: string;
/** 本机是组所在电脑、把这个受邀者任务转给了组内电脑。 */
relay?: RelayBackend;
/**
@@ -1105,6 +1130,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
providerId: run.providerId,
exclude: tried,
reserve: true,
+ reshareKey: reshareKeyForGuest(run.controller),
}).catch(() => null);
if (next?.kind !== 'member' || run.closing) {
if (next && next.kind !== 'unavailable') next.load?.release();
@@ -1212,13 +1238,16 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
/** 转给组内电脑的打开载荷:已按受邀者复核过;来源换成那台上的供应商,带防转圈标记与受邀者的 relay 键。 */
function relayedOpenPayload(run: Run, payload: RemoteAgentOpenPayload, member: GroupRelayMember): RemoteAgentOpenPayload {
- // 「需要换一台」只在受邀者与本机之间:组内电脑不认识也不需要。
- const { acceptsGroupSwitch: _accepts, groupSwitchToken: _token, ...rest } = payload;
+ // 「需要换一台」只在受邀者与本机之间:组内电脑不认识也不需要。受邀者自己填的转分享键不转发。
+ const { acceptsGroupSwitch: _accepts, groupSwitchToken: _token, reshareKey: _reshare, ...rest } = payload;
+ // 分享来的组内电脑按这个人的转分享键核对它的主人是否同意过(provider-sharing.md §4.3)。
+ const reshareKey = member.sameAccount ? undefined : reshareKeyForGuest(run.controller);
return {
...rest,
sessionId: relaySessionIdFor(run.controller, payload.sessionId),
groupAssigned: true,
relay: relayKeyFor(run.controller),
+ ...(reshareKey ? { reshareKey } : {}),
options: { ...payload.options, providerId: member.providerId },
};
}
@@ -1257,7 +1286,13 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
// 旧版受邀者不认识这个状态:照旧只转出原来的错误。
if (!run.acceptsGroupSwitch) return null;
const exclude = noteGroupSwitchTried(run, member);
- const next = await relayDeps.plan({ kind: run.kind, model, providerId: run.providerId, exclude }).catch(() => null);
+ const next = await relayDeps.plan({
+ kind: run.kind,
+ model,
+ providerId: run.providerId,
+ exclude,
+ reshareKey: reshareKeyForGuest(run.controller),
+ }).catch(() => null);
const canMove = next?.kind === 'member' || (next?.kind === 'local' && deps.isAgentAvailable(run.kind));
if (!canMove || run.closing) return null;
deps.log?.info('remote agent: offered the shared user another computer in the provider group', {
@@ -1458,7 +1493,8 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
run.relay = backend;
try {
const caps = await RemoteAgentRunClient.caps(connection.invoke);
- if (caps.virtualWorkspace !== true || (current.sameAccount && caps.guestRelay !== true)) {
+ if (caps.virtualWorkspace !== true
+ || (current.sameAccount ? caps.guestRelay !== true : caps.reshareConsent !== true)) {
throw new Error('[REMOTE_AGENT_PEER_TOO_OLD] the computer in the provider group cannot take shared tasks yet');
}
// 等 caps 期间任务已经结束(撤权、受邀者关闭):不再打开(收尾已经放掉了这次尝试的负载)。
@@ -1500,6 +1536,11 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
// 这次尝试里受邀者那边已经打开的连接全部关掉,下一次尝试的连接编号不同。
for (const connId of wsOpened) append(run, { t: 'ws', connId, kind: 'close' });
if (run.closing) break;
+ // 分享来的那台拒绝了这个人(主人没同意或刚撤回):组所在电脑重新核对同意情况,之后不再选它。
+ const reshareKey = reshareKeyForGuest(run.controller);
+ if (!current.sameAccount && reshareKey && /\[REMOTE_AGENT_RESHARE_NOT_ALLOWED\]/.test(String(error))) {
+ relayDeps.noteReshareDenied?.(current.agentDeviceId, reshareKey);
+ }
// 续接只能回到原来那台:那台接不下时请受邀者交接后重新打开,由组换一台(凭证排在启动失败前面)。
if (!options.fresh) {
await offerSwitchAfterResumeFailure(run, current, error, backend.model ?? payload.options.model);
@@ -1519,6 +1560,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
providerId: groupProviderId,
exclude: tried,
reserve: true,
+ reshareKey,
}).catch(() => null);
if (next?.kind === 'local' && deps.isAgentAvailable(run.kind) && !run.closing) {
if (next.load) run.groupLoad = next.load;
@@ -1991,6 +2033,9 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
virtualWorkspace: true,
// 能按受邀者隔离运行(供应商级授权与出站边界都已接上),才接受组所在电脑中转过来的受邀者任务。
...(deps.providerAccess && deps.bindGuestProviderRoute ? { guestRelay: true } : {}),
+ // 转分享的同意只对受邀者(把这里分享的供应商放进自己组的人)有意义。
+ ...(guest && deps.reshare ? { reshareConsent: true } : {}),
+ ...(guest && deps.reshare ? { reshareBatch: true } : {}),
};
return caps;
}
@@ -1998,6 +2043,10 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
// 组所在电脑删掉了某个受邀者:清掉替它运行过的任务。只作用于调用方自己的 relay。
await forgetRelay(controller, request.relay);
return {};
+ case 'reshare':
+ // 转分享:受邀者的组所在电脑报上它分享的人(整体替换它上一份),主人逐人同意。同账号电脑经组使用不需要同意。
+ if (!deps.reshare || trustOf(controller) !== 'guest') fail('REMOTE_AGENT_INVALID', 'reshare is only for shared users');
+ return deps.reshare.sync(controller, request.entries, request.batch);
case 'upload': {
const uploadKey = key(controller, request.uploadId);
let upload = uploads.get(uploadKey);
@@ -2038,6 +2087,13 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
if (relayKey && guestUnsupported) {
fail('REMOTE_AGENT_UNSUPPORTED', `${request.agentKind} is not available to shared users on this computer`);
}
+ // 转分享(provider-sharing.md §4.3):受邀者的组替它分享的人转来的任务,只在本机主人同意过那个人时运行。
+ // 新错误码只回给带了 reshareKey 的组所在电脑;旧版本按「没开放这个供应商」处理,照常换组里下一台。
+ const reshareKey = controllerTrust === 'guest' && relayKey ? payload.reshareKey : undefined;
+ if (controllerTrust === 'guest' && relayKey && deps.reshare && !deps.reshare.allows(controller, reshareKey)) {
+ if (reshareKey) fail('REMOTE_AGENT_RESHARE_NOT_ALLOWED', 'the owner of this computer has not agreed to this user');
+ failProviderNotAllowed();
+ }
// 运行数按受邀者作用域各算一份;同一控制端替多个受邀者中转时另有合计上限。只有同账号控制端(组所在电脑)
// 的 relay 才各算一份:受邀者自己填的 relay 只把它的数据分开存放,不能用来绕开它的运行数上限。
const active = [...runs.values()].filter((run) => run.controller === controller && run.closedAt === undefined);
@@ -2099,6 +2155,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
providerId,
exclude: new Set(avoid),
reserve: true,
+ reshareKey: reshareKeyForGuest(controller),
});
if (plan?.kind === 'unavailable') fail('REMOTE_AGENT_UNAVAILABLE', 'no computer can run this task right now');
if (plan?.kind === 'member' || plan?.kind === 'local') reserved = plan.load;
@@ -2117,11 +2174,19 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
reserved?.release();
return {};
}
+ // 查询供应商与续接归属期间主人可能已经撤回,而尚未登记的任务不会被 abortReshare 找到。
+ // 最后一次核对与 runs.set 之间不能 await;登记后撤回会走正常的任务收尾。
+ if (controllerTrust === 'guest' && relayKey && deps.reshare && !deps.reshare.allows(controller, reshareKey)) {
+ reserved?.release();
+ if (reshareKey) fail('REMOTE_AGENT_RESHARE_NOT_ALLOWED', 'the owner of this computer has not agreed to this user');
+ failProviderNotAllowed();
+ }
const run: Run = {
id: request.runId,
controller,
trust,
...(relayKey ? { relayKey } : {}),
+ ...(reshareKey ? { reshareKey } : {}),
owner: deps.captureOwner(),
kind: request.agentKind,
log: new EventLog(REMOTE_AGENT_HOST_UNREAD_BYTES),
@@ -2270,6 +2335,15 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
.filter((run) => match(run.controller))
.map((run) => finishRun(run, 'access-revoked', 'navigation')));
},
+ /**
+ * 转分享的同意被撤回(provider-sharing.md §4.3):立即结束匹配控制端(受邀者的组所在电脑)替那个人转来的任务。
+ * 那个人的会话记录与目录留着,主人再同意后还能续接;受邀者删除时随它一起清理。
+ */
+ async abortReshare(match: (controller: string) => boolean, reshareKey: string): Promise<void> {
+ await Promise.all([...runs.values()]
+ .filter((run) => run.reshareKey === reshareKey && match(run.controller))
+ .map((run) => finishRun(run, 'access-revoked', 'navigation')));
+ },
/**
* 受邀者的分享删除后:结束匹配控制端(同一成员的每台设备)的任务,删除它们的影子工作区与
* 附件,以及本机 Agent 目录里它们的会话记录。
diff --git a/apps/desktop/src/main/remote-agent/host/service.ts b/apps/desktop/src/main/remote-agent/host/service.ts
index 1795732c18..3dfd3dbf14 100644
--- a/apps/desktop/src/main/remote-agent/host/service.ts
+++ b/apps/desktop/src/main/remote-agent/host/service.ts
@@ -17,7 +17,9 @@ import {
import { setRemoteAgentHandler } from '../../device-link/dispatch.js';
import { remoteBackgroundInvoke } from '../../device-link/index.js';
import { providerShareGuestAccess } from '../../device-link/providerShareHost.js';
+import { handleProviderShareReshare, providerShareReshareAllows } from '../../device-link/providerShareReshare.js';
import { createProviderGroupGuestRelay } from '../../provider-group/guestRelay.js';
+import { providerGroupReshare } from '../../provider-group/reshareRuntime.js';
import { getProviderGroupOwnerScope } from '../../provider-group/runtime.js';
import { readProviderGroup } from '../../provider-group/store.js';
import { remoteAgentPollerFor } from '../controller/service';
@@ -108,6 +110,10 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
},
// 组内电脑的报错用那台机器的本地时间:不带时区的钟点不按本机时区理解。
readResetAt: (failure) => readTurnUsageResetAt(failure, Date.now(), { localTimeZoneTrusted: false }),
+ // 转分享(provider-sharing.md §4.3):分享来的电脑只给它的主人同意过的人。
+ reshareAllows: providerGroupReshare.allows,
+ noteReshareDenied: providerGroupReshare.noteDenied,
+ reshareNeedsUpdate: providerGroupReshare.needsUpdate,
now: () => Date.now(),
log,
});
@@ -173,6 +179,8 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
recordOwnerUsage: (controller, sample) => recordDeviceUsage(controller, sample, 'device'),
// 供应商组(本机是组所在电脑):受邀者的任务按组分给组内电脑,本机中转(provider-groups.md §4)。
groupRelay,
+ // 转分享(本机是分享者):受邀者的组替它分享的人转来的任务,只在本机主人同意过那个人时运行。
+ reshare: { sync: handleProviderShareReshare, allows: providerShareReshareAllows },
captureOwner: captureDataOwnerBroadcastScope,
isOwnerCurrent: (owner) => isDataOwnerBroadcastScopeCurrent(owner as DataOwnerBroadcastScope),
runsRoot: path.join(options.userDataDir, 'remote-agent'),
@@ -185,10 +193,11 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
void current.abortAll();
},
abortControllers: (match) => current.abortControllers(match),
+ abortReshare: (match, reshareKey) => current.abortReshare(match, reshareKey),
purgeControllers: (match) => current.purgeControllers(match),
activeControllers: () => current.activeControllers(),
turnRunningControllers: () => current.turnRunningControllers(),
- sharedGroupStatus: (providerId) => groupRelay.sharedStatus(providerId),
+ sharedGroupStatus: (providerId, guestController) => groupRelay.sharedStatus(providerId, guestController),
});
}
diff --git a/apps/desktop/src/main/remote-agent/wire.ts b/apps/desktop/src/main/remote-agent/wire.ts
index 7bdbe4edcf..8d9909814f 100644
--- a/apps/desktop/src/main/remote-agent/wire.ts
+++ b/apps/desktop/src/main/remote-agent/wire.ts
@@ -168,6 +168,12 @@ export interface RemoteAgentOpenPayload {
* 隔离运行,会话记录与目录按(控制端, relay)分开。只发给 caps 声明了 guestRelay 的电脑。
*/
relay?: string;
+ /**
+ * 供应商组转分享:组所在电脑把受邀者的任务转给分享来的组内电脑时,带上这个受邀者(按账号)的转分享键,
+ * 与组所在电脑经 op `reshare` 报上去的键相同。那台的主人同意过这个人才运行;没同意或没带时拒绝。
+ * 只发给分享来的组内电脑;旧版本解码时丢弃。
+ */
+ reshareKey?: string;
/**
* 任务所在电脑支持「需要换一台」(docs/product-rules/provider-groups.md §6.1 分享的人):组所在电脑中转的
* 任务在组内电脑上因电脑本身的原因失败时,先在事件流里发一个 `providerGroupSwitch` 状态(一次性凭证)
@@ -322,6 +328,9 @@ export function decodeOpenPayload(value: unknown): RemoteAgentOpenPayload {
...(value.virtualWorkspace === true ? { virtualWorkspace: true } : {}),
...(value.groupAssigned === true ? { groupAssigned: true } : {}),
...(typeof value.relay === 'string' && REMOTE_AGENT_RELAY_KEY_PATTERN.test(value.relay) ? { relay: value.relay } : {}),
+ ...(typeof value.reshareKey === 'string' && REMOTE_AGENT_RELAY_KEY_PATTERN.test(value.reshareKey)
+ ? { reshareKey: value.reshareKey }
+ : {}),
...(value.acceptsGroupSwitch === true ? { acceptsGroupSwitch: true } : {}),
...(typeof value.groupSwitchToken === 'string' && REMOTE_AGENT_RELAY_KEY_PATTERN.test(value.groupSwitchToken)
? { groupSwitchToken: value.groupSwitchToken }
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index f77410ec5e..69f709f117 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -849,6 +849,7 @@ const fanOutProviderShareRequested = createIpcFanOut(PROVIDER_SHARE_IPC.REQUESTE
const fanOutProviderShareSettled = createIpcFanOut(PROVIDER_SHARE_IPC.SETTLED);
const fanOutProviderShareOpenJoin = createIpcFanOut(PROVIDER_SHARE_IPC.OPEN_JOIN);
const fanOutProviderShareOpenManage = createIpcFanOut(PROVIDER_SHARE_IPC.OPEN_MANAGE);
+const fanOutProviderShareReshareRequested = createIpcFanOut(PROVIDER_SHARE_IPC.RESHARE_REQUESTED);
const fanOutDeviceLinkOwnershipChanged = createIpcFanOut('device-link:ownership-changed');
// 控制端:目标设备「无响应」熔断状态翻转(payload = { deviceId, unresponsive })
const fanOutDeviceLinkResponsivenessChanged = createIpcFanOut('device-link:responsiveness-changed');
@@ -4544,6 +4545,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
onSettled: fanOutProviderShareSettled,
onOpenJoin: fanOutProviderShareOpenJoin,
onOpenManage: fanOutProviderShareOpenManage,
+ onReshareRequested: fanOutProviderShareReshareRequested,
},
// 供应商组:这台电脑上某个供应商的组设置(只接受本机应用窗口)。
providerGroup: {
diff --git a/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx b/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
index dc1a76ceca..be116b1997 100644
--- a/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
+++ b/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
@@ -131,6 +131,7 @@ import {
} from '@/features/provider-share/providerShareNavigation';
import {
useProviderSharePendingRequests,
+ useProviderSharePendingReshares,
useProviderShareReceived,
} from '@/features/provider-share/providerShareStore';
@@ -2433,11 +2434,15 @@ export function ProvidersSection() {
// 该状态下 OpenAI 行必须留在左栏,否则「重新连接」入口不可达,用户被迫从向导重发现。
const codexAuth = useCodexAuth();
const remoteControlEnabled = useRemoteControlEnabled();
- // 供应商分享:入口提示点读待审批申请;管理页是本页的子页面(返回回到供应商详情)。
+ // 供应商分享:入口提示点读待审批申请与待处理的转分享请求;管理页是本页的子页面(返回回到供应商详情)。
const pendingShareRequests = useProviderSharePendingRequests();
+ const pendingReshares = useProviderSharePendingReshares();
const pendingShareCounts = useMemo(
- () => pendingRequestCountByProvider(pendingShareRequests.map((item) => item.share)),
- [pendingShareRequests],
+ () => pendingRequestCountByProvider([
+ ...pendingShareRequests.map((item) => item.share),
+ ...pendingReshares.map((item) => item.share),
+ ]),
+ [pendingShareRequests, pendingReshares],
);
const [shareManageProviderId, setShareManageProviderId] = useState<string | null>(null);
const openaiReconnectRequired = codexAuth.state.kind === 'reconnect-required';
diff --git a/apps/desktop/src/renderer/features/provider-group/GroupMemberReshare.tsx b/apps/desktop/src/renderer/features/provider-group/GroupMemberReshare.tsx
new file mode 100644
index 0000000000..e42cf38790
--- /dev/null
+++ b/apps/desktop/src/renderer/features/provider-group/GroupMemberReshare.tsx
@@ -0,0 +1,61 @@
+/**
+ * 组里分享来的电脑:它的主人是否同意本机分享出去的人经组使用它(docs/product-rules/provider-sharing.md §4.3)。
+ * 状态行带一句摘要;展开这一行时逐人列出。只在本机的组、组所在的供应商分享给了别人时出现。
+ */
+import { useTranslation } from 'react-i18next';
+
+import { cn } from '@/lib/utils';
+
+import type { ProviderGroupReshareGuest, ProviderGroupReshareSummary } from '../../../shared/providerGroup';
+import { ShareAvatar } from '../provider-share/ShareAvatar';
+
+type Translate = ReturnType<typeof useTranslation>['t'];
+
+/** 状态行的一句摘要:都同意了、有人在等、有人没被同意、那台需要更新或还没问到。 */
+export function reshareSummaryText(t: Translate, summary: ProviderGroupReshareSummary, owner: string): string {
+ if (summary.support === 'needs-update') return t('providerGroup.member.reshare.needsUpdate', { owner });
+ if (summary.support === 'unknown') return t('providerGroup.member.reshare.unknown', { owner });
+ const count = (state: ProviderGroupReshareGuest['state']) => summary.guests.filter((guest) => guest.state === state).length;
+ if (count('approved') === summary.guests.length) return t('providerGroup.member.reshare.allApproved');
+ if (count('pending') > 0) return t('providerGroup.member.reshare.waiting', { count: count('pending'), owner });
+ if (count('rejected') > 0) return t('providerGroup.member.reshare.rejected', { count: count('rejected'), owner });
+ return t('providerGroup.member.reshare.unknown', { owner });
+}
+
+export function GroupMemberReshare({ summary, owner }: { summary: ProviderGroupReshareSummary; owner: string }) {
+ const { t } = useTranslation();
+ return (
+ // 与上方的额度说明一样缩进到电脑名一列:说明的是这一台。
+ <div data-testid="provider-group-member-reshare" className="-mt-1 flex flex-col gap-1.5 pb-3 pl-11 pr-4">
+ <div className="flex flex-col gap-0.5 px-4">
+ <span className="text-12 font-medium text-[var(--text-secondary)]">{t('providerGroup.member.reshare.title')}</span>
+ <span className="text-12 leading-[1.5] text-[var(--text-tertiary)]">
+ {summary.support === 'needs-update'
+ ? t('providerGroup.member.reshare.needsUpdate', { owner })
+ : t('providerGroup.member.reshare.description', { owner })}
+ </span>
+ </div>
+ {summary.guests.map((guest) => (
+ <div key={guest.memberId} data-testid="provider-group-member-reshare-guest" className="flex items-center gap-2 px-4">
+ <ShareAvatar
+ displayName={guest.displayName}
+ avatarUrl={guest.avatarUrl}
+ size="sm"
+ className={cn(guest.state !== 'approved' && 'opacity-70')}
+ />
+ <span className="min-w-0 flex-1 truncate text-13 text-[var(--text-primary)]">{guest.displayName}</span>
+ <span className="inline-flex shrink-0 items-center gap-1.5 text-12 text-[var(--text-secondary)]">
+ <span
+ aria-hidden="true"
+ className="h-1.5 w-1.5 shrink-0 rounded-full"
+ style={{
+ background: guest.state === 'approved' ? 'var(--remote-status-ready)' : 'var(--remote-status-disconnected)',
+ }}
+ />
+ {t(`providerGroup.member.reshare.state.${summary.support === 'supported' ? guest.state : 'unknown'}`)}
+ </span>
+ </div>
+ ))}
+ </div>
+ );
+}
diff --git a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
index a6e8443c65..057f0626ee 100644
--- a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
@@ -41,6 +41,7 @@ import {
} from '../../../shared/providerGroup';
import { providerShareComputerName, useProviderShareOwnerNameOf } from '../provider-share/providerShareNames';
import { GroupMemberQuota, groupMemberQuotaTarget } from './GroupMemberQuota';
+import { GroupMemberReshare, reshareSummaryText } from './GroupMemberReshare';
import { GroupMemberDetailsButton, GroupMemberVersion } from './GroupMemberVersion';
import { ProviderGroupAddDialog } from './ProviderGroupAddDialog';
import { useProviderGroup } from './useProviderGroup';
@@ -268,6 +269,7 @@ function MemberRow({
// 「已满」等于跑满上限,上限就在旁边的下拉里,不必再报一遍数。其余状态(冷却、不在线、已暂停)
// 上面可能还有在跑的任务,补一段运行数。
const appendRunning = running > 0 && status != null && status.state !== 'available' && status.state !== 'full';
+ const reshare = member.kind === 'share' ? status?.reshare : undefined;
// 点名称一侧展开这台的剩余额度(2026-10-10 用户要求);收起时不读。
const [quotaOpen, setQuotaOpen] = useState(false);
const quotaId = useId();
@@ -326,6 +328,15 @@ function MemberRow({
</span>
</>
)}
+ {/* 分享来的电脑:它的主人是否同意给本机分享的人用(provider-sharing.md §4.3),展开看每个人。 */}
+ {reshare && (
+ <>
+ <span aria-hidden="true">·</span>
+ <span data-testid="provider-group-member-reshare-summary">
+ {reshareSummaryText(t, reshare, ownerName ?? '')}
+ </span>
+ </>
+ )}
</span>
</span>
</GroupMemberDetailsButton>
@@ -389,6 +400,7 @@ function MemberRow({
offline={status?.state === 'offline'}
/>
)}
+ {quotaOpen && reshare && <GroupMemberReshare summary={reshare} owner={ownerName ?? ''} />}
</div>
);
}
diff --git a/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx b/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx
index cc931314af..8e74d77043 100644
--- a/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx
@@ -159,6 +159,40 @@ describe('ProviderGroupSection', () => {
expect(await screen.findAllByTestId('provider-group-member')).toHaveLength(2);
});
+ // 转分享(provider-sharing.md §4.3):分享来的电脑的主人是否同意本机分享出去的人经组使用它。
+ it('shows whether the owner of a shared-in computer agreed to the people this computer shares with', async () => {
+ realLocale = createInstance();
+ await realLocale.init({ lng: 'zh-CN', resources: { 'zh-CN': { translation: zhCN } }, interpolation: { escapeValue: false } });
+ const SHARED = { key: 'share:s1:anthropic', kind: 'share' as const, agentDeviceId: 'share:s1', providerId: 'anthropic', limit: 4, weight: 1, paused: false };
+ stored = { strategy: 'least', autoSwitch: true, members: [LOCAL, SHARED] };
+ const view = viewOf(stored);
+ view.members[1] = {
+ ...view.members[1],
+ state: 'available',
+ ownerName: 'Kai',
+ reshare: {
+ support: 'supported',
+ guests: [
+ { memberId: 'c', displayName: 'Carol', avatarUrl: null, state: 'pending' },
+ { memberId: 'd', displayName: 'Dave', avatarUrl: null, state: 'approved' },
+ ],
+ },
+ };
+ command.mockImplementation(async (cmd: { action: string }) => (cmd.action === 'list' ? { anthropic: stored } : view));
+ render(<ProviderGroupSection providerId="anthropic" providerName="Anthropic" />);
+ const rows = await screen.findAllByTestId('provider-group-member');
+ await waitFor(() => expect(within(rows[1]).getByTestId('provider-group-member-reshare-summary').textContent)
+ .toBe('1 位分享的人等待 Kai 同意'));
+ // 本机这一行不显示。
+ expect(within(rows[0]).queryByTestId('provider-group-member-reshare-summary')).toBeNull();
+ expect(screen.queryByTestId('provider-group-member-reshare')).toBeNull();
+ fireEvent.click(rows[1].querySelector<HTMLButtonElement>('button[aria-expanded]')!);
+ const list = within(rows[1]).getByTestId('provider-group-member-reshare');
+ expect(list.textContent).toContain('需要 Kai 逐人同意');
+ const guests = within(list).getAllByTestId('provider-group-member-reshare-guest');
+ expect(guests.map((guest) => guest.textContent)).toEqual(['CCarol等待同意', 'DDave已同意']);
+ });
+
it('expands a computer to show the quota of its own account', async () => {
stored = { strategy: 'least', autoSwitch: true, members: [LOCAL, MINI] };
render(<ProviderGroupSection providerId="anthropic" providerName="Anthropic" />);
diff --git a/apps/desktop/src/renderer/features/provider-share/ProviderShareGlobalHost.tsx b/apps/desktop/src/renderer/features/provider-share/ProviderShareGlobalHost.tsx
index 7581de2540..227658c3bb 100644
--- a/apps/desktop/src/renderer/features/provider-share/ProviderShareGlobalHost.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/ProviderShareGlobalHost.tsx
@@ -3,6 +3,7 @@
*
* - 分享者:启动时读一次 `owned`,把本次运行还没弹过的待审批申请排队;之后靠 REQUESTED 推送。
* 逐条弹审批弹窗,Esc / × = 稍后处理(申请留在管理页)。系统通知点击 → 打开对应管理页。
+ * 转分享请求(成员经自己的供应商组转给别人用)不弹窗:RESHARE_REQUESTED 时重读,入口亮提示点、管理页处理。
* - 受邀者:分享链接(深链、粘贴、系统通知)→ 申请弹窗。等待期间关掉弹窗的申请,有结果时用
* toast 告知。同时启动「已收到的分享」同步,模型列表随时可用。
*/
@@ -24,6 +25,7 @@ import {
addProviderShareRequested,
refreshProviderShareFavoriteMembership,
getProviderSharePendingRequests,
+ getProviderSharePendingReshares,
refreshProviderShareOwnerPending,
useProviderSharePendingRequests,
} from './providerShareStore';
@@ -85,10 +87,14 @@ export function ProviderShareGlobalHost() {
addProviderShareRequested(event);
enqueue([event.request.requestId]);
});
- // 只在还有待审批申请时随推送重读(那时 main 本就在快速拉取),让撤回、过期的申请消失。
+ // 只在还有待审批申请(含转分享请求)时随推送重读(那时 main 本就在快速拉取),让撤回、过期、已处理的消失。
const offOwned = api.onOwnedChanged(() => {
- if (getProviderSharePendingRequests().length > 0) void refreshProviderShareOwnerPending();
+ if (getProviderSharePendingRequests().length > 0 || getProviderSharePendingReshares().length > 0) {
+ void refreshProviderShareOwnerPending();
+ }
});
+ // 转分享请求不弹窗:重读一次,设置页入口亮提示点、管理页「待处理」一栏出现(provider-sharing.md §4.3)。
+ const offReshare = api.onReshareRequested?.(() => void refreshProviderShareOwnerPending()) ?? (() => undefined);
const offManage = api.onOpenManage(({ providerId }) => {
navigateRef.current(providerShareManagePath(providerId));
});
@@ -128,6 +134,7 @@ export function ProviderShareGlobalHost() {
disposed = true;
offRequested();
offOwned();
+ offReshare();
offManage();
offOpenJoin();
offSettled();
diff --git a/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx b/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx
index 09b8aa477b..fb8f91125c 100644
--- a/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx
@@ -21,10 +21,11 @@ import type {
ProviderOwnUsageView,
ProviderShareMemberView,
ProviderShareOwnerState,
+ ProviderShareReshareView,
ProviderShareUsageRange,
} from '../../../shared/providerShare';
import { ProviderShareLinkDialog } from './ProviderShareLinkDialog';
-import type { ProviderShareGate, ProviderSharePendingRequest } from './providerShareFormat';
+import { pendingResharesFromOwned, type ProviderShareGate, type ProviderSharePendingRequest } from './providerShareFormat';
import { ProviderUsageSection } from './ProviderUsageSection';
import { publishProviderShareOwnerState, removeProviderSharePendingRequest } from './providerShareStore';
import { ShareAvatar } from './ShareAvatar';
@@ -97,7 +98,7 @@ export function ProviderShareManagePage({
}, [load]);
// 同一个供应商在这台电脑上只应有一条分享;稳妥起见合并同供应商的全部记录。
- const { members, requests } = useMemo(() => {
+ const { members, requests, reshares } = useMemo(() => {
const shares = state?.ready ? state.shares.filter((share) => share.providerId === providerId) : [];
const pending: ProviderSharePendingRequest[] = [];
for (const share of shares) {
@@ -109,7 +110,12 @@ export function ProviderShareManagePage({
}
}
pending.sort((a, b) => Date.parse(a.request.createdAt) - Date.parse(b.request.createdAt));
- return { members: shares.flatMap((share) => share.members), requests: pending };
+ return {
+ members: shares.flatMap((share) => share.members),
+ requests: pending,
+ // 转分享请求(provider-sharing.md §4.3):成员想经自己的供应商组把这里分享的供应商转给别人用。
+ reshares: pendingResharesFromOwned(shares),
+ };
}, [providerId, state]);
const withBusy = useCallback(async (key: string, run: () => Promise<void>) => {
@@ -167,6 +173,27 @@ export function ProviderShareManagePage({
[load, t, withBusy],
);
+ /** 转分享:同意、拒绝,或撤回已同意的(撤回立即停止这个人经组转来的任务)。只改本机记录。 */
+ const decideReshare = useCallback(
+ (reshare: ProviderShareReshareView, owner: string, decision: 'approve' | 'reject') =>
+ withBusy(reshare.id, async () => {
+ try {
+ await window.electronAPI.providerShare.command({ action: 'reshare-decide', id: reshare.id, decision });
+ toast.success(
+ decision === 'approve'
+ ? t('providerShare.manage.reshare.toastApproved', { name: reshare.name, owner, provider: providerName })
+ : reshare.state === 'approved'
+ ? t('providerShare.manage.reshare.toastRevoked', { name: reshare.name })
+ : t('providerShare.manage.reshare.toastRejected', { name: reshare.name }),
+ );
+ } catch (error) {
+ toast.error(t(mapIpcErrorToI18nKey(error)));
+ }
+ void load();
+ }),
+ [load, providerName, t, withBusy],
+ );
+
const removeMember = useCallback(
async (member: ProviderShareMemberView) => {
const ok = await confirm({
@@ -263,7 +290,7 @@ export function ProviderShareManagePage({
</p>
)}
- {requests.length > 0 && (
+ {(requests.length > 0 || reshares.length > 0) && (
<section className="mt-6 shrink-0" aria-labelledby="provider-share-pending-title">
<h3 id="provider-share-pending-title" className="mb-2 text-13 font-medium text-[var(--settings-section-title)]">
{t('providerShare.manage.pending.title')}
@@ -319,6 +346,51 @@ export function ProviderShareManagePage({
</div>
</div>
))}
+ {reshares.map((item, index) => (
+ <div
+ key={item.reshare.id}
+ data-testid="provider-share-reshare-row"
+ className={cn(
+ 'flex flex-wrap items-center gap-3 px-4 py-3',
+ (requests.length > 0 || index > 0) && 'border-t border-[var(--settings-theme-card-border)]',
+ )}
+ >
+ <ShareAvatar displayName={item.reshare.name} avatarUrl={item.reshare.avatarUrl} />
+ <div className="flex min-w-[200px] flex-1 flex-col gap-0.5">
+ <div className="flex flex-wrap items-baseline gap-2 text-13">
+ <span className="font-medium text-[var(--text-primary)]">{item.reshare.name}</span>
+ <span className="text-12 text-[var(--text-secondary)]">
+ {t('providerShare.manage.reshare.applying', { owner: item.owner.displayName })}
+ </span>
+ </div>
+ <div className="flex flex-wrap gap-1.5 text-12 text-[var(--text-secondary)]">
+ <span>{t('providerShare.manage.reshare.requestedAt', { time: time.relative(item.reshare.requestedAt) })}</span>
+ <span aria-hidden="true">·</span>
+ <span>{t('providerShare.manage.reshare.usageHint', { name: item.reshare.name, owner: item.owner.displayName })}</span>
+ </div>
+ </div>
+ <div className="flex shrink-0 items-center gap-1.5">
+ <Button
+ variant="secondary"
+ size="sm"
+ compact
+ disabled={busy.has(item.reshare.id)}
+ onClick={() => void decideReshare(item.reshare, item.owner.displayName, 'reject')}
+ >
+ {t('providerShare.manage.reshare.reject')}
+ </Button>
+ <Button
+ variant="primary"
+ size="sm"
+ compact
+ disabled={busy.has(item.reshare.id)}
+ onClick={() => void decideReshare(item.reshare, item.owner.displayName, 'approve')}
+ >
+ {t('providerShare.manage.reshare.approve')}
+ </Button>
+ </div>
+ </div>
+ ))}
</div>
</section>
)}
@@ -350,6 +422,8 @@ export function ProviderShareManagePage({
time={time}
onPause={() => void setMember(member, member.status === 'paused' ? 'resume' : 'pause')}
onRemove={() => void removeMember(member)}
+ reshareBusy={(id) => busy.has(id)}
+ onReshare={(reshare, decision) => void decideReshare(reshare, member.displayName, decision)}
/>
))
)}
@@ -374,6 +448,8 @@ function MemberRow({
time,
onPause,
onRemove,
+ reshareBusy,
+ onReshare,
}: {
member: ProviderShareMemberView;
first: boolean;
@@ -381,9 +457,13 @@ function MemberRow({
time: ReturnType<typeof useShareTimeFormat>;
onPause: () => void;
onRemove: () => void;
+ reshareBusy: (id: string) => boolean;
+ onReshare: (reshare: ProviderShareReshareView, decision: 'approve' | 'reject') => void;
}) {
const { t } = useTranslation();
const paused = member.status === 'paused';
+ // 转分享里已处理过的人(待处理的在上方「待处理」一栏):可以撤回已同意的,或改为同意。
+ const decided = (member.reshares ?? []).filter((reshare) => reshare.state !== 'pending');
const statusText = paused
? t('providerShare.manage.members.statusPaused')
: member.runningTasks > 0
@@ -391,55 +471,99 @@ function MemberRow({
: t('providerShare.manage.members.statusActive');
// 用量在上方「用量」块里按人列出(供应商组 §10),这里只管分享本身。
return (
- <div
- data-testid="provider-share-member-row"
- className={cn('flex flex-wrap items-center gap-3 px-4 py-3', !first && 'border-t border-[var(--settings-theme-card-border)]')}
- >
- <ShareAvatar
- displayName={member.displayName}
- avatarUrl={member.avatarUrl}
- className={cn(paused && 'opacity-70')}
- />
- <div className={cn('flex min-w-[180px] flex-1 flex-col gap-0.5', paused && 'opacity-70')}>
- <div className="flex flex-wrap items-center gap-2 text-13">
- <span className="font-medium text-[var(--text-primary)]">{member.displayName}</span>
- <span className="inline-flex items-center gap-1.5 text-12 text-[var(--text-secondary)]">
- <span
- aria-hidden="true"
- className={cn(
- 'h-1.5 w-1.5 shrink-0 rounded-full',
- paused ? 'bg-[var(--remote-status-disconnected)]' : 'bg-[var(--remote-status-ready)]',
- )}
- />
- {statusText}
- </span>
+ <div className={cn(!first && 'border-t border-[var(--settings-theme-card-border)]')}>
+ <div data-testid="provider-share-member-row" className="flex flex-wrap items-center gap-3 px-4 py-3">
+ <ShareAvatar
+ displayName={member.displayName}
+ avatarUrl={member.avatarUrl}
+ className={cn(paused && 'opacity-70')}
+ />
+ <div className={cn('flex min-w-[180px] flex-1 flex-col gap-0.5', paused && 'opacity-70')}>
+ <div className="flex flex-wrap items-center gap-2 text-13">
+ <span className="font-medium text-[var(--text-primary)]">{member.displayName}</span>
+ <span className="inline-flex items-center gap-1.5 text-12 text-[var(--text-secondary)]">
+ <span
+ aria-hidden="true"
+ className={cn(
+ 'h-1.5 w-1.5 shrink-0 rounded-full',
+ paused ? 'bg-[var(--remote-status-disconnected)]' : 'bg-[var(--remote-status-ready)]',
+ )}
+ />
+ {statusText}
+ </span>
+ </div>
+ <div className="flex flex-wrap gap-1.5 text-12 text-[var(--text-secondary)]">
+ <span>{t('providerShare.manage.members.joined', { date: time.date(Date.parse(member.joinedAt)) })}</span>
+ <span aria-hidden="true">·</span>
+ <span>
+ {member.lastUsedAt
+ ? t('providerShare.manage.members.lastUsed', { time: time.relative(member.lastUsedAt) })
+ : t('providerShare.manage.members.neverUsed')}
+ </span>
+ </div>
</div>
- <div className="flex flex-wrap gap-1.5 text-12 text-[var(--text-secondary)]">
- <span>{t('providerShare.manage.members.joined', { date: time.date(Date.parse(member.joinedAt)) })}</span>
- <span aria-hidden="true">·</span>
- <span>
- {member.lastUsedAt
- ? t('providerShare.manage.members.lastUsed', { time: time.relative(member.lastUsedAt) })
- : t('providerShare.manage.members.neverUsed')}
- </span>
+ <div className="flex shrink-0 items-center gap-1.5">
+ <Button variant="secondary" size="sm" compact disabled={busy} onClick={onPause}>
+ {t(paused ? 'providerShare.manage.members.resume' : 'providerShare.manage.members.pause')}
+ </Button>
+ <Button
+ variant="secondary"
+ tone="danger"
+ size="sm"
+ compact
+ disabled={busy}
+ aria-label={t('providerShare.manage.members.removeAria', { name: member.displayName })}
+ onClick={onRemove}
+ >
+ {t('providerShare.manage.members.remove')}
+ </Button>
</div>
</div>
- <div className="flex shrink-0 items-center gap-1.5">
- <Button variant="secondary" size="sm" compact disabled={busy} onClick={onPause}>
- {t(paused ? 'providerShare.manage.members.resume' : 'providerShare.manage.members.pause')}
- </Button>
- <Button
- variant="secondary"
- tone="danger"
- size="sm"
- compact
- disabled={busy}
- aria-label={t('providerShare.manage.members.removeAria', { name: member.displayName })}
- onClick={onRemove}
- >
- {t('providerShare.manage.members.remove')}
- </Button>
- </div>
+ {decided.length > 0 && (
+ // 经这个成员的供应商组转给别人用的人(provider-sharing.md §4.3):缩进到昵称一列,与这一行同属一人。
+ <div className="-mt-1 flex flex-col gap-1.5 px-4 pb-3" data-testid="provider-share-reshare-list">
+ <span className="ml-11 text-12 text-[var(--text-tertiary)]">
+ {t('providerShare.manage.reshare.listTitle', { owner: member.displayName })}
+ </span>
+ {decided.map((reshare) => {
+ const approved = reshare.state === 'approved';
+ return (
+ <div
+ key={reshare.id}
+ data-testid="provider-share-reshare-item"
+ className="ml-11 flex flex-wrap items-center gap-2"
+ >
+ <ShareAvatar
+ displayName={reshare.name}
+ avatarUrl={reshare.avatarUrl}
+ size="sm"
+ className={cn(!approved && 'opacity-70')}
+ />
+ <span className={cn('min-w-0 flex-1 truncate text-13 text-[var(--text-primary)]', !approved && 'opacity-70')}>
+ {reshare.name}
+ <span className="ml-2 text-12 text-[var(--text-secondary)]">
+ {t(approved ? 'providerShare.manage.reshare.stateApproved' : 'providerShare.manage.reshare.stateRejected')}
+ </span>
+ </span>
+ <Button
+ variant="secondary"
+ size="sm"
+ compact
+ tone={approved ? 'danger' : undefined}
+ disabled={reshareBusy(reshare.id)}
+ aria-label={t(
+ approved ? 'providerShare.manage.reshare.revokeAria' : 'providerShare.manage.reshare.approveAria',
+ { name: reshare.name },
+ )}
+ onClick={() => onReshare(reshare, approved ? 'reject' : 'approve')}
+ >
+ {t(approved ? 'providerShare.manage.reshare.revoke' : 'providerShare.manage.reshare.approve')}
+ </Button>
+ </div>
+ );
+ })}
+ </div>
+ )}
</div>
);
}
diff --git a/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareManagePage.test.tsx b/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareManagePage.test.tsx
index 891d91e625..fcd15bb3b5 100644
--- a/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareManagePage.test.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareManagePage.test.tsx
@@ -6,7 +6,11 @@ import type { ProviderGroupConfig } from '../../../../shared/providerGroup';
import type { ProviderOwnUsageView, ProviderShareOwnerState } from '../../../../shared/providerShare';
import { __testing as localGroupsTesting } from '../../provider-group/useLocalProviderGroups';
import { ProviderShareManagePage } from '../ProviderShareManagePage';
-import { getProviderSharePendingRequests, resetProviderShareStoreForTests } from '../providerShareStore';
+import {
+ getProviderSharePendingRequests,
+ getProviderSharePendingReshares,
+ resetProviderShareStoreForTests,
+} from '../providerShareStore';
vi.mock('react-i18next', () => ({
initReactI18next: { type: '3rdParty', init: () => undefined },
@@ -291,6 +295,43 @@ describe('ProviderShareManagePage', () => {
expect(confirmSpy).toHaveBeenCalledWith(expect.objectContaining({ confirmVariant: 'destructive' }));
});
+ // 转分享(provider-sharing.md §4.3):成员想经自己的供应商组把这里的供应商转给别人用,主人逐人处理。
+ it('lists reshare requests under pending, and lets the owner withdraw or grant decided ones', async () => {
+ command.mockImplementation(async (cmd: { action: string }) => {
+ if (cmd.action === 'owned') {
+ const state = owned();
+ state.shares[0]!.members[0]!.reshares = [
+ { id: 'rs-pending', name: 'Carol', avatarUrl: null, state: 'pending', requestedAt: Date.now() - 1_000, decidedAt: null },
+ { id: 'rs-approved', name: 'Dave', avatarUrl: null, state: 'approved', requestedAt: Date.now() - 9_000, decidedAt: Date.now() - 5_000 },
+ { id: 'rs-rejected', name: 'Erin', avatarUrl: null, state: 'rejected', requestedAt: Date.now() - 9_000, decidedAt: Date.now() - 5_000 },
+ ];
+ return state;
+ }
+ if (cmd.action === 'own-usage') return ownUsage();
+ if (cmd.action === 'received') return [];
+ if (cmd.action === 'reshare-decide') return { ok: true };
+ throw new Error(`unexpected ${cmd.action}`);
+ });
+ renderPage();
+ const pending = await screen.findByTestId('provider-share-reshare-row');
+ expect(pending.textContent).toContain('Carol');
+ expect(pending.textContent).toContain('providerShare.manage.reshare.applying:{"owner":"Lizi"}');
+ expect(getProviderSharePendingReshares().map((item) => item.reshare.id)).toEqual(['rs-pending']);
+ fireEvent.click(within(pending).getByRole('button', { name: 'providerShare.manage.reshare.approve' }));
+ await waitFor(() => expect(command).toHaveBeenCalledWith({ action: 'reshare-decide', id: 'rs-pending', decision: 'approve' }));
+
+ // 处理过的人列在这个成员下方:已同意的可撤回,拒绝的可改为同意。
+ const decided = screen.getAllByTestId('provider-share-reshare-item');
+ expect(decided.map((item) => item.textContent)).toEqual([
+ expect.stringContaining('Dave'),
+ expect.stringContaining('Erin'),
+ ]);
+ fireEvent.click(within(decided[0]!).getByRole('button', { name: /providerShare\.manage\.reshare\.revokeAria/ }));
+ await waitFor(() => expect(command).toHaveBeenCalledWith({ action: 'reshare-decide', id: 'rs-approved', decision: 'reject' }));
+ fireEvent.click(within(decided[1]!).getByRole('button', { name: /providerShare\.manage\.reshare\.approveAria/ }));
+ await waitFor(() => expect(command).toHaveBeenCalledWith({ action: 'reshare-decide', id: 'rs-rejected', decision: 'approve' }));
+ });
+
it('disables link creation and explains why when sharing is gated', async () => {
renderPage('invocation-off');
await screen.findAllByTestId('provider-share-member-row');
diff --git a/apps/desktop/src/renderer/features/provider-share/providerShareFormat.ts b/apps/desktop/src/renderer/features/provider-share/providerShareFormat.ts
index 3a9b55b461..419f0e6c1b 100644
--- a/apps/desktop/src/renderer/features/provider-share/providerShareFormat.ts
+++ b/apps/desktop/src/renderer/features/provider-share/providerShareFormat.ts
@@ -12,6 +12,7 @@ import {
type ProviderShareModelUsageView,
type ProviderShareMoney,
type ProviderShareOwnedView,
+ type ProviderShareReshareView,
} from '../../../shared/providerShare';
/** 分享入口的能力门:允许远程控制 → 允许被远程调用 → 分享(产品规则 §3)。 */
@@ -139,6 +140,34 @@ export function pendingRequestsFromOwned(
return items.sort((a, b) => Date.parse(a.request.createdAt) - Date.parse(b.request.createdAt));
}
+/** 待处理的转分享请求(provider-sharing.md §4.3):成员想把分享来的供应商经自己的供应商组转给这个人用。 */
+export interface ProviderSharePendingReshare {
+ reshare: ProviderShareReshareView;
+ /** 经谁的供应商组(已分享的那个成员)。 */
+ owner: { memberId: string; displayName: string; avatarUrl: string | null };
+ share: { shareId: string; providerId: string; providerLabel: string };
+}
+
+/** owned 快照 → 待处理的转分享请求(按请求时间先后)。 */
+export function pendingResharesFromOwned(
+ shares: readonly ProviderShareOwnedView[],
+): ProviderSharePendingReshare[] {
+ const items: ProviderSharePendingReshare[] = [];
+ for (const share of shares) {
+ for (const member of share.members) {
+ for (const reshare of member.reshares ?? []) {
+ if (reshare.state !== 'pending') continue;
+ items.push({
+ reshare,
+ owner: { memberId: member.memberId, displayName: member.displayName, avatarUrl: member.avatarUrl },
+ share: { shareId: share.shareId, providerId: share.providerId, providerLabel: share.providerLabel },
+ });
+ }
+ }
+ }
+ return items.sort((a, b) => a.reshare.requestedAt - b.reshare.requestedAt);
+}
+
/** 受邀者打开链接时,错误码对应的弹窗状态。 */
export type ProviderShareJoinErrorKind = 'used' | 'self' | 'member' | 'region' | 'invalid' | 'error';
diff --git a/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts b/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts
index 6863d2dd84..f31dc2c08b 100644
--- a/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts
+++ b/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts
@@ -6,6 +6,7 @@
* 分享的状态、在线或所在电脑变化时刷新对应 `share:<id>` 的模型目录缓存,消失的分享作废缓存。
* - 待审批申请(分享者):由全局审批宿主播种(`owned` 一次)、REQUESTED 推送追加、审批后移除;
* 管理页每次读取 `owned` 也会发布到这里。设置页入口的提示点读这份。
+ * - 待处理的转分享请求(分享者):同一份 `owned` 快照里成员带的 reshares;RESHARE_REQUESTED 推送时重读。
*
* 注意:`owned` 会让 main 进入快速拉取(每 5 秒),所以这里**不**在每次 OWNED_CHANGED 都重读,
* 只在还有待审批申请时重读(那时 main 本来就在快速拉取),以便撤回、过期的申请及时消失。
@@ -27,8 +28,10 @@ import type {
import {
diffReceivedShares,
pendingRequestsFromOwned,
+ pendingResharesFromOwned,
providerShareAgentDeviceId,
type ProviderSharePendingRequest,
+ type ProviderSharePendingReshare,
} from './providerShareFormat';
const log = createLogger('providerShareStore');
@@ -216,11 +219,38 @@ function setPending(next: readonly ProviderSharePendingRequest[]): void {
for (const listener of pendingSubscribers) listener();
}
-/** 一份 owned 快照是本机待审批申请的权威来源:整体替换。 */
+// 待处理的转分享请求(分享者,provider-sharing.md §4.3):与待审批申请同出一份 owned 快照。
+let pendingReshares: readonly ProviderSharePendingReshare[] = [];
+const reshareSubscribers = new Set<() => void>();
+
+function setPendingReshares(next: readonly ProviderSharePendingReshare[]): void {
+ if (next.length === 0 && pendingReshares.length === 0) return;
+ pendingReshares = next;
+ for (const listener of reshareSubscribers) listener();
+}
+
+/** 一份 owned 快照是本机待审批申请(含转分享请求)的权威来源:整体替换。 */
export function publishProviderShareOwnerState(state: ProviderShareOwnerState): void {
+ setPendingReshares(state.ready ? pendingResharesFromOwned(state.shares) : []);
setPending(state.ready ? pendingRequestsFromOwned(state.shares) : []);
}
+export function getProviderSharePendingReshares(): readonly ProviderSharePendingReshare[] {
+ return pendingReshares;
+}
+
+function subscribeReshares(listener: () => void): () => void {
+ reshareSubscribers.add(listener);
+ return () => {
+ reshareSubscribers.delete(listener);
+ };
+}
+
+/** 设置页入口的提示点与管理页「待处理」一栏读这份。 */
+export function useProviderSharePendingReshares(): readonly ProviderSharePendingReshare[] {
+ return useSyncExternalStore(subscribeReshares, getProviderSharePendingReshares, getProviderSharePendingReshares);
+}
+
export function addProviderShareRequested(event: ProviderShareRequestedEvent): void {
if (pendingRequests.some((item) => item.request.requestId === event.request.requestId)) return;
setPending([...pendingRequests, { request: event.request, share: event.share }]);
@@ -275,4 +305,6 @@ export function resetProviderShareStoreForTests(): void {
receivedSubscribers.clear();
pendingRequests = [];
pendingSubscribers.clear();
+ pendingReshares = [];
+ reshareSubscribers.clear();
}
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index cf013c7eec..353be6f01b 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -262,6 +262,22 @@
"title": "Remove Sharing with {{name}}?",
"description": "{{name}} will immediately lose access to {{provider}}, and any running sessions will stop. To share again, you’ll need a new link. Usage records are kept.",
"confirm": "Remove Share"
+ },
+ "reshare": {
+ "applying": "wants to use it through {{owner}}’s provider group",
+ "requestedAt": "Requested {{time}}",
+ "usageHint": "If you agree, {{name}}’s sessions can run on this computer, and usage counts under {{owner}}",
+ "approve": "Agree",
+ "reject": "Decline",
+ "listTitle": "Using it through {{owner}}’s provider group",
+ "stateApproved": "Agreed",
+ "stateRejected": "Declined",
+ "revoke": "Withdraw",
+ "revokeAria": "Withdraw agreement for {{name}}",
+ "approveAria": "Agree to {{name}} using it",
+ "toastApproved": "{{name}} can now use {{provider}} through {{owner}}’s provider group",
+ "toastRejected": "Declined {{name}}’s request",
+ "toastRevoked": "Withdrew agreement for {{name}}. Running sessions were stopped."
}
},
"toast": {
@@ -310,7 +326,7 @@
"factFiles": "Your project files and commands still run on your own computer",
"factFilesDetail": "Your session permissions still apply",
"factPrivacy": "Chat content and files the Agent reads pass through {{name}}’s computer and are saved on the computer that runs the session",
- "factPrivacyDetail": "{{name}} only sees your nickname and avatar",
+ "factPrivacyDetail": "{{name}}, and owners of other computers who need to agree, only see your nickname and avatar",
"factApproval": "After you send the request, it takes effect only once {{name}} approves",
"factApprovalDetail": "{{name}} can pause or remove this share at any time",
"send": "Send Request",
@@ -430,7 +446,9 @@
"approvedTitle": "Share Request Approved",
"approvedBody": "{{name}} shared {{provider}} with you",
"rejectedTitle": "Share Request Declined",
- "rejectedBody": "{{name}} declined to share {{provider}}"
+ "rejectedBody": "{{name}} declined to share {{provider}}",
+ "reshareTitle": "New Usage Request",
+ "reshareBody": "{{name}} wants to use your shared {{provider}} through {{owner}}’s provider group"
}
},
"providerGroup": {
@@ -545,7 +563,24 @@
"lastDescription": "It’s the last computer in the group, so removing it deletes the {{provider}} provider group.",
"confirm": "Remove from Group"
},
- "sourceGroupOwner": "Hosts the group"
+ "sourceGroupOwner": "Hosts the group",
+ "reshare": {
+ "allApproved": "Available to people you share with",
+ "waiting_one": "{{count}} person you share with is waiting for {{owner}} to agree",
+ "waiting_other": "{{count}} people you share with are waiting for {{owner}} to agree",
+ "rejected_one": "{{owner}} declined {{count}} person you share with",
+ "rejected_other": "{{owner}} declined {{count}} people you share with",
+ "needsUpdate": "{{owner}} needs to update Cindy before agreeing to people you share with",
+ "unknown": "Not yet known whether {{owner}} agrees to people you share with",
+ "title": "Can people you share with use this computer",
+ "description": "{{owner}} agrees person by person. Tasks from people without agreement aren’t assigned to this computer.",
+ "state": {
+ "approved": "Agreed",
+ "pending": "Waiting",
+ "rejected": "Declined",
+ "unknown": "Not checked yet"
+ }
+ }
},
"deleteConfirm": {
"title": "Delete the {{provider}} provider group?",
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 1fdf1121f0..65e05bbec0 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -260,6 +260,22 @@
"title": "{{name}} との共有を削除しますか?",
"description": "{{name}} はすぐに {{provider}} を使えなくなり、実行中のセッションは停止します。再び共有するには新しいリンクが必要です。使用量の記録は残ります。",
"confirm": "共有を削除"
+ },
+ "reshare": {
+ "applying": "{{owner}} のプロバイダーグループ経由での利用を希望しています",
+ "requestedAt": "{{time}}にリクエスト",
+ "usageHint": "同意すると、{{name}} のセッションをこのパソコンで実行でき、使用量は {{owner}} の分として記録されます",
+ "approve": "同意",
+ "reject": "拒否",
+ "listTitle": "{{owner}} のプロバイダーグループ経由で利用",
+ "stateApproved": "同意済み",
+ "stateRejected": "未同意",
+ "revoke": "同意を取り消す",
+ "revokeAria": "{{name}} への同意を取り消す",
+ "approveAria": "{{name}} の利用に同意する",
+ "toastApproved": "{{name}} が {{owner}} のプロバイダーグループ経由で {{provider}} を使えるようにしました",
+ "toastRejected": "{{name}} のリクエストを拒否しました",
+ "toastRevoked": "{{name}} への同意を取り消しました。実行中のセッションは停止しました"
}
},
"toast": {
@@ -308,7 +324,7 @@
"factFiles": "プロジェクトのファイルとコマンドは引き続きあなたのパソコンで実行されます",
"factFilesDetail": "あなたのセッションの権限が適用されます",
"factPrivacy": "チャットの内容と Agent が読み取ったファイルの内容は {{name}} のパソコンを経由し、実際にセッションを実行するパソコンに保存されます",
- "factPrivacyDetail": "{{name}} に表示されるのはあなたのニックネームとアバターだけです",
+ "factPrivacyDetail": "{{name}} と、同意が必要なほかのパソコンの持ち主に表示されるのは、あなたのニックネームとアバターだけです",
"factApproval": "申請を送った後、{{name}} が承認すると有効になります",
"factApprovalDetail": "{{name}} はこの共有をいつでも停止または削除できます",
"send": "申請を送信",
@@ -428,7 +444,9 @@
"approvedTitle": "共有の申請が承認されました",
"approvedBody": "{{name}} が {{provider}} の共有を承認しました",
"rejectedTitle": "共有の申請は承認されませんでした",
- "rejectedBody": "{{name}} は {{provider}} の共有を承認しませんでした"
+ "rejectedBody": "{{name}} は {{provider}} の共有を承認しませんでした",
+ "reshareTitle": "新しい利用リクエスト",
+ "reshareBody": "{{name}} が {{owner}} のプロバイダーグループ経由で、あなたの共有した {{provider}} を使いたいと希望しています"
}
},
"providerGroup": {
@@ -540,7 +558,22 @@
"lastDescription": "グループ内の最後のパソコンです。外すと {{provider}} のプロバイダーグループは削除されます。",
"confirm": "グループから外す"
},
- "sourceGroupOwner": "グループを作成したパソコン"
+ "sourceGroupOwner": "グループを作成したパソコン",
+ "reshare": {
+ "allApproved": "共有相手も利用できます",
+ "waiting_other": "共有相手 {{count}} 人が {{owner}} の同意を待っています",
+ "rejected_other": "{{owner}} は共有相手 {{count}} 人に同意しませんでした",
+ "needsUpdate": "{{owner}} が Cindy を更新すると、共有相手への同意ができるようになります",
+ "unknown": "{{owner}} が共有相手に同意しているかはまだわかりません",
+ "title": "共有相手がこのパソコンを使えるか",
+ "description": "{{owner}} が 1 人ずつ同意します。同意されていない人のセッションはこのパソコンに割り当てられません。",
+ "state": {
+ "approved": "同意済み",
+ "pending": "同意待ち",
+ "rejected": "未同意",
+ "unknown": "未確認"
+ }
+ }
},
"deleteConfirm": {
"title": "{{provider}} のプロバイダーグループを削除しますか?",
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 200640e044..77b7228506 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -260,6 +260,22 @@
"title": "{{name}}님과의 공유를 삭제할까요?",
"description": "{{name}}님은 즉시 {{provider}}을(를) 사용할 수 없게 되고 실행 중인 세션은 중지됩니다. 다시 공유하려면 새 링크가 필요합니다. 사용량 기록은 유지됩니다.",
"confirm": "공유 삭제"
+ },
+ "reshare": {
+ "applying": "{{owner}}님의 제공자 그룹을 통해 사용하려고 합니다",
+ "requestedAt": "{{time}}에 요청",
+ "usageHint": "동의하면 {{name}}님의 세션이 이 컴퓨터에서 실행될 수 있고, 사용량은 {{owner}}님 몫으로 기록됩니다",
+ "approve": "동의",
+ "reject": "거절",
+ "listTitle": "{{owner}}님의 제공자 그룹을 통해 사용",
+ "stateApproved": "동의함",
+ "stateRejected": "동의하지 않음",
+ "revoke": "동의 철회",
+ "revokeAria": "{{name}}님에 대한 동의 철회",
+ "approveAria": "{{name}}님의 사용에 동의",
+ "toastApproved": "{{name}}님이 {{owner}}님의 제공자 그룹을 통해 {{provider}}을(를) 사용할 수 있게 되었습니다",
+ "toastRejected": "{{name}}님의 요청을 거절했습니다",
+ "toastRevoked": "{{name}}님에 대한 동의를 철회했습니다. 실행 중인 세션은 중지되었습니다"
}
},
"toast": {
@@ -308,7 +324,7 @@
"factFiles": "프로젝트 파일과 명령은 계속 내 컴퓨터에서 실행됩니다",
"factFilesDetail": "내 세션 권한이 그대로 적용됩니다",
"factPrivacy": "채팅 내용과 Agent가 읽은 파일 내용은 {{name}}님의 컴퓨터를 거쳐, 실제로 세션을 실행하는 컴퓨터에 저장됩니다",
- "factPrivacyDetail": "{{name}}님에게는 내 닉네임과 프로필 사진만 표시됩니다",
+ "factPrivacyDetail": "{{name}}님과 동의가 필요한 다른 컴퓨터 주인에게는 내 닉네임과 프로필 사진만 표시됩니다",
"factApproval": "요청을 보낸 뒤 {{name}}님이 승인해야 적용됩니다",
"factApprovalDetail": "{{name}}님은 언제든지 이 공유를 일시 중지하거나 삭제할 수 있습니다",
"send": "요청 보내기",
@@ -428,7 +444,9 @@
"approvedTitle": "공유 요청 승인됨",
"approvedBody": "{{name}}님이 {{provider}} 공유를 승인했습니다",
"rejectedTitle": "공유 요청 거절됨",
- "rejectedBody": "{{name}}님이 {{provider}} 공유를 거절했습니다"
+ "rejectedBody": "{{name}}님이 {{provider}} 공유를 거절했습니다",
+ "reshareTitle": "새 사용 요청",
+ "reshareBody": "{{name}}님이 {{owner}}님의 제공자 그룹을 통해 내가 공유한 {{provider}}을(를) 사용하려고 합니다"
}
},
"providerGroup": {
@@ -540,7 +558,22 @@
"lastDescription": "그룹의 마지막 컴퓨터입니다. 제외하면 {{provider}} 제공자 그룹이 삭제됩니다.",
"confirm": "그룹에서 제외"
},
- "sourceGroupOwner": "그룹을 만든 컴퓨터"
+ "sourceGroupOwner": "그룹을 만든 컴퓨터",
+ "reshare": {
+ "allApproved": "공유받은 사람도 사용할 수 있음",
+ "waiting_other": "공유받은 사람 {{count}}명이 {{owner}}님의 동의를 기다리는 중",
+ "rejected_other": "{{owner}}님이 공유받은 사람 {{count}}명에게 동의하지 않음",
+ "needsUpdate": "{{owner}}님이 Cindy를 업데이트해야 공유받은 사람에게 동의할 수 있습니다",
+ "unknown": "{{owner}}님이 공유받은 사람에게 동의했는지 아직 알 수 없습니다",
+ "title": "공유받은 사람이 이 컴퓨터를 쓸 수 있는지",
+ "description": "{{owner}}님이 한 명씩 동의합니다. 동의받지 않은 사람의 세션은 이 컴퓨터에 배정되지 않습니다.",
+ "state": {
+ "approved": "동의함",
+ "pending": "동의 대기 중",
+ "rejected": "동의하지 않음",
+ "unknown": "아직 확인 안 됨"
+ }
+ }
},
"deleteConfirm": {
"title": "{{provider}} 제공자 그룹을 삭제할까요?",
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
index 62f35a2e73..cb32959070 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -260,6 +260,22 @@
"title": "删除对 {{name}} 的分享?",
"description": "{{name}} 将立即无法使用 {{provider}},正在运行的任务会停止。之后要再分享,需要重新生成链接。用量记录会保留。",
"confirm": "删除分享"
+ },
+ "reshare": {
+ "applying": "想经 {{owner}} 的供应商组使用",
+ "requestedAt": "{{time}}请求",
+ "usageHint": "同意后,{{name}} 的任务可以在这台电脑上运行,用量算在 {{owner}} 名下",
+ "approve": "同意",
+ "reject": "拒绝",
+ "listTitle": "经 {{owner}} 的供应商组使用",
+ "stateApproved": "已同意",
+ "stateRejected": "未同意",
+ "revoke": "撤回同意",
+ "revokeAria": "撤回对 {{name}} 的同意",
+ "approveAria": "同意 {{name}} 使用",
+ "toastApproved": "已同意 {{name}} 经 {{owner}} 的供应商组使用 {{provider}}",
+ "toastRejected": "已拒绝 {{name}} 的请求",
+ "toastRevoked": "已撤回对 {{name}} 的同意,正在运行的任务已停止"
}
},
"toast": {
@@ -308,7 +324,7 @@
"factFiles": "你的项目文件和命令仍在你自己的电脑上执行",
"factFilesDetail": "由你的任务权限把关",
"factPrivacy": "对话内容和 Agent 读取的文件内容会经过 {{name}} 的电脑,并保存在实际运行任务的那台电脑上",
- "factPrivacyDetail": "{{name}} 只会看到你的昵称和头像",
+ "factPrivacyDetail": "{{name}} 和需要同意你使用的其他电脑主人只会看到你的昵称和头像",
"factApproval": "发送申请后,需要 {{name}} 同意才会生效",
"factApprovalDetail": "{{name}} 可以随时关闭或删除这个分享",
"send": "发送申请",
@@ -428,7 +444,9 @@
"approvedTitle": "分享申请已通过",
"approvedBody": "{{name}} 已同意分享 {{provider}}",
"rejectedTitle": "分享申请未通过",
- "rejectedBody": "{{name}} 没有同意分享 {{provider}}"
+ "rejectedBody": "{{name}} 没有同意分享 {{provider}}",
+ "reshareTitle": "新的使用请求",
+ "reshareBody": "{{name}} 想经 {{owner}} 的供应商组使用你分享的 {{provider}}"
}
},
"providerGroup": {
@@ -540,7 +558,22 @@
"lastDescription": "它是组里最后一台电脑,移出后会删除 {{provider}} 的供应商组。",
"confirm": "移出组"
},
- "sourceGroupOwner": "组所在电脑"
+ "sourceGroupOwner": "组所在电脑",
+ "reshare": {
+ "allApproved": "分享的人可以用",
+ "waiting_other": "{{count}} 位分享的人等待 {{owner}} 同意",
+ "rejected_other": "{{owner}} 未同意 {{count}} 位分享的人",
+ "needsUpdate": "{{owner}} 的 Cindy 更新后才能同意给分享的人用",
+ "unknown": "还不知道 {{owner}} 是否同意给分享的人用",
+ "title": "分享的人能否用这台电脑",
+ "description": "需要 {{owner}} 逐人同意。没同意的人,任务不会分到这台电脑。",
+ "state": {
+ "approved": "已同意",
+ "pending": "等待同意",
+ "rejected": "未同意",
+ "unknown": "还没问到"
+ }
+ }
},
"deleteConfirm": {
"title": "删除 {{provider}} 的供应商组?",
diff --git a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
index 065c56fbc9..ce058afea6 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -260,6 +260,22 @@
"title": "刪除對 {{name}} 的分享?",
"description": "{{name}} 將立即無法使用 {{provider}},正在執行的任務會停止。之後要再分享,需要重新產生連結。用量紀錄會保留。",
"confirm": "刪除分享"
+ },
+ "reshare": {
+ "applying": "想經 {{owner}} 的供應商組使用",
+ "requestedAt": "{{time}}請求",
+ "usageHint": "同意後,{{name}} 的任務可以在這臺電腦上執行,用量算在 {{owner}} 名下",
+ "approve": "同意",
+ "reject": "拒絕",
+ "listTitle": "經 {{owner}} 的供應商組使用",
+ "stateApproved": "已同意",
+ "stateRejected": "未同意",
+ "revoke": "撤回同意",
+ "revokeAria": "撤回對 {{name}} 的同意",
+ "approveAria": "同意 {{name}} 使用",
+ "toastApproved": "已同意 {{name}} 經 {{owner}} 的供應商組使用 {{provider}}",
+ "toastRejected": "已拒絕 {{name}} 的請求",
+ "toastRevoked": "已撤回對 {{name}} 的同意,正在執行的任務已停止"
}
},
"toast": {
@@ -308,7 +324,7 @@
"factFiles": "你的專案檔案和指令仍在你自己的電腦上執行",
"factFilesDetail": "由你的任務權限把關",
"factPrivacy": "對話內容和 Agent 讀取的檔案內容會經過 {{name}} 的電腦,並儲存在實際執行任務的那台電腦上",
- "factPrivacyDetail": "{{name}} 只會看到你的暱稱和頭像",
+ "factPrivacyDetail": "{{name}} 和需要同意你使用的其他電腦主人只會看到你的暱稱和頭像",
"factApproval": "傳送申請後,需要 {{name}} 同意才會生效",
"factApprovalDetail": "{{name}} 可以隨時關閉或刪除這個分享",
"send": "傳送申請",
@@ -428,7 +444,9 @@
"approvedTitle": "分享申請已通過",
"approvedBody": "{{name}} 已同意分享 {{provider}}",
"rejectedTitle": "分享申請未通過",
- "rejectedBody": "{{name}} 沒有同意分享 {{provider}}"
+ "rejectedBody": "{{name}} 沒有同意分享 {{provider}}",
+ "reshareTitle": "新的使用請求",
+ "reshareBody": "{{name}} 想經 {{owner}} 的供應商組使用你分享的 {{provider}}"
}
},
"providerGroup": {
@@ -540,7 +558,22 @@
"lastDescription": "它是組裡最後一臺電腦,移出後會刪除 {{provider}} 的供應商組。",
"confirm": "移出組"
},
- "sourceGroupOwner": "組所在電腦"
+ "sourceGroupOwner": "組所在電腦",
+ "reshare": {
+ "allApproved": "分享的人可以用",
+ "waiting_other": "{{count}} 位分享的人等待 {{owner}} 同意",
+ "rejected_other": "{{owner}} 未同意 {{count}} 位分享的人",
+ "needsUpdate": "{{owner}} 的 Cindy 更新後才能同意給分享的人用",
+ "unknown": "還不知道 {{owner}} 是否同意給分享的人用",
+ "title": "分享的人能否用這臺電腦",
+ "description": "需要 {{owner}} 逐人同意。沒同意的人,任務不會分到這臺電腦。",
+ "state": {
+ "approved": "已同意",
+ "pending": "等待同意",
+ "rejected": "未同意",
+ "unknown": "還沒問到"
+ }
+ }
},
"deleteConfirm": {
"title": "刪除 {{provider}} 的供應商組?",
diff --git a/apps/desktop/src/renderer/vite-env.d.ts b/apps/desktop/src/renderer/vite-env.d.ts
index aa37ae49c3..88e3c6042a 100644
--- a/apps/desktop/src/renderer/vite-env.d.ts
+++ b/apps/desktop/src/renderer/vite-env.d.ts
@@ -3953,6 +3953,8 @@ interface ElectronAPI {
onSettled(cb: (event: import('../shared/providerShare').ProviderShareSettledEvent) => void): () => void;
onOpenJoin(cb: (event: { link: string }) => void): () => void;
onOpenManage(cb: (event: { providerId: string }) => void): () => void;
+ /** 有人请求把这里分享的供应商经他的供应商组转给别人用(转分享)。 */
+ onReshareRequested(cb: () => void): () => void;
};
providerGroup: {
command<C extends import('../shared/providerGroup').ProviderGroupCommand>(
diff --git a/apps/desktop/src/shared/providerGroup.ts b/apps/desktop/src/shared/providerGroup.ts
index ffb40b77ff..b430e5665f 100644
--- a/apps/desktop/src/shared/providerGroup.ts
+++ b/apps/desktop/src/shared/providerGroup.ts
@@ -103,6 +103,26 @@ export interface ProviderGroupMemberStatus {
* 按自己的连接情况补上,不来自组所在电脑的回包。
*/
unreachableHere?: boolean;
+ /**
+ * 分享来的电脑:这台的主人对本机分享出去的人逐人同意的结果(provider-sharing.md §4.3)。只在本机自己的组里、
+ * 组所在的供应商分享给了别人时有;不经设备互联发给其他电脑。
+ */
+ reshare?: ProviderGroupReshareSummary;
+}
+
+/** 本机分享出去的一个人:分享来的那台电脑的主人是否同意他经组使用那台。 */
+export interface ProviderGroupReshareGuest {
+ memberId: string;
+ displayName: string;
+ avatarUrl: string | null;
+ /** unknown = 还没问到(那台离线或刚加入)。 */
+ state: 'approved' | 'pending' | 'rejected' | 'unknown';
+}
+
+export interface ProviderGroupReshareSummary {
+ /** needs-update = 那台的 Cindy 太旧,给不出同意;unknown = 还没问到。 */
+ support: 'supported' | 'needs-update' | 'unknown';
+ guests: ProviderGroupReshareGuest[];
}
export interface ProviderGroupView {
diff --git a/apps/desktop/src/shared/providerShare.ts b/apps/desktop/src/shared/providerShare.ts
index 8e5fadcc1c..572c89cd94 100644
--- a/apps/desktop/src/shared/providerShare.ts
+++ b/apps/desktop/src/shared/providerShare.ts
@@ -40,6 +40,8 @@ export const PROVIDER_SHARE_IPC = {
OPEN_JOIN: 'provider-share:open-join',
/** 打开某个供应商的分享管理页(系统通知点击)。payload: { providerId: string } */
OPEN_MANAGE: 'provider-share:open-manage',
+ /** 分享者:有人把这里分享的供应商放进了自己的供应商组,请求转给别人用(待处理一栏重读)。payload: null */
+ RESHARE_REQUESTED: 'provider-share:reshare-requested',
} as const;
export type ProviderShareUsageRange = '7d' | 'month' | 'all';
@@ -67,10 +69,25 @@ export interface ProviderShareModelUsageView {
amount: ProviderShareMoney | null;
}
+/**
+ * 转分享(provider-sharing.md §4.3):这个成员把分享来的供应商放进了自己的供应商组,又把组分享给了别人。
+ * 每一项是他分享的一个人;昵称与头像由他的电脑转述。
+ */
+export interface ProviderShareReshareView {
+ id: string;
+ name: string;
+ avatarUrl: string | null;
+ state: 'pending' | 'approved' | 'rejected';
+ requestedAt: number;
+ decidedAt: number | null;
+}
+
export interface ProviderShareMemberView extends ProviderShareMember {
lastUsedAt: number | null;
runningTasks: number;
models: ProviderShareModelUsageView[];
+ /** 经这个成员的供应商组转给别人用的请求;没有时为空(旧快照可能缺省)。 */
+ reshares?: ProviderShareReshareView[];
}
export interface ProviderShareOwnedView {
@@ -135,6 +152,8 @@ export type ProviderShareCommand =
| { action: 'create-link'; providerId: string }
| { action: 'approve' | 'reject'; requestId: string }
| { action: 'set-member'; memberId: string; status: 'pause' | 'resume' | 'remove' }
+ /** 转分享:同意或拒绝(拒绝已同意的 = 撤回)。 */
+ | { action: 'reshare-decide'; id: string; decision: 'approve' | 'reject' }
| { action: 'received' }
| { action: 'received-snapshot'; favoriteRecovery?: ProviderShareFavoriteRecovery }
| { action: 'preview'; link: string }
@@ -158,6 +177,7 @@ export interface ProviderShareCommandResult {
approve: { ok: true };
reject: { ok: true };
'set-member': { ok: true };
+ 'reshare-decide': { ok: true };
received: ProviderShareReceived[];
'received-snapshot': ProviderShareReceivedSnapshot;
preview: ProviderShareLinkPreview;
diff --git a/docs/dev-rules/credentials-and-local-storage.md b/docs/dev-rules/credentials-and-local-storage.md
index b0bb18029a..5bfc19c040 100644
--- a/docs/dev-rules/credentials-and-local-storage.md
+++ b/docs/dev-rules/credentials-and-local-storage.md
@@ -202,6 +202,8 @@ Desktop 的运行时 refresh 遇到瞬时失败后,主动调用与定时重试
| 旧版 worktree 回收器兼容锁 | 不再创建新的跨 profile Git 锁;保留旧回执对 `<commonGitDir>/worktrees/<id>/locked` 及更早 `.worktree-keep` 的清理。仅当最后一个共享借用结束且自建文件身份和内容仍匹配时删除,不覆盖用户锁;失败沿用 `.release` 重试。支持精确的 `bigint:dev:ino:birthtimeNs` 身份;旧数字编号为 0 或超过安全整数范围时无法证明归属,保留锁但仍释放已结束的租约,避免 Windows 编号精度丢失误删用户替换文件 |
| 跨 profile 的 worktree 回收日志位置 | `app.getPath('appData')/Cindy/shared-worktree-recycle-journals`,仍按日志目录哈希发布原 profile 日志位置,兼容可能同时运行的旧客户端;新客户端不再读取其他 profile 的日志来借用工程。不复制恢复状态、不代替 owner 执行恢复 |
| 供应商分享:分享者电脑上的受邀者用量 | `userData/remote-agent/provider-share-usage.json`,按(日期、分享、成员、Agent、供应商、模型)聚合 token 与轮次,行内 `byMember` 按组内电脑的键再分(2026-10-11 加;行键与合计不变,旧版本照常累计并原样写回,合计多出各台之和的部分算没区分电脑),原子替换写入,保留 400 天;只含服务端生成的分享与成员 id,不含昵称、对话或凭证。成员删除后保留(管理页不再显示),同一人重新加入时接续 |
+| 供应商分享:转分享的同意 | `userData/owners/<账号>/provider-share-reshare.json`,分享者电脑上记下受邀者的组所在电脑报来的、请求经组使用的人(`provider-sharing.md` §4.3):服务端生成的分享与成员 id、那台组所在电脑的设备 id、组所在电脑给的不透明键、主人的决定与时间,以及组所在电脑转述的昵称与头像地址(只用于管理页认人,不进日志)。不含对话或凭证。原子替换写入;成员被删除或退出、启动后核对已不在这台的分享与成员时删除对应记录 |
+| 供应商组:转分享待清空记录 | 复用 `userData/owners/<账号>/provider-group-prefs.json` 的可选 `reshareCleanups`,只含分享来的电脑逻辑 id 与随机清理代次,不含昵称、头像、对话或凭证。最后一个组引用移出时,与组设置在同一跨进程锁内原子写入;对端确认空名单后按代次删除,失败每分钟重试,重启继续,重新加入先清空旧同意。旧文件缺字段视为空,旧版改写组设置仍保留未知字段;损坏文件保留并拒绝覆写。见 `provider-group/store.ts` 与 `__tests__/stores.test.ts` |
| 供应商按使用方的用量 | `userData/owners/<账号>/provider-usage-by-party.json`,按(日期、供应商、使用方、设备 id、组内电脑的键、Agent、模型)聚合 token 与轮次。使用方:本机、同账号另一台电脑、经同账号组所在电脑转来的受邀者任务、本机经另一台电脑的组在别的组内电脑上运行的(只用来报告给那台组所在电脑)、同账号电脑报告来的(每次报告整体替换那台从某天起的行);没有使用方字段的旧行按设备 id 推出。原子替换写入,保留 400 天;只含供应商 id、设备 id、组内电脑的键与模型名,不含对话或凭证。按账号存放(供应商 id 在不同账号下会重复),从开始记录起不补历史 |
| macOS 菜单栏余量设置 | `userData/menubar-settings.json`,本机偏好:是否显示、来源顺序与显隐、菜单栏文字、快见底通知、隐藏个人信息、统计范围;只含供应商 id,不含凭证或用量数值 |
| macOS 菜单栏 Cindy 余额样本 | `userData/owners/<账号>/menubar-credit-samples.json`,只记录观测到的余额数值与时间(按区域与币种分组),用于估算日均消耗;保留 30 天、原子替换写入,不含凭证或账号标识 |
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index f2a43ab49a..448fc6510f 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -929,7 +929,8 @@ handler 无 sender 依赖;不加入共享任务访客白名单,不进入自
B 上受邀者会话的 Agent 自带工具按白名单开放(产品规则 §9 第 5 条,不改 wire);受邀者电脑上的 `cindy_exec` 在任务的
Agent 位置是 `share:` 时为 Claude Code 追加 `WebFetch`(在受邀者电脑抓取,tools/list 追加项):旧版受邀者不列,受邀者就没有
WebFetch;旧版分享者上它与自带 WebFetch 并存。两种组合都不报错,也不改 wire;
- remote-agent wire 本身不变。新错误码 `REMOTE_AGENT_SHARE_PAUSED` / `REMOTE_AGENT_SHARE_REMOVED` / `REMOTE_AGENT_SHARE_UNAVAILABLE`
+ remote-agent wire 本身不变(2026-10-15 起受邀者可多调一个 op `reshare`、open 多一个可选 `reshareKey`,channel 白名单不变,
+ 见「供应商组:转分享需原主人逐人同意」)。新错误码 `REMOTE_AGENT_SHARE_PAUSED` / `REMOTE_AGENT_SHARE_REMOVED` / `REMOTE_AGENT_SHARE_UNAVAILABLE`
只在受邀者本机产生(分享者电脑回 `ACCESS_REVOKED`、relay 回 `REMOTE_DISABLED` 时改写成 `UNAVAILABLE`);
控制这台电脑的旧版手机没有对应文案,显示通用的发送失败提示。分享出去的 `maker:provider:list` 去掉分享者的账号身份
(`subscriptionAccount` / `openAiAccount` 与名称里的登录名、邮箱,`@cindy/device-link` 的 `scrubSharedProvider`),
@@ -1127,6 +1128,46 @@ G 重新打开时换一台。G 与 O 之间新增四项可选内容,O 与 M
自动交接)、`maker-ipc/sessionAgentSwitchHandler.ts`(仅内部可用的 `forceRelocation`);回归见
`remote-agent/__tests__/groupRelay.test.ts`、`provider-group/__tests__/service.test.ts`、`guestSwitch.test.ts`。
+## 供应商组:转分享需原主人逐人同意(2026-10-15)
+
+产品规则见 [`provider-sharing.md`](../product-rules/provider-sharing.md) §4.3 与 [`provider-groups.md`](../product-rules/provider-groups.md)
+§4。组所在电脑 O 的组里有分享来的组内电脑 M(O 的账号是 M 的受邀者),O 又把组所在的供应商分享给了 G:G 的任务要经 O 中转到
+M 上运行,必须先由 M 的主人逐人同意(按 G 的账号,不按设备)。O 与 M 之间沿用 `maker:remote-agent:v1`,新增三项可选内容;
+G 与 O 之间不变。受邀者能调用的 channel 不变(仍是 `maker:remote-agent:v1` 的新 op,不改 `PROVIDER_SHARE_CHANNELS`、
+`REMOTE_INVOKE_ALLOWLIST` 与 allowlist 哈希)。
+
+- **caps 新增可选 `reshareConsent: true`**(`RemoteAgentCaps`,`parseRemoteAgentCaps` 白名单只认 `true`):M 能记下并核对转分享的
+ 同意。只回给受邀者对端(同账号控制端经组使用不需要同意)。O 只给声明了它的 M 报人;未声明的旧 M 给不出同意,O 不把受邀者的
+ 任务分给它,设置页提示那台需要更新。O 在每次 open 前现查(含绕过分配的已有绑定续接),不能沿用降级前的能力或同意缓存。
+- **新 op `reshare { entries: [{ key, name, avatar? }] }`**(`parseRemoteAgentRequest`):O 把它此刻分享的人整体报给 M(整体替换
+ 调用方上一份;调用方按本地 peer key 的(分享、成员、设备)区分)。`key` 是 O 按(O 的分享 id, G 的成员 id)派生的不透明键(格式同
+ `REMOTE_AGENT_RELAY_KEY_PATTERN`,同一个人从哪台设备来都相同);`name`(≤128 字符,无控制字符)与 `avatar`(只收 https)由 O 转述,
+ 只用来让 M 的主人认出是谁。最多 256 项、键不能重复。回包 `{ entries: [{ key, state: 'pending' | 'approved' | 'rejected' }] }`
+ (`parseRemoteAgentReshareResult`,不认识的状态与请求外的键丢弃)。M 只接受受邀者对端,其他调用方回 `REMOTE_AGENT_INVALID`;旧 M
+ 不认识这个 op 同样回 `REMOTE_AGENT_INVALID`。替换语义使重复发送安全;O 只在本机分享快照已拉到时才报,避免空名单清掉已有同意。
+ 单次请求上限是 wire 防护,不是分享人数上限:超过 256 人时,O 先从 M 的 caps 读取 `reshareBatch: true`,再用不透明的
+ `batch: { id, index, count }` 按 256 人分片顺序发送;每片响应只带当前片的状态、同一批次信息与 `complete`,最后一片才表示接收端已整体替换。
+ M 可以乱序接收并在内存暂存,缺片或未收齐时保留上一份已落盘审批名单;未完成批次 10 分钟后过期,新批次替换同一来源的旧批次。
+ 批次数不设按人数的固定上限,接收端按序列化字节总预算限制未完成批次,超预算返回可重试的忙碌错误;已完成批次在过期前对重复片段回同一完成状态,避免重试重新创建待处理批次。
+ 没有 `reshareBatch` 的旧 M 不能安全接收大名单,O 标记需要更新且不发送任何部分名单。
+- **open 载荷新增可选 `reshareKey`**(`remote-agent/wire.ts`,同 relay 键格式):O 把受邀者任务转给分享来的 M 时带上这个人的键
+ (同账号组内电脑不带;G 自己填的不转发)。M 收到受邀者对端带 `relay` 的 open(即被转来的任务,含续接)时,只有主人同意过
+ (调用方, `reshareKey`)才运行:带了 `reshareKey` 而没同意回新错误码 `REMOTE_AGENT_RESHARE_NOT_ALLOWED`(带这个字段即表示 O 认识它);
+ 没带(旧 O)回已有的 `REMOTE_AGENT_PROVIDER_NOT_ALLOWED`,旧 O 照常换组里下一台、转给 G 时统一成「暂时不可用」。
+ 主人撤回同意时 M 立即结束这个人经组转来的任务;M 在所有异步查询结束后、登记任务前再次核对同意,核对与登记之间不等待。
+ O 收到 `REMOTE_AGENT_RESHARE_NOT_ALLOWED` 时重新核对同意情况,之后不再选它。
+- O 移出最后一个组引用时,在本机组设置里原子记下待清空代次;`reshare` 空名单得到有效回包后才删除该代次,失败每分钟重试,
+ 重启后继续。重新加入时先清空再报人;迟到的确认不能吞掉再次移出的新代次。不新增 wire 字段,沿用整体替换的幂等语义。
+- O 给 G 的匿名组状态(`groupStatus`)里,没同意过 G 的分享来的电脑显示 `unavailable`(那台给不出同意时 `needs-update`),与实际
+ 分配一致;`groupSize` 不变。
+- 已知局限:M 只能按 O 自报的 `relay` 认出被转来的任务;改过的 O 不带 `relay` 时 M 分不出(防误分享,不防恶意,与供应商分享
+ 「默认信任分享对象」一致)。更早的 O(P2b 之前)不带 `relay`,M 同样分不出。
+- 不改 relay、服务器与数据库(M 的同意记录在本机 `provider-share-reshare.json`)。实现:`packages/device-link/src/remoteAgent.ts`、
+ `remote-agent/host/runHost.ts`、`host/groupRelay.ts`(`reshareKeyFor`)、`device-link/providerShareReshare.ts`(M 侧记录)、
+ `provider-group/reshare.ts` 与 `reshareRuntime.ts`(O 侧报人与缓存)、`provider-group/guestRelay.ts`(选电脑);回归见
+ `packages/device-link/src/__tests__/remoteAgent.test.ts`、`remote-agent/__tests__/groupRelay.test.ts`、
+ `provider-group/__tests__/reshare.test.ts`、`guestRelay.test.ts`、`device-link/__tests__/providerShareReshare.test.ts`。
+
## 供应商分享:受邀者不看分享者的电脑名,组只给台数(2026-10-10)
产品规则见 [`provider-sharing.md`](../product-rules/provider-sharing.md) §5.1、§6 与 [`provider-groups.md`](../product-rules/provider-groups.md)
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index b65a363fc8..ca108c8451 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -26,6 +26,8 @@
> 2026-10-11 用户确认:**换不换电脑统一成一个判定**——新建任务、工作中、发送前、协同、分享的人、手机都问同一处
> (`provider-group/failurePolicy.ts`);**默认出问题就换**,只有换到哪台都一样、或不是那台电脑的问题时不换;本机的操作不打断
> 进行中的远程一轮。见 §6.1「怎么判断换不换」。
+> 2026-10-15 用户要求:**分享来的电脑不能借组转给别人**——组所在的供应商分享给了别人时,分享的人的任务只分给主人逐人同意过
+> 这个人的分享来的电脑;原分享被删除或已退出后那台自动移出组。见 §3、§4「分享的人(中转)」与[供应商分享](provider-sharing.md) §4.3。
> 2026-10-15 用户裁决:**组策略谁用都是一套**——撤掉 2026-10-12 的「本机自用优先」,本机自己的任务与同账号其他电脑、
> 分享的人一样按组策略分配,本机只是组里普通的一台;「暂停对外分配」仍只拦外部新任务。同日要求**配额先比、快到期的先用**
> (目的是尽快把快重置的配额用掉):不论选哪种组策略,都先用每周配额 5 小时内重置的,然后是 5 小时配额 1 小时内重置的,
@@ -94,6 +96,12 @@
- 分享关系属于账号:组所在电脑账号收到的分享,这个账号的其他电脑也能直接用。被组所在电脑加进组之后,
这个账号的其他电脑上不再单独列出它,只列组那一项(与同账号电脑被收进组同一条规则,§10);组所在电脑离线时
它重新单独出现。组设置本身仍只存在组所在电脑本机。
+- **原分享被删除或已退出,那台自动移出组**(2026-10-15 用户要求):分享来的电脑对应的分享从这个账号收到的分享里消失
+ (分享者删除、或这个账号退出)时,组所在电脑把它移出组并解除指向它的任务绑定,组所在电脑自己与它分享的人都不再用到它。
+ 只在已收到的分享名单完整可信时判断:本区域名单已拉到,本账号可能有分享的对方区域名单也都已确认;拉取失败、还没拉到、
+ 换账号中都不动。分享只是暂停时保留(显示「分享已暂停」)。实现见 `provider-group/removedShares.ts`(接线在 `reshareRuntime.ts`),回归见同名测试。
+- **分享来的电脑不能借组转给别人**(2026-10-15):加进组只扩大这个账号自己的用法;组所在的供应商分享给了别人时,分享的人
+ 要经组用到分享来的电脑,必须由那台的主人逐人同意(§4「分享的人(中转)」,[供应商分享](provider-sharing.md) §4.3)。
- 组内电脑数量不设上限;每台的并发上限见 §5。
- 协同任务的 Lead 与 Worker 与普通任务一样归供应商组分配、出问题时自动换电脑(2026-10-10 用户裁决:远程与本机
供应商对协同是同一套逻辑与体验),细则见 §6.1「协同任务」。审查任务的设置固定跟随源任务,不归供应商组分配。
@@ -122,9 +130,21 @@
- 受邀者的**新任务**按组策略选一台:选到组所在电脑就在本机运行;选到别的电脑就由组所在电脑中转,事件、反向请求、
WebSocket 帧原样转发,消息与附件不解码、不落盘(§8「只在内存中转」)。受邀者带来的「已分配」「中转」字段一律
当作普通受邀者任务处理,组所在电脑不让受邀者自己决定去哪台。
- - 只选能接受受邀者的电脑:组所在电脑自己;分享来的电脑(那台本来就把组所在电脑当受邀者隔离);同账号电脑要声明
- 能按受邀者隔离(`guestRelay`),不声明的旧版本一阵子(10 分钟)不再给它受邀者的任务,但不冷却它,组所在电脑
- 自己的任务照常分过去。
+ - 只选能接受受邀者的电脑:组所在电脑自己;分享来的电脑(那台本来就把组所在电脑当受邀者隔离),且**那台的主人同意过
+ 这个受邀者**(2026-10-15,[供应商分享](provider-sharing.md) §4.3);同账号电脑要声明能按受邀者隔离(`guestRelay`),
+ 不声明的旧版本一阵子(10 分钟)不再给它受邀者的任务,但不冷却它,组所在电脑自己的任务照常分过去。
+ - **转分享的同意**:组所在电脑自动把分享出去的人(按账号)报给组里每台分享来的电脑,由那台的主人逐人同意;结果只在组所在
+ 电脑内存里,以那台为准(组或分享的人变化后马上报,还有人等着时每分钟再问,其余每 10 分钟核对,设置页打开时 15 秒内现问),
+ 没问到之前一律当作没同意。中转到分享来的电脑时带上这个人的转分享键,那台再核对一次,没同意就拒绝(换组里下一台,不冷却);
+ 主人撤回时那台立即结束这个人的任务;查询供应商、续接归属等等待结束后,登记任务前再次核对,同一步登记,中间不再等待。
+ 每次向分享来的电脑打开任务(含已有绑定的续接)都现查 `reshareConsent` 能力;降级的旧端不能沿用缓存同意接任务。
+ 分享来的电脑离开全部组时,移出组与待清空记录同一次原子写入;空名单被确认后才删除,失败每分钟重试,重启后继续。重新加入
+ 也先清空旧同意,再重新报人;已确认的空名单不再定时轮询。实现与回归见 `provider-group/store.ts`、`reshare.ts` 及对应测试。
+ 名单超过 256 人时由支持 `reshareBatch` 的新版电脑按批次分片,每片回报当前片状态,接收端收齐后才整体替换;批次数不设固定人数上限,
+ 接收端以字节预算保护内存;已完成片段重发仍幂等。旧版不能安全接收大名单时显示需要更新,不发送部分名单。
+ 那台的 Cindy 太旧、给不出同意时不分给分享的人。分享的人看到的匿名状态里这台写「暂不
+ 可用」(或「需要更新」),组的台数不变。同账号的电脑经组使用(组所在电脑自己与我的其他电脑)不需要同意。
+ 协议见 `docs/dev-rules/protocol-compatibility.md`「供应商组:转分享需原主人逐人同意」。
- 被中转过来的任务,组内电脑一律按受邀者隔离运行(即使来自同账号的组所在电脑):受邀者目录、会话索引与运行数按
(组所在电脑, 受邀者)分开,受邀者在那台的身份是组所在电脑为它取的不透明键,任务 id 也按受邀者派生,两个受邀者
用同一个任务 id 不会撞车。组所在电脑在同一台组内电脑上按受邀者各算 16 个任务、合计不超过 64 个。
@@ -438,7 +458,9 @@
- 分享者这边也不弹确认:「远程与分享」页的供应商组一块写明「分享的人的任务也按组分配」。
- 已知差异(2026-10-09 确认接受):这条规则上线前加入的受邀者,以及仍在用旧版本申请的受邀者,看到的是
「Agent 在 {分享者} 的电脑上运行」。不补提醒,只更新「分享给我的供应商」详情里的说明。
-- 分享来的组内电脑上,组所在电脑作为受邀者照常受到受邀者隔离(供应商分享 §9);它的主人只看到组所在电脑账号的昵称与头像。
+- 分享来的组内电脑上,组所在电脑作为受邀者照常受到受邀者隔离(供应商分享 §9);它的主人只看到组所在电脑账号的昵称与头像,
+ 以及组所在电脑转述的、请它同意的分享的人的昵称与头像(转分享,供应商分享 §4.3;受邀者申请弹窗已写明会展示给需要同意的
+ 其他电脑主人)。不给它看分享的人的其他信息,也不给它看组里其他电脑。
- 组所在电脑能看到经它转发的对话与文件内容,与分享者电脑一致;转发内容只在内存中转,不写入日志。
- 组内电脑报出的、会透露它是谁或它与组所在电脑关系的错误(那台对组所在电脑的分享暂停、没开远程调用、连不上等),
转给受邀者时统一成「暂时不可用」。已知差异(P2b):Agent 输出与工具路径里可能出现组内电脑上的会话目录路径(含那台的
@@ -462,6 +484,8 @@
(`groupSize`,2026-10-10)。2026-10-12 增加按需读取的匿名状态(`groupStatus`):只含固定状态枚举,
不含组员标识、真实名称、来源关系、任务数、并发上限、订阅配额或用量。组摘要里分享来的组员也不带名字
(旧快照可能是那位分享者的电脑名)。
+8. **分享来的电脑不借组转给别人**(2026-10-15):分享的人的任务只分给主人逐人同意过这个人的分享来的电脑,那台电脑
+ 打开被转来的任务时再核对一次(供应商分享 §4.3、§9 第 8 条);原分享被删除或已退出后那台移出组(§3)。
## 10. 界面
@@ -539,6 +563,11 @@
- 组名本身不再带组所在电脑那一个账号的名字。手机端本期不变。实现见 `apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx`
的 `providerGroupUsage`,回归见 `modelSelectorProviderGroupUsage.test.tsx`。
- 设置页组内电脑一行与「添加电脑」弹窗里,分享来的电脑写「{分享者} 的电脑」,不写分享者的电脑名(供应商分享 §6)。
+- **分享来的电脑的转分享状态**(2026-10-15,供应商分享 §4.3):组所在的供应商分享给了别人时,这一行的状态后面接一句
+ 「分享的人可以用」「N 位分享的人等待 {分享者} 同意」「{分享者} 未同意 N 位分享的人」,那台给不出同意时写
+ 「{分享者} 的 Cindy 更新后才能同意给分享的人用」,还没问到时写「还不知道 {分享者} 是否同意给分享的人用」;不另占一行。
+ 点名称一侧展开时,在「别人分享的电脑不显示配额」下方逐人列出(头像、昵称、已同意/等待同意/未同意/还没问到)。
+ 只在本机自己的组里显示,同账号另一台电脑查看组的只读列表不显示。实现见 `features/provider-group/GroupMemberReshare.tsx`。
- **只显示组**(2026-10-10):同账号其他电脑的模型列表与设置页左栏里,被其他在线电脑的组收进去的远程供应商与
分享不再单独列出,只列组所在电脑那一项;不在任何组里的照常单独显示。规则:
- 只看此刻在线、列表里有的电脑的目录:组所在电脑离线时组那一项不在,组员自动重新单独出现;
@@ -625,7 +654,8 @@
| 角色 | 是旧版本时 |
|---|---|
| 组所在电脑 | 组只在新版本里存在。降级到旧版本后组不生效,这个供应商回到只在本机运行;经组分到其他电脑的任务在旧版本里不能续接,需要换模型或新开任务。同账号其他电脑问它时得到 `CHANNEL_NOT_ALLOWED`、目录里也没有组摘要,当作没有组照常直接连它;已经经它的组分到别处的任务留在原处,成为普通的远程 Agent 任务 |
-| 组内电脑 | 照常作为普通的同账号远程供应商或分享来的供应商接任务。「已由供应商组分配」标记对它是不认识的字段,解码时丢弃;它本来没有组,也不会转圈。旧版同账号组内电脑不声明 `guestRelay`,组所在电脑不给它分受邀者的任务(它不会按受邀者隔离);旧版分享来的组内电脑本来就把组所在电脑当受邀者,照常接,只是不按受邀者再细分作用域(组所在电脑自己按受邀者隔离) |
+| 组内电脑 | 照常作为普通的同账号远程供应商或分享来的供应商接任务。「已由供应商组分配」标记对它是不认识的字段,解码时丢弃;它本来没有组,也不会转圈。旧版同账号组内电脑不声明 `guestRelay`,组所在电脑不给它分受邀者的任务(它不会按受邀者隔离);旧版分享来的组内电脑本来就把组所在电脑当受邀者,照常接组所在电脑自己的任务;它给不出转分享的同意(caps 不声明 `reshareConsent`),2026-10-15 起组所在电脑不再把分享的人的任务分给它,设置页提示那台需要更新(供应商分享 §4.3) |
+| 组所在电脑(转分享) | 2026-10-15 之前的组所在电脑不知道要征得同意,会照旧把分享的人的任务转给分享来的电脑:新版分享来的电脑见到被转来(带中转标记)却没带转分享键的任务一律拒绝(回已有的 `REMOTE_AGENT_PROVIDER_NOT_ALLOWED`),旧组所在电脑照常换组里下一台,转给分享的人时统一成「暂时不可用」 |
| 同账号其他电脑 | 直连由任务所在的电脑执行,旧版本不认识组:选组所在电脑的这个供应商时直接在组所在电脑上运行(没有组),模型列表里组内电脑照常单独显示、没有供应商组的标注 |
| 手机与远程控制 | 旧手机、旧控制端不认识组摘要,模型列表照常逐台列出。被控电脑是旧版本时问不到「这个任务归哪个组」(`CHANNEL_NOT_ALLOWED` 或不认识的动作),按没归组处理:组照样收起,在组那一项里选模型照旧先确认换电脑,与之前相同 |
| 分享的人 | 照常使用,中转对它透明(协议不变)。打开任务阶段的换电脑由组所在电脑完成,旧版本同样享受;运行中失败时它没有声明支持「需要换一台」,组所在电脑照旧返回原来的错误(如用量上限),用户像现在一样换模型或稍后重试。新版本声明支持,运行中失败时自动换一台(§6.1)。旧版本申请弹窗仍是「Agent 在 {分享者} 的电脑上运行」(§8 已知差异) |
diff --git a/docs/product-rules/provider-sharing.md b/docs/product-rules/provider-sharing.md
index 0cd00b1f8d..d550f83c39 100644
--- a/docs/product-rules/provider-sharing.md
+++ b/docs/product-rules/provider-sharing.md
@@ -9,6 +9,8 @@
> 分享出去的供应商建了[供应商组](provider-groups.md)时,§1 的运行位置、§7.2 管理页、§7.4 用量
> 与 §9 安全不变量按该文调整:受邀者的任务按组分配与中转、运行中自动换电脑已实现(2026-10-10,P2b / P2c),
> 按组的用量(§7.4)在 P3。§4.1 第 3 步的告知不论有没有组都已改用该文 §8 的说法(2026-10-10)。
+> 2026-10-15 用户要求:受邀者把分享来的供应商放进自己的供应商组再分享给第三人时,必须由原分享者逐人同意;原分享者
+> 删除对他的分享后,他与他分享的人都不再能用到它,见 §4.3、§9 第 8 条。
## 1. 定位
@@ -78,7 +80,8 @@
- 运行方式:Agent 在分享者的电脑或分享者安排的其他电脑上运行(分享者可能建了[供应商组](provider-groups.md);
不论有没有组都这样写,之后建组不需要再提醒),受邀者的文件和命令仍在自己电脑上执行;
- 隐私:对话内容和 Agent 读到的文件内容会经过分享者的电脑,并保存在实际运行任务的那台电脑上;
- - 身份:受邀者的昵称和头像会展示给分享者,不展示邮箱、手机号等其他信息。
+ - 身份:受邀者的昵称和头像会展示给分享者,以及需要同意他使用的其他电脑主人(分享者把别人分享来的电脑放进了
+ 供应商组,§4.3),不展示邮箱、手机号等其他信息。
受邀者点「发送申请」后才真正提交;取消不提交,链接在 5 分钟有效期内保持未使用。
提交后受邀者看到本次申请的**配对码**(见 §6.1),等待分享者同意。
@@ -107,6 +110,34 @@
- 分享者打开自己的链接:提示「这是你自己的供应商,你的其他电脑可以直接使用」,不进入申请流程。
- 同一受邀者已拥有该供应商的分享时再次申请:提示已在使用,不重复建立。
+### 4.3 转分享:分享来的供应商再给别人用(2026-10-15 用户裁决)
+
+受邀者 B 可以把 A 分享来的供应商加进自己的[供应商组](provider-groups.md);这只扩大 B 自己的用法(A 已同意 B 使用),
+不需要再问 A。但 B 把这个组又分享给别人(C)时,C 的任务会经组跑到 A 的电脑上,等于把 A 的供应商转给了 C,**必须由 A
+逐人同意**:
+
+- **按人同意**(用户裁决:每个新受邀者都要 A 单独同意,不是同意一次就对 B 的所有受邀者有效)。按 C 的账号计,C 从哪台
+ 电脑来都是同一个人。A 没同意的人,任务不会分到 A 的电脑;B 分享出去照常进行,C 用组里其他电脑。
+- **不用 B 手动发起**:B 的组所在电脑在组里有分享来的电脑、而组所在的供应商又分享给了别人时,自动把分享的人报给那台
+ 电脑;B 新分享给一个人、或把分享来的电脑加进已分享的组时随之报上。B 不能替 A 同意。
+- **A 处理**:A 的「远程与分享」页「待处理」一栏出现「{C} 想经 {B} 的供应商组使用」,可同意或拒绝;处理过的人列在
+ 「已分享的人」里 B 那一行下方,已同意的可以撤回,拒绝的可以改为同意。新请求在应用不在前台时发系统通知,设置页入口
+ 亮提示点;不另弹审批弹窗(不是新的分享申请)。A 看到的 C 的昵称与头像由 B 的电脑转述,A 无法另行核实(§6 已知局限同理);
+ 同意后 C 的用量算在 B 名下(A 那边看到的仍是 B 在用)。
+- **生效与撤回**:同意后下一次分配起生效;撤回或拒绝立即结束 C 经组跑在 A 电脑上的任务,之后不再分给 A 的电脑。
+ B 删除 C、或把 A 的电脑移出组时,A 那边的这条请求随之消失;A 删除对 B 的分享(或 B 退出)时,B 名下的全部同意一并作废,
+ 之后重新分享给 B 也要重新同意。
+- **原分享删除即不再有**:A 删除对 B 的分享或 B 退出后,B 自己与 B 分享的人都用不到 A 的电脑——B 的组在确认分享已不在后
+ 自动把那台移出组(只在拿到完整可信的已收到分享名单时才判断,见[供应商组](provider-groups.md) §3)。A 只是暂停分享时保留,
+ 恢复后照旧(同意也保留)。
+- **B 那边看到什么**:组内电脑那一行的状态写「分享的人可以用」「N 位分享的人等待 {A} 同意」或「{A} 未同意 N 位分享的人」;
+ 展开这一行逐人列出。A 的 Cindy 太旧给不出同意时写「{A} 的 Cindy 更新后才能同意给分享的人用」,这台不分给分享的人。
+ C 在「分享给我的供应商」的匿名状态里看到这台「暂不可用」(或「需要更新」),与实际分配一致。
+- 协议见 `docs/dev-rules/protocol-compatibility.md`「供应商组:转分享需原主人逐人同意」;同意记录只存在 A 的电脑上
+ (`provider-share-reshare.json`),不经服务端。分享来的供应商本身仍不能生成分享链接,只能经组转给别人。
+ 转分享名单单次最多传 256 人;超过时由支持 `reshareBatch` 的新版电脑分片发送,每片回报当前片的状态,接收端收齐后才整体替换审批名单,
+ 批次数不按人数设置固定上限而受接收端字节预算保护。完成片段的重发保持幂等;旧版电脑显示需要更新并保持原有名单,不发送部分名单。
+
## 5. 受邀者使用
### 5.1 模型列表
@@ -219,8 +250,9 @@ Desktop「设置 → 模型供应商」的左栏(2026-10-08 用户裁决):
管理页按供应商划分,标题为「分享 {供应商}」,从设置页进入、可返回:
- **生成分享链接**:主操作。
-- **待处理**:待审批的申请(同意/拒绝);为空时整块隐藏。链接 5 分钟即过期,不列出未使用的链接。
-- **已分享的人**:每人一行,显示头像、昵称、加入时间、最近使用、当前状态(正常/已暂停)与是否有任务正在运行。
+- **待处理**:待审批的申请(同意/拒绝),以及转分享请求(§4.3,同意/拒绝);为空时整块隐藏。链接 5 分钟即过期,不列出未使用的链接。
+- **已分享的人**:每人一行,显示头像、昵称、加入时间、最近使用、当前状态(正常/已暂停)与是否有任务正在运行;这个人经自己的
+ 供应商组转给别人用、已处理过的请求列在这一行下方(已同意的可撤回,拒绝的可改为同意,§4.3)。
- **用量**(2026-10-11 起移到页面上方的「用量」块,见[供应商组](provider-groups.md) §7):按人列出——第一行是自己(当前登录账号),
之后是分享的人,每人一行显示所选时间段内的用量合计(只显示昵称与头像,§6);展开后按电脑分开、每台下面按模型列出
(没有组的供应商当成只有本机一台的组,2026-10-12 起):轮次、输入 token、输出 token、估算金额。
@@ -410,6 +442,10 @@ Desktop「设置 → 模型供应商」的左栏(2026-10-08 用户裁决):
`apps/desktop/src/renderer/features/provider-share/ProviderShareReceivedRail.tsx`;
命令判定复用 `packages/maker-core/src/agents/shared/auto-review.ts` 的 `shellCommandReadsCredentials`,
上面的命令放宽与 git 核实通过它只有分享任务才传的选项(`CredentialCommandOptions`)实现,不传时判定不变。
+8. **不能借组转分享**(2026-10-15):受邀者的供应商组替它分享的人转来的任务,分享者电脑只在主人同意过那个人时运行
+ (§4.3);没同意、已撤回或认不出是谁的一律拒绝,受邀者自己的任务不受影响。组所在电脑分配时同样先排除,分享者电脑
+ 是最终裁决方。分享者电脑只能按组所在电脑自报的中转标记认出被转来的任务:这是防误分享,不防被改过的客户端
+ (与「默认信任分享对象」一致)。
## 10. 与现有规则的关系
@@ -443,6 +479,9 @@ Desktop「设置 → 模型供应商」的左栏(2026-10-08 用户裁决):
本机任务与同账号远程供应商的确认不受影响。受邀者对这个分享打开了「信任 {分享者}」时,这些确认都不再弹,
启动同步仍不带凭证类文件;关掉后下一步起恢复确认,其他分享不受影响。
11. Light 与 Dark 两种模式都已实现。
+12. 受邀者 B 把分享来的供应商加进组、又把组分享给 C 后:分享者 A 没同意 C 时,C 的任务不会分到 A 的电脑(B 的电脑直接转过去
+ 也被 A 拒绝);A 同意后下一次分配起可用,撤回后 C 正在 A 电脑上的任务立即停止;A 同意 C 不代表同意 B 分享的其他人。A 删除对
+ B 的分享后,A 的电脑从 B 的组里移出,B 与 C 都用不到;A 只是暂停时保留。A 的 Cindy 较旧时 C 的任务不分给 A 的电脑(§4.3)。
## 12. 后续可选
diff --git a/packages/device-link/src/__tests__/remoteAgent.test.ts b/packages/device-link/src/__tests__/remoteAgent.test.ts
index 38f3d5e4c3..41f701e81b 100644
--- a/packages/device-link/src/__tests__/remoteAgent.test.ts
+++ b/packages/device-link/src/__tests__/remoteAgent.test.ts
@@ -12,6 +12,7 @@ import {
parseRemoteAgentReadResult,
parseRemoteAgentReply,
parseRemoteAgentRequest,
+ parseRemoteAgentReshareResult,
parseRemoteAgentStreamItem,
remoteAgentErrorCode,
} from '../index';
@@ -37,6 +38,102 @@ describe('remote agent channel', () => {
expect(parseRemoteAgentCaps({ ...caps, guestRelay: 'yes' })).not.toHaveProperty('guestRelay');
});
+ // 转分享(provider-sharing.md §4.3):组所在电脑把它分享的人报给分享来的组内电脑,由那台的主人逐人同意。
+ it('parses the reshare op, its result and the consent capability', () => {
+ const key = 'a1b2c3d4e5f60718293a4b5c6d7e8f90';
+ const other = 'b1b2c3d4e5f60718293a4b5c6d7e8f90';
+ expect(parseRemoteAgentRequest({
+ op: 'reshare',
+ entries: [
+ { key, name: ' Bob ', avatar: 'https://cdn.example.com/a.png', extra: 1 },
+ { key: other, name: 'Carol', avatar: 'http://insecure.example.com/a.png' },
+ ],
+ })).toEqual({
+ op: 'reshare',
+ entries: [
+ { key, name: 'Bob', avatar: 'https://cdn.example.com/a.png' },
+ { key: other, name: 'Carol' },
+ ],
+ });
+ expect(parseRemoteAgentRequest({ op: 'reshare', entries: [] })).toEqual({ op: 'reshare', entries: [] });
+ for (const bad of [
+ { op: 'reshare' },
+ { op: 'reshare', entries: [{ key: 'short', name: 'Bob' }] },
+ { op: 'reshare', entries: [{ key, name: '' }] },
+ { op: 'reshare', entries: [{ key, name: 'a\u0000b' }] },
+ { op: 'reshare', entries: [{ key, name: 'x'.repeat(129) }] },
+ { op: 'reshare', entries: [{ key, name: 'Bob' }, { key, name: 'Bob again' }] },
+ { op: 'reshare', entries: Array.from({ length: 257 }, (_, i) => ({ key: `${String(i).padStart(3, '0')}${key.slice(3)}`, name: 'x' })) },
+ ]) {
+ expect(() => parseRemoteAgentRequest(bad)).toThrow('REMOTE_AGENT_INVALID');
+ }
+ // 回包:不认识的状态与请求外的键丢掉。
+ expect(parseRemoteAgentReshareResult({
+ entries: [
+ { key, state: 'approved' },
+ { key: other, state: 'maybe' },
+ { key: 'c1b2c3d4e5f60718293a4b5c6d7e8f90', state: 'pending' },
+ ],
+ }, new Set([key, other]))).toEqual({ entries: [{ key, state: 'approved' }] });
+ expect(() => parseRemoteAgentReshareResult({
+ entries: [{ key, state: 'pending' }, { key, state: 'approved' }],
+ })).toThrow('REMOTE_AGENT_INVALID');
+ expect(() => parseRemoteAgentReshareResult({
+ entries: Array.from({ length: 257 }, (_, index) => ({
+ key: String(index).padStart(3, '0') + key.slice(3),
+ state: 'pending',
+ })),
+ })).toThrow('REMOTE_AGENT_INVALID');
+ expect(() => parseRemoteAgentReshareResult({})).toThrow('REMOTE_AGENT_INVALID');
+ const caps = { version: 1, agents: [], maxRuns: 16, uploadChunkBytes: 1024, maxPayloadBytes: 2048 };
+ expect(parseRemoteAgentCaps({ ...caps, reshareConsent: true }).reshareConsent).toBe(true);
+ expect(parseRemoteAgentCaps({ ...caps, reshareConsent: 1 })).not.toHaveProperty('reshareConsent');
+ expect(remoteAgentErrorCode('[REMOTE_AGENT_RESHARE_NOT_ALLOWED] no')).toBe('REMOTE_AGENT_RESHARE_NOT_ALLOWED');
+ });
+
+ it('parses reshare batches and rejects malformed batch metadata', () => {
+ const key = 'a1b2c3d4e5f60718293a4b5c6d7e8f90';
+ const batchId = 'batch-a1b2c3d4e5f6';
+ expect(parseRemoteAgentRequest({
+ op: 'reshare',
+ entries: [{ key, name: 'Bob' }],
+ batch: { id: batchId, index: 1, count: 2 },
+ })).toEqual({
+ op: 'reshare',
+ entries: [{ key, name: 'Bob' }],
+ batch: { id: batchId, index: 1, count: 2 },
+ });
+ expect(parseRemoteAgentRequest({
+ op: 'reshare',
+ entries: [{ key, name: 'Bob' }],
+ batch: { id: batchId, index: 4096, count: 4097 },
+ })).toMatchObject({ batch: { index: 4096, count: 4097 } });
+ expect(parseRemoteAgentReshareResult({
+ entries: [{ key, state: 'approved' }],
+ batch: { id: batchId, index: 1, count: 2, complete: true },
+ }, new Set([key]))).toEqual({
+ entries: [{ key, state: 'approved' }],
+ batch: { id: batchId, index: 1, count: 2, complete: true },
+ });
+ for (const batch of [
+ { id: 'short', index: 0, count: 1 },
+ { id: 123, index: 0, count: 1 },
+ { id: batchId, index: -1, count: 2 },
+ { id: batchId, index: 2, count: 2 },
+ { id: batchId, index: 0, count: 0 },
+ { id: batchId, index: 0, count: Number.MAX_SAFE_INTEGER + 1 },
+ ]) {
+ expect(() => parseRemoteAgentRequest({ op: 'reshare', entries: [{ key, name: 'Bob' }], batch }))
+ .toThrow('REMOTE_AGENT_INVALID');
+ }
+ const caps = { version: 1, agents: [], maxRuns: 16, uploadChunkBytes: 1024, maxPayloadBytes: 2048 };
+ expect(parseRemoteAgentCaps({ ...caps, reshareConsent: true, reshareBatch: true })).toMatchObject({
+ reshareConsent: true,
+ reshareBatch: true,
+ });
+ expect(parseRemoteAgentCaps({ ...caps, reshareBatch: 'yes' })).not.toHaveProperty('reshareBatch');
+ });
+
it('parses every op and drops unknown fields', () => {
expect(parseRemoteAgentRequest({ op: 'caps', x: 1 })).toEqual({ op: 'caps' });
expect(parseRemoteAgentRequest({ op: 'open', runId, agentKind: 'pi', payload: { json: { a: 1 } }, extra: 1 }))
diff --git a/packages/device-link/src/remoteAgent.ts b/packages/device-link/src/remoteAgent.ts
index 8068c0d522..41d1df636d 100644
--- a/packages/device-link/src/remoteAgent.ts
+++ b/packages/device-link/src/remoteAgent.ts
@@ -84,6 +84,8 @@ export const REMOTE_AGENT_ERROR_CODES = [
'REMOTE_AGENT_UNAVAILABLE',
// 那台电脑没有对这个供应商打开「允许被远程调用」(或已关闭)。
'REMOTE_AGENT_PROVIDER_NOT_ALLOWED',
+ // 供应商组转来的受邀者任务:这台电脑的主人没有同意这个受邀者经组使用(只回给打开时带了 reshareKey 的组所在电脑)。
+ 'REMOTE_AGENT_RESHARE_NOT_ALLOWED',
] as const;
export type RemoteAgentErrorCode = (typeof REMOTE_AGENT_ERROR_CODES)[number];
@@ -160,11 +162,52 @@ export type RemoteAgentRequest =
* 运行过的任务留下的会话记录与目录。relay 是组所在电脑为受邀者取的不透明键(打开任务时随载荷带过来),
* 只作用于调用方自己的 relay。旧版组内电脑回 REMOTE_AGENT_INVALID(它从没接过被中转的任务)。
*/
- | { op: 'forget'; relay: string };
+ | { op: 'forget'; relay: string }
+ /**
+ * 供应商组转分享(组所在电脑 → 分享来的组内电脑,调用方是那台的受邀者):组所在电脑把自己分享的人
+ * 经组使用这台电脑的请求整体报上来(整体替换调用方上一份),那台的主人逐人同意。回包是每一项此刻的结果
+ * ({@link RemoteAgentReshareResult})。只发给 caps 声明了 reshareConsent 的电脑;支持大名单的电脑另声明
+ * reshareBatch,分片在最后一片到达前不会替换审批名单。
+ */
+ | { op: 'reshare'; entries: RemoteAgentReshareEntry[]; batch?: RemoteAgentReshareBatch };
/** 供应商组为受邀者取的不透明键(组所在电脑按受邀者派生,不含身份信息);「需要换一台」凭证同一格式。 */
export const REMOTE_AGENT_RELAY_KEY_PATTERN = /^[A-Za-z0-9_-]{16,64}$/;
+/** 转分享批次 id 与 relay 一样是不透明的短键,不携带账号或成员身份。 */
+export const REMOTE_AGENT_RESHARE_BATCH_ID_PATTERN = /^[A-Za-z0-9_-]{16,64}$/;
+
+/**
+ * 转分享请求里的一个人:组所在电脑分享的人(按账号,不分设备)。key 是组所在电脑按(分享, 成员)派生的不透明键,
+ * 打开中转任务时随载荷带上(reshareKey);昵称与头像由组所在电脑转述,只用来让那台的主人认出是谁。
+ */
+export interface RemoteAgentReshareEntry {
+ key: string;
+ name: string;
+ avatar?: string;
+}
+
+/** 大名单转分享的片段信息;每个片段仍受 REMOTE_AGENT_MAX_RESHARE_ENTRIES 限制。 */
+export interface RemoteAgentReshareBatch {
+ id: string;
+ index: number;
+ count: number;
+}
+
+export type RemoteAgentReshareState = 'pending' | 'approved' | 'rejected';
+export const REMOTE_AGENT_RESHARE_STATES: readonly RemoteAgentReshareState[] = ['pending', 'approved', 'rejected'];
+
+export interface RemoteAgentReshareResult {
+ entries: Array<{ key: string; state: RemoteAgentReshareState }>;
+ /** 分块请求的回执;complete=false 时接收端尚未替换审批记录。 */
+ batch?: RemoteAgentReshareBatch & { complete: boolean };
+}
+
+/** 一次转分享请求最多带几个人(远高于实际分享人数,只用来挡异常请求)。 */
+export const REMOTE_AGENT_MAX_RESHARE_ENTRIES = 256;
+const RESHARE_NAME_MAX = 128;
+const RESHARE_AVATAR_MAX = 2048;
+
/**
* 供应商组「需要换一台」:组所在电脑在中转任务的事件流里发出的状态键,值是一次性凭证。只发给打开任务时
* 声明了 acceptsGroupSwitch 的控制端,排在那次错误前面;控制端取走凭证、不并入任务状态。
@@ -188,6 +231,13 @@ export interface RemoteAgentCaps {
* 不声明的电脑,组所在电脑不给它分受邀者的任务(否则受邀者会拿到主人级权限)。
*/
guestRelay?: boolean;
+ /**
+ * 供应商组转分享:受邀者(组所在电脑)可以报上它分享的人、由这台的主人逐人同意(op `reshare`),组转来的受邀者任务
+ * 只在同意过的人上运行。不声明的电脑给不出同意,组所在电脑不把受邀者的任务分给它。
+ */
+ reshareConsent?: boolean;
+ /** 是否支持带 batch 的转分享请求;未声明时只能使用单片旧协议。 */
+ reshareBatch?: boolean;
}
export interface RemoteAgentReadResult {
@@ -248,6 +298,23 @@ function count(value: unknown, max: number): number {
return value as number;
}
+function reshareBatch(value: unknown): RemoteAgentReshareBatch {
+ const v = record(value);
+ if (typeof v.id !== 'string' || !REMOTE_AGENT_RESHARE_BATCH_ID_PATTERN.test(v.id)) invalid();
+ // 片数不是产品人数上限;实际接收端按字节预算限制暂存内容。
+ const batchCount = count(v.count, Number.MAX_SAFE_INTEGER);
+ if (batchCount < 1) invalid();
+ const index = count(v.index, batchCount - 1);
+ return { id: v.id, index, count: batchCount };
+}
+
+function reshareResultBatch(value: unknown): RemoteAgentReshareResult['batch'] {
+ const v = record(value);
+ const batch = reshareBatch(v);
+ if (typeof v.complete !== 'boolean') invalid();
+ return { ...batch, complete: v.complete };
+}
+
function base64Chars(bytes: number): number {
return Math.ceil(bytes / 3) * 4;
}
@@ -357,11 +424,62 @@ export function parseRemoteAgentRequest(value: unknown): RemoteAgentRequest {
case 'forget':
if (typeof v.relay !== 'string' || !REMOTE_AGENT_RELAY_KEY_PATTERN.test(v.relay)) invalid();
return { op: 'forget', relay: v.relay };
+ case 'reshare': {
+ if (!Array.isArray(v.entries) || v.entries.length > REMOTE_AGENT_MAX_RESHARE_ENTRIES) invalid();
+ const entries = v.entries.map(reshareEntry);
+ if (new Set(entries.map((entry) => entry.key)).size !== entries.length) invalid();
+ return {
+ op: 'reshare',
+ entries,
+ ...(v.batch === undefined ? {} : { batch: reshareBatch(v.batch) }),
+ };
+ }
default:
invalid();
}
}
+function reshareEntry(value: unknown): RemoteAgentReshareEntry {
+ const v = record(value);
+ if (typeof v.key !== 'string' || !REMOTE_AGENT_RELAY_KEY_PATTERN.test(v.key)) invalid();
+ const name = typeof v.name === 'string' ? v.name.trim() : '';
+ // eslint-disable-next-line no-control-regex -- 控制字符是显式拒绝目标
+ if (!name || name.length > RESHARE_NAME_MAX || /[\u0000-\u001f\u007f]/.test(name)) invalid();
+ const avatar = reshareAvatar(v.avatar);
+ return { key: v.key, name, ...(avatar ? { avatar } : {}) };
+}
+
+/** 头像只收 https 地址;其他写法丢掉(不让整条请求失败)。 */
+function reshareAvatar(value: unknown): string | null {
+ if (typeof value !== 'string' || !value || value.length > RESHARE_AVATAR_MAX) return null;
+ try {
+ return new URL(value).protocol === 'https:' ? value : null;
+ } catch {
+ return null;
+ }
+}
+
+/** 组所在电脑读 `reshare` 的回包:不认识的状态、不在请求里的键丢掉。 */
+export function parseRemoteAgentReshareResult(value: unknown, keys?: ReadonlySet<string>): RemoteAgentReshareResult {
+ const v = record(value);
+ if (!Array.isArray(v.entries) || v.entries.length > REMOTE_AGENT_MAX_RESHARE_ENTRIES) invalid();
+ const entries: RemoteAgentReshareResult['entries'] = [];
+ const seen = new Set<string>();
+ for (const item of v.entries) {
+ const entry = item && typeof item === 'object' && !Array.isArray(item) ? item as Record<string, unknown> : null;
+ if (!entry || typeof entry.key !== 'string' || !REMOTE_AGENT_RELAY_KEY_PATTERN.test(entry.key)) continue;
+ if (seen.has(entry.key)) invalid();
+ seen.add(entry.key);
+ if (keys && !keys.has(entry.key)) continue;
+ if (!(REMOTE_AGENT_RESHARE_STATES as readonly unknown[]).includes(entry.state)) continue;
+ entries.push({ key: entry.key, state: entry.state as RemoteAgentReshareState });
+ }
+ return {
+ entries,
+ ...(v.batch === undefined ? {} : { batch: reshareResultBatch(v.batch) }),
+ };
+}
+
/** poll 按游标幂等:peer reset 后可以重读,其余 op 不可重试。 */
export function isRemoteAgentReadInvoke(channel: string, args: unknown[] | undefined): boolean {
if (channel !== REMOTE_AGENT_CHANNEL) return false;
@@ -391,6 +509,8 @@ export function parseRemoteAgentCaps(value: unknown): RemoteAgentCaps {
maxPayloadBytes: count(v.maxPayloadBytes, Number.MAX_SAFE_INTEGER),
...(v.virtualWorkspace === true ? { virtualWorkspace: true } : {}),
...(v.guestRelay === true ? { guestRelay: true } : {}),
+ ...(v.reshareConsent === true ? { reshareConsent: true } : {}),
+ ...(v.reshareBatch === true ? { reshareBatch: true } : {}),
};
if (caps.version < 1 || caps.maxRuns < 1 || caps.uploadChunkBytes < 1) invalid();
return caps;