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): 同账号任意电脑管理供应商组,受邀者可信任分享者 (#6069)

Liziae54765a320d
diff --git a/apps/desktop/src/main/bootstrap-electron.ts b/apps/desktop/src/main/bootstrap-electron.ts
index efd2cc7dda..1fcab02fdc 100644
--- a/apps/desktop/src/main/bootstrap-electron.ts
+++ b/apps/desktop/src/main/bootstrap-electron.ts
@@ -9697,7 +9697,7 @@ app.on('ready', async () => {
registerSharedTaskIpc(isSharedTaskAvailable, () => getDeviceLinkStatus() === 'online');
registerProviderShareIpc();
registerProviderGroupIpc({ reshare: providerGroupReshare });
- registerProviderGroupRemoteHandler();
+ registerProviderGroupRemoteHandler({ onGroupChanged: () => providerGroupReshare.kick('group') });
registerProviderGroupReshare();
registerFilePeerIpc();
registerRemoteDesktopIpc(isGlobalVoiceInputOverlaySender, {
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareApprovalWindows.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareApprovalWindows.test.ts
new file mode 100644
index 0000000000..f283ee5424
--- /dev/null
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareApprovalWindows.test.ts
@@ -0,0 +1,312 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const state = vi.hoisted(() => ({ scope: 'owner-a', boundaryPending: false, owned: [] as unknown[] }));
+const clipboard = vi.hoisted(() => ({ remember: vi.fn() }));
+vi.mock('../../appSessionState.js', () => ({
+ activeOwnerScopeKey: () => state.scope,
+ isAppSessionBoundaryPending: () => state.boundaryPending,
+}));
+vi.mock('../../textClipboard.js', () => ({ rememberIssuedClipboardText: clipboard.remember }));
+vi.mock('../../authManager.js', () => ({ getAuthState: () => ({ isAuthenticated: true }), getDeviceId: () => 'host-device' }));
+vi.mock('../../logger.js', () => ({ createLogger: () => ({ warn: vi.fn(), info: vi.fn() }) }));
+vi.mock('../../maker-host/remote-provider-access-store.js', () => ({ isRemoteProviderInvocationAllowed: () => true }));
+vi.mock('../settings-store.js', () => ({ readDeviceLinkSettings: () => ({ remoteControlEnabled: true }) }));
+vi.mock('../providerShareApi.js', () => ({
+ providerShareOwnerKey: () => state.scope,
+ providerShareApi: { listOwned: async () => state.owned },
+}));
+
+type Host = typeof import('../providerShareHost');
+let dir: string;
+let host: Host;
+let windows: typeof import('../providerShareApprovalWindows');
+const events = () => ({ changed: vi.fn(), requested: vi.fn(), watchedRequested: vi.fn(), revoked: vi.fn(), reconcile: vi.fn() });
+const request = { requestId: 'request-1', displayName: 'Guest', avatarUrl: null, region: 'global' as const,
+ pairingCode: '0123', createdAt: '2026-10-15T08:00:00Z', expiresAt: '2026-10-16T08:00:00Z' };
+const LINK_A = 'a'.repeat(64);
+const LINK_B = 'b'.repeat(64);
+const LINK_C = 'c'.repeat(64);
+const ownedShare = { shareId: 'share-1', providerId: 'anthropic', providerLabel: 'Anthropic', hostDeviceId: 'host-device',
+ createdAt: '2026-10-15T08:00:00Z', members: [], requests: [request] };
+const filePath = () => path.join(dir, state.scope, 'provider-share-approval-windows.json');
+const assertCurrent = () => { if (state.boundaryPending) throw new Error('account boundary'); };
+
+async function loadProcess() {
+ vi.resetModules();
+ windows = await import('../providerShareApprovalWindows');
+ windows.configureProviderShareApprovalWindows({ filePath, scopeKey: () => state.scope });
+ host = await import('../providerShareHost');
+}
+
+beforeEach(async () => {
+ dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-share-approval-window-'));
+ state.scope = 'owner-a';
+ state.boundaryPending = false;
+ state.owned = [];
+ clipboard.remember.mockReset();
+ vi.useFakeTimers({ toFake: ['Date'] });
+ vi.setSystemTime(new Date('2026-10-15T08:00:00Z'));
+ await loadProcess();
+});
+
+afterEach(() => {
+ host.stopProviderShareHost();
+ windows.configureProviderShareApprovalWindows(null);
+ vi.useRealTimers();
+ vi.restoreAllMocks();
+ fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe('approval ownership across a complete application restart', () => {
+ it('retains separate remote-link quiet windows when a local link is created, including after restart', async () => {
+ host.startProviderShareHost(events());
+ await host.quietProviderShareRequests('anthropic', LINK_A);
+ await host.quietProviderShareRequests('anthropic', LINK_C);
+ await host.clearProviderShareRequestQuiet('anthropic');
+ host.stopProviderShareHost();
+ await loadProcess();
+ const requests = [LINK_A, LINK_B, LINK_C].map((linkId, i) => ({ ...request, requestId: `request-${i}`, linkId }));
+ state.owned = [{ ...ownedShare, requests }];
+ const ev = events();
+ host.startProviderShareHost(ev);
+ await host.refreshProviderShareHost('local-link-after-restart');
+ expect(ev.requested.mock.calls.map(([item, , quiet]) => [item.linkId, quiet])).toEqual([
+ [LINK_A, true], [LINK_B, false], [LINK_C, true],
+ ]);
+ });
+
+ it('restores multiple watches for one supplier without claiming a third computer link', async () => {
+ host.startProviderShareHost(events());
+ await host.watchProviderShareRequests('group-host', 'anthropic', LINK_A, async () => []);
+ await host.watchProviderShareRequests('group-host', 'anthropic', LINK_B, async () => []);
+ host.stopProviderShareHost();
+ await loadProcess();
+ const requests = [LINK_A, LINK_B, LINK_C].map((linkId, i) => ({ ...request, requestId: `request-${i}`, linkId }));
+ const ev = events();
+ host.startProviderShareHost(ev, { readWatchedShares: async () => [{ ...ownedShare, hostDeviceId: 'group-host', requests }] });
+ await host.refreshProviderShareHost('multiple-link-restart');
+ expect(ev.watchedRequested.mock.calls.map(([item]) => item.request.linkId)).toEqual([LINK_A, LINK_B]);
+ await host.refreshProviderShareHost('same-snapshot');
+ expect(ev.watchedRequested).toHaveBeenCalledTimes(2);
+ });
+
+ it('does not let a restored legacy watch claim an identified request', async () => {
+ host.startProviderShareHost(events());
+ await host.watchProviderShareRequests('group-host', 'anthropic', async () => []);
+ host.stopProviderShareHost();
+ await loadProcess();
+ const ev = events();
+ host.startProviderShareHost(ev, { readWatchedShares: async () => [{ ...ownedShare, requests: [{ ...request, linkId: LINK_B }] }] });
+ await host.refreshProviderShareHost('legacy-watch-new-link');
+ expect(ev.watchedRequested).not.toHaveBeenCalled();
+ });
+
+ it('expires exact ownership and isolates it from another account', async () => {
+ host.startProviderShareHost(events());
+ await host.quietProviderShareRequests('anthropic', LINK_A);
+ await host.watchProviderShareRequests('group-host', 'anthropic', LINK_A, async () => []);
+ host.stopProviderShareHost();
+ await loadProcess();
+ const identified = { ...request, linkId: LINK_A };
+ state.owned = [{ ...ownedShare, requests: [identified] }];
+ state.scope = 'owner-b';
+ const other = events();
+ const readWatchedShares = vi.fn(async () => [{ ...ownedShare, requests: [identified] }]);
+ host.startProviderShareHost(other, { readWatchedShares });
+ await host.refreshProviderShareHost('other-account-exact');
+ expect(other.requested).toHaveBeenCalledWith(identified, expect.anything(), false);
+ expect(readWatchedShares).not.toHaveBeenCalled();
+ host.stopProviderShareHost();
+ state.scope = 'owner-a';
+ vi.setSystemTime(Date.now() + windows.PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS + 1);
+ const expired = events();
+ host.startProviderShareHost(expired, { readWatchedShares });
+ await host.refreshProviderShareHost('expired-exact');
+ expect(expired.requested).toHaveBeenCalledWith(identified, expect.anything(), false);
+ expect(readWatchedShares).not.toHaveBeenCalled();
+ expect(windows.readProviderShareApprovalWindows()).toEqual({ quietUntil: {}, watches: [] });
+ });
+
+ it('routes watched requests only to the exact link that was generated here', async () => {
+ const watched = events();
+ const remote = { ...ownedShare, hostDeviceId: 'group-host', requests: [{ ...request, requestId: 'request-b', linkId: LINK_B }] };
+ host.startProviderShareHost(watched);
+ await host.watchProviderShareRequests('group-host', 'anthropic', LINK_A, async () => [remote]);
+ await host.refreshProviderShareHost('exact-link');
+ expect(watched.watchedRequested).not.toHaveBeenCalled();
+
+ const matching = { ...remote, requests: [{ ...request, requestId: 'request-a', linkId: LINK_A }] };
+ await host.watchProviderShareRequests('group-host', 'anthropic', LINK_A, async () => [matching]);
+ await host.refreshProviderShareHost('exact-link-match');
+ expect(watched.watchedRequested).toHaveBeenCalledWith(expect.objectContaining({ request: expect.objectContaining({ linkId: LINK_A }) }));
+ });
+
+ it('keeps the supplier computer quiet before its first snapshot after restart', async () => {
+ host.startProviderShareHost(events());
+ await host.quietProviderShareRequests('anthropic');
+ host.stopProviderShareHost();
+ await loadProcess(); // 丢掉模块内存,模拟完整 Electron 主进程重启。
+ state.owned = [ownedShare];
+ const ev = events();
+ host.startProviderShareHost(ev);
+ await host.refreshProviderShareHost('restart');
+ expect(ev.requested).toHaveBeenCalledWith(request, expect.anything(), true);
+ });
+
+ it('rebuilds the generating computer reader and continues polling after restart', async () => {
+ host.startProviderShareHost(events());
+ await host.watchProviderShareRequests('group-host', 'anthropic', async () => []);
+ host.stopProviderShareHost();
+ await loadProcess();
+ const readWatchedShares = vi.fn(async () => [{ ...ownedShare, hostDeviceId: 'group-host' }]);
+ const ev = events();
+ host.startProviderShareHost(ev, { readWatchedShares });
+ await host.refreshProviderShareHost('restart');
+ expect(readWatchedShares).toHaveBeenCalledWith('group-host');
+ expect(ev.watchedRequested).toHaveBeenCalledWith(expect.objectContaining({ request, hostDeviceId: 'group-host' }));
+ expect(host.getProviderShareHostSnapshot()).toEqual([]);
+ });
+
+ it('does not restore an expired quiet window', async () => {
+ host.startProviderShareHost(events());
+ await host.quietProviderShareRequests('anthropic');
+ host.stopProviderShareHost();
+ vi.setSystemTime(Date.now() + windows.PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS + 1);
+ await loadProcess();
+ state.owned = [ownedShare];
+ const ev = events();
+ host.startProviderShareHost(ev);
+ await host.refreshProviderShareHost('expired');
+ expect(ev.requested).toHaveBeenCalledWith(request, expect.anything(), false);
+ });
+
+ it('persists a local link clearing the previous quiet window', async () => {
+ host.startProviderShareHost(events());
+ await host.quietProviderShareRequests('anthropic');
+ await host.clearProviderShareRequestQuiet('anthropic');
+ host.stopProviderShareHost();
+ await loadProcess();
+ state.owned = [ownedShare];
+ const ev = events();
+ host.startProviderShareHost(ev);
+ await host.refreshProviderShareHost('local-link');
+ expect(ev.requested).toHaveBeenCalledWith(request, expect.anything(), false);
+ });
+
+ it('does not read another account ownership and restores it after switching back', async () => {
+ host.startProviderShareHost(events());
+ await host.quietProviderShareRequests('anthropic');
+ host.stopProviderShareHost();
+ await loadProcess();
+ state.scope = 'owner-b';
+ state.owned = [ownedShare];
+ const other = events();
+ host.startProviderShareHost(other);
+ await host.refreshProviderShareHost('other-account');
+ expect(other.requested).toHaveBeenCalledWith(request, expect.anything(), false);
+ host.stopProviderShareHost();
+ state.scope = 'owner-a';
+ const original = events();
+ host.startProviderShareHost(original);
+ await host.refreshProviderShareHost('original-account');
+ expect(original.requested).toHaveBeenCalledWith(request, expect.anything(), true);
+ });
+});
+
+describe('approval ownership storage', () => {
+ it.each(['quiet', 'clear', 'watch'] as const)('rejects %s setup after the runtime stops without changing stored ownership', async (action) => {
+ host.startProviderShareHost(events());
+ if (action === 'clear') await host.quietProviderShareRequests('anthropic');
+ host.stopProviderShareHost();
+ const original = fs.existsSync(filePath()) ? fs.readFileSync(filePath(), 'utf8') : null;
+ const setup = action === 'quiet' ? host.quietProviderShareRequests('anthropic')
+ : action === 'clear' ? host.clearProviderShareRequestQuiet('anthropic')
+ : host.watchProviderShareRequests('group-host', 'anthropic', async () => []);
+ await expect(setup).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(fs.existsSync(filePath()) ? fs.readFileSync(filePath(), 'utf8') : null).toBe(original);
+ });
+
+ it('does not expose a remote link when its reply arrives after the approval runtime stops', async () => {
+ const { invokeProviderManagement } = await import('../../provider-group/managementClient');
+ host.startProviderShareHost(events());
+ const invoke = vi.fn(async () => {
+ host.stopProviderShareHost(); // 回包已到,账号没变,但设备互联的 runtime 已被停止。
+ return { ok: true as const, result: {
+ result: { link: 'https://cindy.app/s#test', linkId: LINK_A, expiresAt: new Date(Date.now() + 60_000).toISOString() },
+ respondedAt: Date.now(),
+ } };
+ });
+ await expect(invokeProviderManagement(invoke, 'group-host', {
+ action: 'manage-share', command: { action: 'create-link', providerId: 'anthropic' },
+ })).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(clipboard.remember).not.toHaveBeenCalled();
+ expect(fs.existsSync(filePath())).toBe(false);
+ expect(invoke).toHaveBeenCalledTimes(1);
+ });
+
+ it('keeps both sides of concurrently saved windows without storing link or person details', async () => {
+ const until = Date.now() + windows.PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS;
+ await Promise.all([
+ windows.updateProviderShareApprovalWindows((current) => ({ ...current, quietUntil: { ...current.quietUntil, anthropic: until } }), assertCurrent),
+ windows.updateProviderShareApprovalWindows((current) => ({ ...current, watches: [{ hostDeviceId: 'group-host', providerId: 'openai', until }] }), assertCurrent),
+ ]);
+ const stored = JSON.parse(fs.readFileSync(filePath(), 'utf8'));
+ expect(stored).toEqual({ quietUntil: { anthropic: until }, watches: [{ hostDeviceId: 'group-host', providerId: 'openai', until }] });
+ });
+
+ it('preserves a corrupt file instead of overwriting it', async () => {
+ fs.mkdirSync(path.dirname(filePath()), { recursive: true });
+ fs.writeFileSync(filePath(), '{broken');
+ await expect(windows.updateProviderShareApprovalWindows((current) => current, assertCurrent)).rejects.toThrow();
+ expect(fs.readFileSync(filePath(), 'utf8')).toBe('{broken');
+ });
+
+ it('rejects a save at an account boundary without creating a file', async () => {
+ state.boundaryPending = true;
+ await expect(windows.updateProviderShareApprovalWindows((current) => current, assertCurrent)).rejects.toThrow('account boundary');
+ expect(fs.existsSync(filePath())).toBe(false);
+ });
+
+ it('does not commit to either account after switching while waiting for the lock', async () => {
+ const originalFile = filePath();
+ const until = Date.now() + windows.PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS;
+ const save = windows.updateProviderShareApprovalWindows((current) => ({ ...current, quietUntil: { anthropic: until } }), assertCurrent);
+ state.scope = 'owner-b';
+ await expect(save).rejects.toThrow('Could not save provider share approval ownership');
+ expect(fs.existsSync(originalFile)).toBe(false);
+ expect(fs.existsSync(filePath())).toBe(false);
+ });
+
+ it('retains the previous disk state when atomic replacement fails', async () => {
+ const until = Date.now() + windows.PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS;
+ await windows.updateProviderShareApprovalWindows((current) => ({ ...current, quietUntil: { anthropic: until } }), assertCurrent);
+ const original = fs.readFileSync(filePath(), 'utf8');
+ const rename = fs.renameSync;
+ vi.spyOn(fs, 'renameSync').mockImplementation((source, target) => {
+ if (target === filePath()) throw Object.assign(new Error('disk write failed'), { code: 'EIO' });
+ return rename(source, target);
+ });
+ await expect(windows.updateProviderShareApprovalWindows((current) => ({
+ ...current, quietUntil: { ...current.quietUntil, openai: until },
+ }), assertCurrent)).rejects.toThrow('Could not save provider share approval ownership');
+ expect(fs.readFileSync(filePath(), 'utf8')).toBe(original);
+ });
+
+ it('keeps the active quiet window when clearing it fails to persist', async () => {
+ host.startProviderShareHost(events());
+ await host.quietProviderShareRequests('anthropic');
+ const rename = fs.renameSync;
+ vi.spyOn(fs, 'renameSync').mockImplementation((source, target) => {
+ if (target === filePath()) throw Object.assign(new Error('private path must not escape'), { code: 'EIO' });
+ return rename(source, target);
+ });
+ await expect(host.clearProviderShareRequestQuiet('anthropic')).rejects.toThrow('Could not save provider share approval ownership');
+ state.owned = [ownedShare];
+ await host.refreshProviderShareHost('save-failed');
+ expect(host.getProviderShareQuietRequestIds()).toEqual(['request-1']);
+ });
+});
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareGuestPrefs.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareGuestPrefs.test.ts
index 0c5b803342..d52cb52bf4 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareGuestPrefs.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareGuestPrefs.test.ts
@@ -298,6 +298,130 @@ describe('provider share guest prefs', () => {
expect(Object.keys(stored().shares)).toEqual(['kept']);
expect(isProviderShareCredentialConsentSkipped('share-1')).toBe(false);
});
+ it('does not enable trust in memory when the durable write fails', async () => {
+ fs.mkdirSync(file(), { recursive: true });
+
+ await expect(setProviderShareCredentialConsent('write-fails', 'global', true)).rejects.toThrow();
+ expect(isProviderShareCredentialConsentSkipped('write-fails')).toBe(false);
+
+ fs.rmdirSync(file());
+ await setProviderShareCredentialConsent('write-fails', 'global', true);
+ expect(isProviderShareCredentialConsentSkipped('write-fails')).toBe(true);
+ });
+
+ it('serializes concurrent settings without losing another share or retaining a failed enable', async () => {
+ await Promise.all([
+ setProviderShareCredentialConsent('first', 'global', true),
+ setProviderShareCredentialConsent('second', 'cn', true),
+ ]);
+ expect(Object.keys(stored().shares).sort()).toEqual(['first', 'second']);
+
+ // 真正的 rename 失败,随后排队的写入仍应成功,不能把失败的启用一起保存。
+ const rename = fsp.rename;
+ const blocker = path.join(root, 'rename-blocker');
+ fs.mkdirSync(blocker);
+ fs.writeFileSync(path.join(blocker, 'keep'), 'not a preferences file');
+ vi.spyOn(fsp, 'rename').mockImplementationOnce((source) => rename(source, blocker));
+ const [failed, saved] = await Promise.allSettled([
+ setProviderShareCredentialConsent('failed', 'global', true),
+ setProviderShareCredentialConsent('third', 'global', true),
+ ]);
+ expect(failed.status).toBe('rejected');
+ expect(saved.status).toBe('fulfilled');
+ expect(isProviderShareCredentialConsentSkipped('failed')).toBe(false);
+ expect(Object.keys(stored().shares).sort()).toEqual(['first', 'second', 'third']);
+ restart();
+ expect(isProviderShareCredentialConsentSkipped('failed')).toBe(false);
+ expect(isProviderShareCredentialConsentSkipped('third')).toBe(true);
+ });
+
+ it.each(['leave', 'prune', 'prune-other'] as const)('does not revive removed trust when %s runs during an in-flight save', async (cleanup) => {
+ await setProviderShareCredentialConsent('already-trusted', 'global', true);
+ let release!: () => void;
+ let entered!: () => void;
+ const held = new Promise<void>((resolve) => { release = resolve; });
+ const started = new Promise<void>((resolve) => { entered = resolve; });
+ const rename = fsp.rename;
+ vi.spyOn(fsp, 'rename').mockImplementationOnce(async (...args) => {
+ entered();
+ await held;
+ return rename(...args);
+ });
+ const save = setProviderShareCredentialConsent('pending', 'global', true);
+ try {
+ await started;
+ expect(isProviderShareCredentialConsentSkipped('pending')).toBe(false);
+ if (cleanup === 'leave') {
+ forgetProviderShareGuestPrefs('pending');
+ forgetProviderShareGuestPrefs('already-trusted');
+ } else {
+ pruneProviderShareGuestPrefs(new Set(cleanup === 'prune-other' ? ['pending'] : []), ['global']);
+ }
+ expect(isProviderShareCredentialConsentSkipped('already-trusted')).toBe(false);
+ expect(isProviderShareCredentialConsentSkipped('pending')).toBe(false);
+ } finally {
+ release();
+ await save;
+ await flushProviderShareGuestPrefs();
+ }
+ expect(stored().shares).toEqual(cleanup === 'prune-other'
+ ? { pending: { region: 'global', skipCredentialConsent: true } }
+ : {});
+ restart();
+ expect(isProviderShareCredentialConsentSkipped('pending')).toBe(cleanup === 'prune-other');
+ expect(isProviderShareCredentialConsentSkipped('already-trusted')).toBe(false);
+ });
+
+ it('keeps concurrent account writes isolated even when switching back before they finish', async () => {
+ const accountA = setProviderShareCredentialConsent('only-a', 'global', true);
+ owner = 'account-b';
+ const accountB = setProviderShareCredentialConsent('only-b', 'global', true);
+ owner = 'account-a';
+ const accountAAgain = setProviderShareCredentialConsent('also-a', 'cn', true);
+ await Promise.all([accountA, accountB, accountAAgain]);
+ expect(Object.keys(stored().shares).sort()).toEqual(['also-a', 'only-a']);
+ expect(isProviderShareCredentialConsentSkipped('only-a')).toBe(true);
+ expect(isProviderShareCredentialConsentSkipped('also-a')).toBe(true);
+ expect(isProviderShareCredentialConsentSkipped('only-b')).toBe(false);
+ owner = 'account-b';
+ expect(Object.keys(stored().shares)).toEqual(['only-b']);
+ expect(isProviderShareCredentialConsentSkipped('only-b')).toBe(true);
+ expect(isProviderShareCredentialConsentSkipped('only-a')).toBe(false);
+ });
+
+ it.each(['leave', 'prune'] as const)('keeps revoked trust disabled when %s cleanup cannot be saved', async (cleanup) => {
+ await setProviderShareCredentialConsent('removed', 'global', true);
+ vi.spyOn(fsp, 'rename').mockRejectedValueOnce(new Error('disk unavailable'));
+ if (cleanup === 'leave') {
+ await expect(forgetProviderShareGuestPrefs('removed')).rejects.toThrow('disk unavailable');
+ } else {
+ await pruneProviderShareGuestPrefs(new Set(), ['global']);
+ }
+ expect(isProviderShareCredentialConsentSkipped('removed')).toBe(false);
+
+ // 缓存重读及别的分享保存都不能把已退出分享的旧磁盘授权重新发布。
+ invalidateProviderShareGuestPrefsCache();
+ await setProviderShareCredentialConsent('other', 'cn', true);
+ expect(isProviderShareCredentialConsentSkipped('removed')).toBe(false);
+ expect(isProviderShareCredentialConsentSkipped('other')).toBe(true);
+
+ // 只有新的显式信任操作成功后才可以恢复。
+ await setProviderShareCredentialConsent('removed', 'global', true);
+ expect(isProviderShareCredentialConsentSkipped('removed')).toBe(true);
+ });
+
+ it('retains the previous setting when disabling trust fails to save', async () => {
+ await setProviderShareCredentialConsent('trusted', 'global', true);
+ const rename = fsp.rename;
+ const blocker = path.join(root, 'disable-blocker');
+ fs.mkdirSync(blocker);
+ fs.writeFileSync(path.join(blocker, 'keep'), 'not a preferences file');
+ vi.spyOn(fsp, 'rename').mockImplementationOnce((source) => rename(source, blocker));
+ await expect(setProviderShareCredentialConsent('trusted', 'global', false)).rejects.toThrow();
+ expect(isProviderShareCredentialConsentSkipped('trusted')).toBe(true);
+ restart();
+ expect(isProviderShareCredentialConsentSkipped('trusted')).toBe(true);
+ });
});
describe('provider share guest prefs IPC boundary', () => {
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts
new file mode 100644
index 0000000000..44574302a1
--- /dev/null
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts
@@ -0,0 +1,183 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ipcMain } from 'electron';
+
+import type { ProviderShareManagementCommand } from '../../../shared/providerManagement';
+
+const state = vi.hoisted(() => ({ owner: 'owner-a', boundaryPending: false }));
+const api = vi.hoisted(() => ({ createLink: vi.fn(), approve: vi.fn(), reject: vi.fn(), setMember: vi.fn() }));
+const host = vi.hoisted(() => ({
+ refresh: vi.fn(), snapshot: vi.fn(), quiet: vi.fn(), active: vi.fn(), decision: vi.fn(), member: vi.fn(),
+}));
+const listProviders = vi.hoisted(() => vi.fn());
+const identityCard = vi.hoisted(() => vi.fn());
+const remember = vi.hoisted(() => vi.fn());
+
+vi.mock('../../appSessionState.js', () => ({
+ activeOwnerScopeKey: () => state.owner,
+ isAppSessionBoundaryPending: () => state.boundaryPending,
+}));
+vi.mock('../../authManager.js', () => ({ getDeviceId: () => 'host-device' }));
+vi.mock('../../i18n.js', () => ({ t: (key: string) => key }));
+vi.mock('../../logger.js', () => ({ createLogger: () => ({ warn: vi.fn() }) }));
+vi.mock('../../maker-host/createDesktopProviderService.js', () => ({
+ getDesktopProviderService: () => ({ listProviders }),
+}));
+vi.mock('../../maker-host/remote-provider-access-store.js', () => ({ isRemoteProviderInvocationAllowed: () => true }));
+vi.mock('../../textClipboard.js', () => ({ rememberIssuedClipboardText: remember }));
+vi.mock('../../security/trustedAppRenderer.js', () => ({ assertTrustedAppRendererEvent: vi.fn() }));
+vi.mock('../../usage/ledgerCurrency.js', () => ({ currentLedgerCurrency: vi.fn() }));
+vi.mock('../../usage/modelPricing.js', () => ({ getGatewayModelPricing: vi.fn(), getModelPriceQuote: vi.fn() }));
+vi.mock('../../usage/turnCostCalculator.js', () => ({ computePriceQuoteTurnMoney: vi.fn(), normalizeModelIdForPricing: vi.fn() }));
+vi.mock('../../usage/providerPartyUsageStore.js', () => ({ currentProviderPartyUsageStore: vi.fn() }));
+vi.mock('../providerShareUsageStore.js', () => ({ getProviderShareUsageStore: vi.fn() }));
+vi.mock('../settings-store.js', () => ({ readDeviceLinkSettings: () => ({ remoteControlEnabled: true }), readLastKnownDeviceNames: vi.fn() }));
+vi.mock('../providerShareApi.js', () => ({
+ providerShareApi: api,
+ fetchIdentityCard: identityCard,
+ sha256Hex: (value: string) => value,
+ providerShareLinkFor: () => 'https://cindy.app/s#test-link',
+}));
+vi.mock('../dispatch.js', () => ({
+ getControllerDisplayName: vi.fn(), providerShareActiveControllers: vi.fn(),
+ revokeProviderShareControllers: vi.fn(), setProviderShareAccess: vi.fn(),
+}));
+vi.mock('../providerShareHost.js', () => ({
+ startProviderShareHost: vi.fn(), stopProviderShareHost: vi.fn(),
+ refreshProviderShareHost: host.refresh, getProviderShareHostSnapshot: host.snapshot,
+ clearProviderShareRequestQuiet: vi.fn(),
+ providerShareGuestAccess: vi.fn(), providerShareGuestDenial: vi.fn(), ensureProviderSharePeerKnown: vi.fn(),
+ quietProviderShareRequests: host.quiet, markProviderShareHostActive: host.active,
+ applyLocalRequestDecision: host.decision, applyLocalMemberChange: host.member,
+}));
+vi.mock('../providerShareGuest.js', () => ({ startProviderShareGuest: vi.fn(), stopProviderShareGuest: vi.fn() }));
+vi.mock('../providerShareGuestPrefs.js', () => ({ configureProviderShareGuestPrefs: vi.fn(), invalidateProviderShareGuestPrefsCache: vi.fn() }));
+vi.mock('../providerShareGuestPrefsIpc.js', () => ({ setProviderShareCredentialConsentFromIpc: vi.fn() }));
+
+import { executeProviderShareManagementCommand, registerProviderShareIpc, startProviderShareRuntime, stopProviderShareRuntime } from '../providerShareRuntime';
+
+const createLink: ProviderShareManagementCommand = { action: 'create-link', providerId: 'anthropic' };
+const LINK_ID = 'a'.repeat(64);
+const mutations: ProviderShareManagementCommand[] = [
+ { action: 'approve', requestId: 'r1' },
+ { action: 'reject', requestId: 'r1' },
+ { action: 'set-member', memberId: 'm1', status: 'remove' },
+];
+
+beforeEach(() => {
+ vi.resetAllMocks();
+ state.owner = 'owner-a';
+ state.boundaryPending = false;
+ listProviders.mockResolvedValue([{ id: 'anthropic', name: 'Anthropic', connected: true, agents: ['claude-code'] }]);
+ identityCard.mockResolvedValue({ card: 'test-identity-card' });
+ api.createLink.mockResolvedValue({ invitation: 'test-invitation', linkId: LINK_ID });
+ api.approve.mockResolvedValue({ ok: true });
+ api.reject.mockResolvedValue({ ok: true });
+ api.setMember.mockResolvedValue({ status: 'removed' });
+ host.refresh.mockResolvedValue(undefined);
+ host.snapshot.mockReturnValue([{ requests: [{ requestId: 'r1' }], members: [{ memberId: 'm1' }] }]);
+ startProviderShareRuntime(vi.fn());
+});
+
+afterEach(() => stopProviderShareRuntime());
+
+describe('same-account share management during account transitions', () => {
+ it.each([
+ createLink, ...mutations,
+ { action: 'owned', range: '7d' },
+ { action: 'own-usage', providerId: 'anthropic', range: '7d' },
+ ] satisfies ProviderShareManagementCommand[])('refuses $action at entry while teardown is pending', async (command) => {
+ state.boundaryPending = true;
+ await expect(executeProviderShareManagementCommand(command)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(listProviders).not.toHaveBeenCalled();
+ expect(host.refresh).not.toHaveBeenCalled();
+ expect(api.createLink).not.toHaveBeenCalled();
+ expect(api.approve).not.toHaveBeenCalled();
+ expect(api.reject).not.toHaveBeenCalled();
+ expect(api.setMember).not.toHaveBeenCalled();
+ });
+
+ it.each(mutations)('does not submit $action when teardown begins during membership refresh', async (command) => {
+ host.refresh.mockImplementationOnce(async () => { state.boundaryPending = true; });
+ await expect(executeProviderShareManagementCommand(command)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(api.approve).not.toHaveBeenCalled();
+ expect(api.reject).not.toHaveBeenCalled();
+ expect(api.setMember).not.toHaveBeenCalled();
+ });
+
+ it.each(['provider lookup', 'identity card', 'link response'])('stops link creation when teardown begins during %s', async (stage) => {
+ if (stage === 'provider lookup') listProviders.mockImplementationOnce(async () => { state.boundaryPending = true; return []; });
+ if (stage === 'identity card') identityCard.mockImplementationOnce(async () => { state.boundaryPending = true; return {}; });
+ if (stage === 'link response') api.createLink.mockImplementationOnce(async () => { state.boundaryPending = true; return {}; });
+ await expect(executeProviderShareManagementCommand(createLink)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(identityCard).toHaveBeenCalledTimes(stage === 'provider lookup' ? 0 : 1);
+ expect(api.createLink).toHaveBeenCalledTimes(stage === 'link response' ? 1 : 0);
+ expect(host.active).not.toHaveBeenCalled();
+ expect(host.refresh).not.toHaveBeenCalled();
+ expect(host.quiet).not.toHaveBeenCalled();
+ expect(remember).not.toHaveBeenCalled();
+ });
+
+ it.each(mutations)('discards a late $action result before changing local approval or membership state', async (command) => {
+ const changeBoundary = async () => { state.boundaryPending = true; return { status: 'removed' }; };
+ api.approve.mockImplementationOnce(changeBoundary);
+ api.reject.mockImplementationOnce(changeBoundary);
+ api.setMember.mockImplementationOnce(changeBoundary);
+ await expect(executeProviderShareManagementCommand(command)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(host.decision).not.toHaveBeenCalled();
+ expect(host.member).not.toHaveBeenCalled();
+ expect(host.refresh).toHaveBeenCalledExactlyOnceWith('management');
+ });
+
+ it('also discards a link response after a committed account switch', async () => {
+ api.createLink.mockImplementationOnce(async () => { state.owner = 'owner-b'; return {}; });
+ await expect(executeProviderShareManagementCommand(createLink)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(host.quiet).not.toHaveBeenCalled();
+ expect(remember).not.toHaveBeenCalled();
+ });
+
+ it.each(mutations)('executes $action once and updates local state when the account is stable', async (command) => {
+ await expect(executeProviderShareManagementCommand(command)).resolves.toEqual({ ok: true });
+ if (command.action === 'set-member') {
+ expect(api.setMember).toHaveBeenCalledExactlyOnceWith('m1', 'remove');
+ expect(host.member).toHaveBeenCalledExactlyOnceWith('m1', 'removed');
+ } else if (command.action === 'approve' || command.action === 'reject') {
+ expect(api[command.action]).toHaveBeenCalledExactlyOnceWith('r1');
+ expect(host.decision).toHaveBeenCalledExactlyOnceWith('r1');
+ }
+ });
+
+ it('creates and registers a link when the account is stable', async () => {
+ await expect(executeProviderShareManagementCommand(createLink)).resolves.toMatchObject({ link: 'https://cindy.app/s#test-link', linkId: LINK_ID });
+ expect(api.createLink).toHaveBeenCalledTimes(1);
+ expect(host.quiet).toHaveBeenCalledExactlyOnceWith('anthropic', LINK_ID);
+ expect(remember).toHaveBeenCalledExactlyOnceWith('https://cindy.app/s#test-link', expect.any(String));
+ });
+
+ it('rejects an old server before exposing or registering a remote link', async () => {
+ api.createLink.mockResolvedValueOnce({ invitation: 'test-invitation' });
+ await expect(executeProviderShareManagementCommand(createLink)).rejects.toThrow(/UNSUPPORTED_CAPABILITY/);
+ expect(host.quiet).not.toHaveBeenCalled();
+ expect(host.active).not.toHaveBeenCalled();
+ expect(remember).not.toHaveBeenCalled();
+ });
+
+ it('still creates local share links with an old server', async () => {
+ api.createLink.mockResolvedValueOnce({ invitation: 'test-invitation' });
+ const handle = vi.spyOn(ipcMain, 'handle');
+ try {
+ registerProviderShareIpc();
+ const handler = handle.mock.calls.find(([channel]) => channel === 'provider-share:command')![1];
+ await expect(handler({} as Electron.IpcMainInvokeEvent, createLink)).resolves.toMatchObject({ link: 'https://cindy.app/s#test-link' });
+ expect(host.quiet).not.toHaveBeenCalled();
+ expect(remember).toHaveBeenCalledTimes(1);
+ } finally {
+ handle.mockRestore();
+ }
+ });
+
+ it('does not register a link when saving its host ownership fails', async () => {
+ host.quiet.mockRejectedValueOnce(new Error('ownership save failed'));
+ await expect(executeProviderShareManagementCommand(createLink)).rejects.toThrow('ownership save failed');
+ expect(remember).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareReshare.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareReshare.test.ts
index 5dc545ef26..ffe0460e00 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareReshare.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareReshare.test.ts
@@ -44,6 +44,19 @@ beforeEach(async () => {
});
describe('provider share reshare consent (sharer computer)', () => {
+ it('keeps a reshare pending when account teardown begins while waiting for the decision write lock', async () => {
+ await reshare.handleProviderShareReshare(B_GROUP, [{ key: CAROL, name: 'Carol' }]);
+ const record = reshare.listProviderShareReshares()[0]!;
+ let current = true;
+ const pending = reshare.decideProviderShareReshare(record.id, 'approve', Date.now(), () => {
+ if (!current) throw new Error('[PRECONDITION_FAILED] The account changed');
+ });
+ current = false;
+ await expect(pending).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(reshare.listProviderShareReshares()[0]).toEqual(record);
+ expect(reshare.providerShareReshareAllows(B_GROUP, CAROL)).toBe(false);
+ });
+
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() });
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareRuntime.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareRuntime.test.ts
index 275370578c..3d1ed7744e 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareRuntime.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareRuntime.test.ts
@@ -16,6 +16,8 @@ const state = vi.hoisted(() => ({
remoteControl: true,
allowed: new Set<string>(['anthropic']),
owned: [] as ProviderShareOwned[],
+ ownedError: false,
+ remoteOwned: [] as ProviderShareOwned[],
received: [] as ProviderShareReceived[],
receivedError: false,
boundaryPending: false,
@@ -39,7 +41,10 @@ vi.mock('../../maker-host/remote-provider-access-store.js', () => ({
vi.mock('../settings-store.js', () => ({ readDeviceLinkSettings: () => ({ remoteControlEnabled: state.remoteControl }) }));
vi.mock('../providerShareApi.js', () => ({
providerShareApi: {
- listOwned: async () => state.owned,
+ listOwned: async () => {
+ if (state.ownedError) throw new Error('offline');
+ return state.owned;
+ },
listReceived: async () => {
if (state.receivedError) throw new Error('offline');
return state.received;
@@ -62,12 +67,20 @@ import { crossRegionLeave } from '../providerShareCrossRegion';
import {
applyLocalMemberChange,
+ clearProviderShareRequestQuiet,
+ forgetWatchedProviderShareRequest,
+ getProviderShareHostSnapshot,
+ getProviderShareQuietRequestIds,
+ getProviderShareWatchedRequests,
+ PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS,
providerShareGuestAccess,
providerShareGuestDenial,
providerShareMemberMatcher,
+ quietProviderShareRequests,
refreshProviderShareHost,
startProviderShareHost,
stopProviderShareHost,
+ watchProviderShareRequests,
} from '../providerShareHost';
import {
isProviderShareRefusal,
@@ -98,8 +111,16 @@ const member = (memberId: string, status: 'active' | 'paused' = 'active') => ({
const guest = (memberId: string, device = 'laptop') => providerShareGuestPeer('share-1', memberId, device);
function events() {
- return { changed: vi.fn(), requested: vi.fn(), revoked: vi.fn(), reconcile: vi.fn() };
+ return { changed: vi.fn(), requested: vi.fn(), watchedRequested: vi.fn(), revoked: vi.fn(), reconcile: vi.fn() };
}
+const pendingRequest = (requestId: string) => ({ ...person, requestId, pairingCode: '0427', createdAt: 'x', expiresAt: 'y' });
+const otherShare = (requests: ProviderShareOwned['requests'], providerId = 'anthropic'): ProviderShareOwned => ({
+ shareId: `share-${providerId}-group`, providerId, providerLabel: 'Anthropic', hostDeviceId: 'group-host',
+ createdAt: '2026-10-01T00:00:00.000Z', members: [member('g1')], requests,
+});
+const readWatchedShares = vi.fn(async (hostDeviceId: string) => state.remoteOwned.filter((item) => item.hostDeviceId === hostDeviceId));
+const watchShare = (hostDeviceId: string, providerId: string) =>
+ watchProviderShareRequests(hostDeviceId, providerId, () => readWatchedShares(hostDeviceId));
beforeEach(() => {
state.authenticated = true;
@@ -107,6 +128,10 @@ beforeEach(() => {
state.remoteControl = true;
state.allowed = new Set(['anthropic']);
state.owned = [];
+ state.ownedError = false;
+ state.remoteOwned = [];
+ readWatchedShares.mockReset().mockImplementation(async (hostDeviceId) =>
+ state.remoteOwned.filter((item) => item.hostDeviceId === hostDeviceId));
state.received = [];
state.receivedError = false;
state.boundaryPending = false;
@@ -170,6 +195,7 @@ describe('provider share host snapshot', () => {
await refreshProviderShareHost('again');
expect(ev.requested).toHaveBeenCalledTimes(1);
expect(ev.requested.mock.calls[0][0]).toEqual(request);
+ expect(ev.requested.mock.calls[0][2]).toBe(false);
expect(ev.reconcile).toHaveBeenCalledTimes(1);
const owned = ev.reconcile.mock.calls[0][0] as Map<string, Set<string>>;
expect([...owned.get('share-1')!]).toEqual(['m1']);
@@ -214,6 +240,277 @@ describe('provider share host purge after pause', () => {
});
});
+// provider-sharing.md §4.1 第 4 步:审批弹窗跟着生成链接的电脑。
+describe('provider share approval follows the computer that generated the link', () => {
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('keeps this computer quiet for requests on a link another computer generated, within the window only', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ state.owned = [share([member('m1')])];
+ const ev = events();
+ startProviderShareHost(ev);
+ await refreshProviderShareHost('test');
+
+ await quietProviderShareRequests('anthropic');
+ state.owned = [share([member('m1')], [pendingRequest('r1')])];
+ await refreshProviderShareHost('remote-link');
+ expect(ev.requested).toHaveBeenLastCalledWith(pendingRequest('r1'), expect.objectContaining({ shareId: 'share-1' }), true);
+ expect(getProviderShareQuietRequestIds()).toEqual(['r1']);
+
+ // 窗口期过后才发现的申请照旧由本机弹。
+ vi.setSystemTime(new Date(Date.now() + PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS + 1));
+ state.owned = [share([member('m1')], [pendingRequest('r1'), pendingRequest('r2')])];
+ await refreshProviderShareHost('late');
+ expect(ev.requested).toHaveBeenLastCalledWith(pendingRequest('r2'), expect.anything(), false);
+
+ // 处理掉的申请不再记作静默。
+ state.owned = [share([member('m1')], [pendingRequest('r2')])];
+ await refreshProviderShareHost('handled');
+ expect(getProviderShareQuietRequestIds()).toEqual([]);
+ });
+
+ it('resumes prompting here once this computer generates its own link', async () => {
+ state.owned = [share([member('m1')])];
+ const ev = events();
+ startProviderShareHost(ev);
+ await refreshProviderShareHost('test');
+ await quietProviderShareRequests('anthropic');
+ await clearProviderShareRequestQuiet('anthropic');
+ state.owned = [share([member('m1')], [pendingRequest('r1')])];
+ await refreshProviderShareHost('local-link');
+ expect(ev.requested).toHaveBeenLastCalledWith(pendingRequest('r1'), expect.anything(), false);
+ expect(getProviderShareQuietRequestIds()).toEqual([]);
+ });
+
+ it('keeps the quiet approval ownership across a host runtime restart', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ state.owned = [share([member('m1')])];
+ const first = events();
+ startProviderShareHost(first);
+ await refreshProviderShareHost('test');
+ await quietProviderShareRequests('anthropic');
+
+ stopProviderShareHost();
+ const restarted = events();
+ startProviderShareHost(restarted);
+ await refreshProviderShareHost('restart');
+ state.owned = [share([member('m1')], [pendingRequest('after-restart')])];
+ await refreshProviderShareHost('after-restart');
+
+ expect(restarted.requested).toHaveBeenLastCalledWith(
+ pendingRequest('after-restart'),
+ expect.objectContaining({ shareId: 'share-1' }),
+ true,
+ );
+ expect(getProviderShareQuietRequestIds()).toEqual(['after-restart']);
+
+ // 不让本测试的短期归属影响后续测试。
+ vi.setSystemTime(new Date(Date.now() + PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS + 1));
+ stopProviderShareHost();
+ });
+
+ it('keeps watched approval ownership and de-duplication across a host runtime restart', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ state.owned = [share([member('m1')])];
+ state.remoteOwned = [otherShare([])];
+ const first = events();
+ startProviderShareHost(first);
+ await refreshProviderShareHost('test');
+ await watchShare('group-host', 'anthropic');
+
+ state.remoteOwned = [otherShare([pendingRequest('before-restart')])];
+ await refreshProviderShareHost('before-restart');
+ expect(first.watchedRequested).toHaveBeenCalledTimes(1);
+
+ stopProviderShareHost();
+ const restarted = events();
+ startProviderShareHost(restarted);
+ await refreshProviderShareHost('restart');
+ expect(restarted.watchedRequested).not.toHaveBeenCalled();
+
+ state.remoteOwned = [otherShare([pendingRequest('before-restart'), pendingRequest('after-restart')])];
+ await refreshProviderShareHost('after-restart');
+ expect(restarted.watchedRequested.mock.calls.map(([item]) => item.request.requestId)).toEqual(['after-restart']);
+
+ // 不让本测试的短期归属影响后续测试。
+ vi.setSystemTime(new Date(Date.now() + PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS + 1));
+ stopProviderShareHost();
+ });
+
+ it('prompts here for a watched share on another computer without letting it into this computer\'s snapshot', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ state.owned = [share([member('m1')])];
+ state.remoteOwned = [otherShare([pendingRequest('w0')]), otherShare([pendingRequest('o1')], 'openai')];
+ const ev = events();
+ startProviderShareHost(ev);
+ await refreshProviderShareHost('test');
+ // 没有生成过链接:别的电脑上的申请这里不弹。
+ expect(ev.watchedRequested).not.toHaveBeenCalled();
+
+ await watchShare('group-host', 'anthropic');
+ state.remoteOwned = [otherShare([pendingRequest('w0'), pendingRequest('w1')]), otherShare([pendingRequest('o1')], 'openai')];
+ await refreshProviderShareHost('watch');
+ await refreshProviderShareHost('again');
+ expect(ev.watchedRequested.mock.calls.map(([item]) => item.request.requestId)).toEqual(['w0', 'w1']);
+ expect(ev.watchedRequested.mock.calls[1][0]).toEqual({
+ request: pendingRequest('w1'),
+ share: { shareId: 'share-anthropic-group', providerId: 'anthropic', providerLabel: 'Anthropic' },
+ hostDeviceId: 'group-host',
+ });
+ // 只用于弹窗:不进本机快照,不放行受邀者。
+ expect(getProviderShareHostSnapshot().map((item) => item.shareId)).toEqual(['share-1']);
+ expect(ev.requested).not.toHaveBeenCalled();
+
+ // 本机处理后立即移除;处理前发出的那次拉取还带着它也不再弹、不再加回。
+ forgetWatchedProviderShareRequest('w1');
+ await refreshProviderShareHost('stale');
+ expect(getProviderShareWatchedRequests().map((item) => item.request.requestId)).toEqual(['w0']);
+ expect(ev.watchedRequested).toHaveBeenCalledTimes(2);
+
+ // 在别处处理、撤回或过期:从快照里消失即移除。
+ state.remoteOwned = [otherShare([])];
+ await refreshProviderShareHost('gone');
+ expect(getProviderShareWatchedRequests()).toEqual([]);
+
+ // 窗口期过后不再关注。
+ vi.setSystemTime(new Date(Date.now() + PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS + 1));
+ state.remoteOwned = [otherShare([pendingRequest('w2')])];
+ await refreshProviderShareHost('late');
+ expect(ev.watchedRequested).toHaveBeenCalledTimes(2);
+ });
+
+ it('continues polling a watched computer after reconnect even when this computer owns no shares', async () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ startProviderShareHost(events());
+ await refreshProviderShareHost('start');
+ await watchShare('group-host', 'anthropic');
+ stopProviderShareHost();
+
+ const restarted = events();
+ startProviderShareHost(restarted);
+ await refreshProviderShareHost('restart');
+ state.remoteOwned = [otherShare([pendingRequest('after-reconnect')])];
+ await vi.advanceTimersByTimeAsync(5_000);
+ expect(restarted.watchedRequested).toHaveBeenCalledWith(expect.objectContaining({
+ request: pendingRequest('after-reconnect'), hostDeviceId: 'group-host',
+ }));
+ expect(getProviderShareHostSnapshot()).toEqual([]);
+ stopProviderShareHost();
+ });
+
+ it('reads watched requests even when the local REST snapshot cannot be fetched', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ const ev = events();
+ startProviderShareHost(ev);
+ await refreshProviderShareHost('start');
+ await watchShare('group-host', 'anthropic');
+ state.ownedError = true;
+ state.remoteOwned = [otherShare([pendingRequest('remote-only')])];
+ await refreshProviderShareHost('local-offline');
+ expect(ev.watchedRequested).toHaveBeenCalledWith(expect.objectContaining({ request: pendingRequest('remote-only') }));
+ });
+
+ it('continues remote polling while a local REST read is still pending', async () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ let finishLocal!: (shares: ProviderShareOwned[]) => void;
+ const localRead = vi.spyOn(providerShareApi, 'listOwned').mockImplementation(() =>
+ new Promise((resolve) => { finishLocal = resolve; }));
+ const ev = events();
+ startProviderShareHost(ev);
+ await watchShare('group-host', 'anthropic');
+ state.remoteOwned = [otherShare([pendingRequest('local-still-pending')])];
+ try {
+ await vi.advanceTimersByTimeAsync(5_000);
+ expect(ev.watchedRequested).toHaveBeenCalledWith(expect.objectContaining({ request: pendingRequest('local-still-pending') }));
+ expect(localRead).toHaveBeenCalledTimes(1);
+ } finally {
+ finishLocal([]);
+ await refreshProviderShareHost('finish-local');
+ localRead.mockRestore();
+ stopProviderShareHost();
+ }
+ });
+
+ it('keeps pending requests on a failed computer while applying successful updates from another computer', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ const ev = events();
+ startProviderShareHost(ev);
+ await refreshProviderShareHost('start');
+ await watchShare('group-host', 'anthropic');
+ await watchShare('another-host', 'anthropic');
+ state.remoteOwned = [
+ otherShare([pendingRequest('keep-offline')]),
+ { ...otherShare([pendingRequest('remove-online')]), hostDeviceId: 'another-host' },
+ ];
+ await refreshProviderShareHost('both-online');
+ readWatchedShares.mockImplementation(async (hostDeviceId) => {
+ if (hostDeviceId === 'group-host') throw new Error('offline');
+ return [{ ...otherShare([pendingRequest('new-online')]), hostDeviceId }];
+ });
+ await refreshProviderShareHost('one-offline');
+ expect(getProviderShareWatchedRequests().map((item) => item.request.requestId).sort()).toEqual(['keep-offline', 'new-online']);
+ });
+
+ it('does not let one pending remote read delay local requests or another watched computer', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ const ev = events();
+ startProviderShareHost(ev);
+ await refreshProviderShareHost('start');
+ await watchShare('group-host', 'anthropic');
+ await watchShare('another-host', 'anthropic');
+ let finishOffline!: (shares: ProviderShareOwned[]) => void;
+ let onlineRequest = 'online';
+ readWatchedShares.mockImplementation((hostDeviceId) => hostDeviceId === 'group-host'
+ ? new Promise((resolve) => { finishOffline = resolve; })
+ : Promise.resolve([{ ...otherShare([pendingRequest(onlineRequest)]), hostDeviceId }]));
+ state.owned = [share([], [pendingRequest('local')])];
+ const refreshing = refreshProviderShareHost('slow-peer');
+ try {
+ await vi.waitFor(() => {
+ expect(ev.requested).toHaveBeenCalledWith(pendingRequest('local'), expect.anything(), false);
+ expect(ev.watchedRequested).toHaveBeenCalledWith(expect.objectContaining({ request: pendingRequest('online') }));
+ });
+ state.owned = [share([], [pendingRequest('local-next')])];
+ onlineRequest = 'online-next';
+ await refreshProviderShareHost('next-round-with-slow-peer');
+ expect(ev.requested).toHaveBeenLastCalledWith(pendingRequest('local-next'), expect.anything(), false);
+ expect(ev.watchedRequested).toHaveBeenLastCalledWith(expect.objectContaining({ request: pendingRequest('online-next') }));
+ expect(readWatchedShares.mock.calls.filter(([hostDeviceId]) => hostDeviceId === 'group-host')).toHaveLength(1);
+ } finally {
+ finishOffline([]);
+ await refreshing;
+ }
+ });
+
+ it('discards a watched snapshot that completes after an account switch', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ vi.setSystemTime(new Date('2026-10-14T08:00:00.000Z'));
+ const ev = events();
+ startProviderShareHost(ev);
+ await refreshProviderShareHost('start');
+ await watchShare('group-host', 'anthropic');
+ let finish!: (shares: ProviderShareOwned[]) => void;
+ readWatchedShares.mockImplementation(() => new Promise((resolve) => { finish = resolve; }));
+ const refreshing = refreshProviderShareHost('before-switch');
+ state.scope = 'cloud:other:2';
+ finish([otherShare([pendingRequest('old-owner')])]);
+ await refreshing;
+ expect(ev.watchedRequested).not.toHaveBeenCalled();
+ expect(getProviderShareWatchedRequests()).toEqual([]);
+ });
+});
+
describe('provider share guest routing', () => {
it('distinguishes an authoritative empty membership list from startup, failure, disconnect and account switch', async () => {
expect(getReceivedSharesSnapshot().confirmedRegions).toEqual([]);
diff --git a/apps/desktop/src/main/device-link/providerShareApprovalWindows.ts b/apps/desktop/src/main/device-link/providerShareApprovalWindows.ts
new file mode 100644
index 0000000000..37d30a0e1c
--- /dev/null
+++ b/apps/desktop/src/main/device-link/providerShareApprovalWindows.ts
@@ -0,0 +1,112 @@
+/** 七分钟内的审批弹窗归属;只存电脑、供应商、非秘密链接标识与截止时刻,不存口令、申请或身份。 */
+import { PROVIDER_SHARE_LINK_TTL_MS } from '@cindy/device-link';
+
+import { createLogger } from '../logger.js';
+import { createOverrideSettingsFile } from '../maker-host/override-settings-file.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
+
+const log = createLogger('provider-share:approval-windows');
+
+/** 两侧共用:链接五分钟有效,再给申请拉取留两分钟;过期不重建、不延长。 */
+export const PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS = PROVIDER_SHARE_LINK_TTL_MS + 2 * 60_000;
+
+export interface ProviderShareApprovalQuietLink {
+ providerId: string;
+ linkId: string;
+ until: number;
+}
+
+export interface ProviderShareApprovalWatch {
+ hostDeviceId: string;
+ providerId: string;
+ linkId?: string;
+ until: number;
+}
+
+export interface ProviderShareApprovalWindows {
+ quietUntil: Record<string, number>;
+ /** Exact-link ownership for servers that return linkId; legacy watches omit it. */
+ quietLinks?: ProviderShareApprovalQuietLink[];
+ watches: ProviderShareApprovalWatch[];
+}
+
+const empty = (): ProviderShareApprovalWindows => ({ quietUntil: {}, watches: [] });
+const validId = (value: unknown): value is string => typeof value === 'string' && value.length > 0 && value.length <= 256;
+const validLinkId = (value: unknown): value is string => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+
+function normalize(raw: unknown): ProviderShareApprovalWindows {
+ const input = raw as Partial<ProviderShareApprovalWindows> | null;
+ const now = Date.now();
+ const validUntil = (value: unknown): value is number => typeof value === 'number' && Number.isFinite(value)
+ && value > now && value <= now + PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS;
+ const quiet = input?.quietUntil;
+ const quietUntil = Object.fromEntries(Object.entries(quiet && typeof quiet === 'object' && !Array.isArray(quiet) ? quiet : {})
+ .filter(([providerId, until]) => validId(providerId) && validUntil(until)));
+ const watches = new Map<string, ProviderShareApprovalWindows['watches'][number]>();
+ for (const item of Array.isArray(input?.watches) ? input.watches : []) {
+ if (!item || !validId(item.hostDeviceId) || !validId(item.providerId) || !validUntil(item.until)) continue;
+ if (item.linkId !== undefined && !validLinkId(item.linkId)) continue;
+ const linkId = item.linkId;
+ const key = JSON.stringify([item.hostDeviceId, item.providerId, linkId ?? null]);
+ const previous = watches.get(key);
+ const watch = { hostDeviceId: item.hostDeviceId, providerId: item.providerId, ...(linkId ? { linkId } : {}), until: item.until };
+ if (!previous || previous.until < watch.until) watches.set(key, watch);
+ }
+ const quietLinks = new Map<string, ProviderShareApprovalQuietLink>();
+ for (const item of Array.isArray(input?.quietLinks) ? input.quietLinks : []) {
+ if (!item || !validId(item.providerId) || !validLinkId(item.linkId) || !validUntil(item.until)) continue;
+ const key = JSON.stringify([item.providerId, item.linkId]);
+ const previous = quietLinks.get(key);
+ if (!previous || previous.until < item.until) quietLinks.set(key, { providerId: item.providerId, linkId: item.linkId, until: item.until });
+ }
+ return { quietUntil, ...(quietLinks.size > 0 ? { quietLinks: [...quietLinks.values()] } : {}), watches: [...watches.values()] };
+}
+
+function createStore(options: { filePath: () => string; scopeKey: () => string }) {
+ return createOverrideSettingsFile<ProviderShareApprovalWindows>({
+ ...options,
+ defaults: empty,
+ normalize,
+ log,
+ label: 'provider-share-approval-windows',
+ maxBytes: 1024 * 1024,
+ preserveUnreadableFile: true,
+ logLoadedValue: false,
+ logReadErrorDetails: false,
+ });
+}
+
+let store: ReturnType<typeof createStore> | null = null;
+
+/** 启动接线注入当前账号路径;没有配置的测试仍只用内存,不在 import 时读写磁盘。 */
+export function configureProviderShareApprovalWindows(options: { filePath: () => string; scopeKey: () => string } | null): void {
+ store = options ? createStore(options) : null;
+}
+
+export function readProviderShareApprovalWindows(): ProviderShareApprovalWindows | null {
+ if (!store) return null;
+ store.invalidateIfChanged();
+ // 缓存命中时也重新过滤已经过期的记录。
+ return normalize(store.read());
+}
+
+export async function updateProviderShareApprovalWindows(
+ update: (current: ProviderShareApprovalWindows) => ProviderShareApprovalWindows,
+ assertCurrent: () => void,
+): Promise<void> {
+ assertCurrent();
+ if (store) {
+ try {
+ await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ return update(normalize(value));
+ }, { preserveDefaults: true });
+ } catch (error) {
+ // 不把文件路径或底层错误原文交给 Renderer / 另一台电脑。
+ const code = (error as NodeJS.ErrnoException | null)?.code;
+ log.warn('approval window save failed', { code: typeof code === 'string' ? code : 'UNKNOWN' });
+ throwIpcError('PRECONDITION_FAILED', 'Could not save provider share approval ownership');
+ }
+ }
+ assertCurrent();
+}
diff --git a/apps/desktop/src/main/device-link/providerShareGuestPrefs.ts b/apps/desktop/src/main/device-link/providerShareGuestPrefs.ts
index 45d71aa2f7..bd227ce1c1 100644
--- a/apps/desktop/src/main/device-link/providerShareGuestPrefs.ts
+++ b/apps/desktop/src/main/device-link/providerShareGuestPrefs.ts
@@ -35,11 +35,21 @@ interface StoredPrefs {
const SHARE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,121}$/;
+interface PendingSetting {
+ file: string | null;
+ shareId: string;
+ region: Region;
+ cancelled: boolean;
+}
+
let resolvePath: (() => string) | null = null;
let cache: { file: string | null; shares: Map<string, GuestPrefRecord> } | null = null;
let writes: Promise<void> = Promise.resolve();
let pendingWrites = 0;
let generation = 0;
+const pendingSettings = new Set<PendingSetting>();
+// 退出或权威名单清理立即撤权;不能等前面的磁盘写入结束才停止跳过确认。
+const revokedShares = new Map<string | null, Map<string, object>>();
/** 由本机接线在启动时提供文件位置(按当前账号解析);传 null 回到只在内存里。 */
export function configureProviderShareGuestPrefs(options: { resolvePath: (() => string) | null }): void {
@@ -147,25 +157,63 @@ async function writeFile(file: string, snapshot: StoredPrefs, assertCurrent: ()
/** 这个分享的任务里凭证类操作是否不再确认(默认 false)。 */
export function isProviderShareCredentialConsentSkipped(shareId: string): boolean {
- return load().get(shareId)?.skipCredentialConsent === true;
+ const file = currentFile();
+ if (revokedShares.get(file)?.has(shareId)) return false;
+ return load(file).get(shareId)?.skipCredentialConsent === true;
}
/** 打开或关掉「信任 {分享者}」。关掉就是删掉记录(只存 override)。 */
export async function setProviderShareCredentialConsent(shareId: string, region: Region, skip: boolean): Promise<void> {
if (!SHARE_ID.test(shareId)) throw new Error('Invalid provider share id');
const file = currentFile();
- await persist(file, (shares) => {
- if (!skip) return shares.delete(shareId);
- if (shares.get(shareId)?.region === region) return false;
- shares.set(shareId, { region, skipCredentialConsent: true });
- return true;
+ const setting: PendingSetting = { file, shareId, region, cancelled: false };
+ pendingSettings.add(setting);
+ try {
+ await persist(file, (shares) => {
+ if (setting.cancelled) return false;
+ if (!skip) return shares.delete(shareId);
+ if (shares.get(shareId)?.region === region) return false;
+ shares.set(shareId, { region, skipCredentialConsent: true });
+ return true;
+ });
+ if (!setting.cancelled) revokedShares.get(file)?.delete(shareId);
+ } finally {
+ pendingSettings.delete(setting);
+ }
+}
+
+/** 在内存中立即撤权,再在同一跨进程锁内删除磁盘记录;失败也不恢复信任。 */
+function removePrefs(file: string | null, matches: (shareId: string, region: Region) => boolean): Promise<void> {
+ const revoked = revokedShares.get(file) ?? new Map<string, object>();
+ revokedShares.set(file, revoked);
+ const removal = {};
+ for (const setting of pendingSettings) {
+ if (setting.file === file && matches(setting.shareId, setting.region)) {
+ setting.cancelled = true;
+ revoked.set(setting.shareId, removal);
+ }
+ }
+ for (const [shareId, record] of load(file)) {
+ if (matches(shareId, record.region)) revoked.set(shareId, removal);
+ }
+ return persist(file, (shares) => {
+ const previousSize = shares.size;
+ for (const [shareId, record] of shares) {
+ if (matches(shareId, record.region)) shares.delete(shareId);
+ }
+ return shares.size !== previousSize;
+ }).then(() => {
+ for (const [shareId, token] of revoked) {
+ if (token === removal) revoked.delete(shareId);
+ }
+ if (revoked.size === 0 && revokedShares.get(file) === revoked) revokedShares.delete(file);
});
}
/** 绑定退出请求发起时的账号文件,完成退出后只清理该账号的偏好。 */
export function captureProviderShareGuestPrefsRemoval(shareId: string): () => Promise<void> {
const file = currentFile();
- return () => persist(file, (shares) => shares.delete(shareId));
+ return () => removePrefs(file, (id) => id === shareId);
}
/** 受邀者退出了这个分享:忘掉它的偏好。 */
@@ -181,13 +229,7 @@ export function pruneProviderShareGuestPrefs(present: ReadonlySet<string>, confi
if (confirmedRegions.length === 0) return;
const file = currentFile();
if (pendingWrites === 0 && ![...load(file)].some(([shareId, record]) => confirmedRegions.includes(record.region) && !present.has(shareId))) return;
- return persist(file, (shares) => {
- const previousSize = shares.size;
- for (const [shareId, record] of shares) {
- if (confirmedRegions.includes(record.region) && !present.has(shareId)) shares.delete(shareId);
- }
- return shares.size !== previousSize;
- }).catch(() => undefined);
+ return removePrefs(file, (shareId, region) => confirmedRegions.includes(region) && !present.has(shareId)).catch(() => undefined);
}
/** 等最近一次写入落盘(测试与退出前用)。 */
@@ -201,4 +243,6 @@ export function resetProviderShareGuestPrefsForTests(): void {
invalidateProviderShareGuestPrefsCache();
writes = Promise.resolve();
pendingWrites = 0;
+ pendingSettings.clear();
+ revokedShares.clear();
}
diff --git a/apps/desktop/src/main/device-link/providerShareHost.ts b/apps/desktop/src/main/device-link/providerShareHost.ts
index 080d8017e6..ec8a4444ac 100644
--- a/apps/desktop/src/main/device-link/providerShareHost.ts
+++ b/apps/desktop/src/main/device-link/providerShareHost.ts
@@ -7,6 +7,9 @@
* - 有分享但没有待处理的事时每 60 秒拉一次(受邀者退出等变化);
* - 不认识的受邀者连进来时按需立即拉一次(限频)。
* 本机做的暂停、删除先改本机快照、立即撤权,不等下一次拉取。
+ *
+ * 审批弹窗跟着生成链接的电脑(provider-sharing.md §4.1):同账号另一台电脑经管理为本机的分享生成链接后,
+ * 窗口期内的新申请在本机只进管理页与提示点;那台电脑在同一窗口期关注本机的分享,由它弹审批窗。
*/
import {
parseProviderSharePeer,
@@ -18,9 +21,17 @@ import { isAppSessionBoundaryPending } from '../appSessionState.js';
import { getAuthState, getDeviceId } from '../authManager.js';
import { createLogger } from '../logger.js';
import { isRemoteProviderInvocationAllowed } from '../maker-host/remote-provider-access-store.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
import { providerShareApi, providerShareOwnerKey } from './providerShareApi.js';
+import {
+ PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS,
+ readProviderShareApprovalWindows,
+ updateProviderShareApprovalWindows,
+} from './providerShareApprovalWindows.js';
import { readDeviceLinkSettings } from './settings-store.js';
+export { PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS } from './providerShareApprovalWindows.js';
+
const log = createLogger('provider-share:host');
const FAST_POLL_MS = 5_000;
@@ -28,7 +39,6 @@ const SLOW_POLL_MS = 60_000;
/** 生成链接后保持快速拉取的时长:链接 5 分钟有效,再留出申请到达的余量。 */
const HOT_AFTER_LINK_MS = 6 * 60_000;
const ON_DEMAND_MIN_INTERVAL_MS = 5_000;
-
export interface ProviderShareGuestAccess {
shareId: string;
memberId: string;
@@ -38,8 +48,12 @@ export interface ProviderShareGuestAccess {
export interface ProviderShareHostEvents {
/** 快照变化(管理页刷新)。 */
changed(shares: readonly ProviderShareOwned[]): void;
- /** 出现新的待审批申请(审批弹窗与系统通知)。 */
- requested(request: ProviderShareRequestItem, share: ProviderShareOwned): void;
+ /**
+ * 出现新的待审批申请(审批弹窗与系统通知)。quiet = 链接由同账号另一台电脑生成,由那台弹窗,本机不弹。
+ */
+ requested(request: ProviderShareRequestItem, share: ProviderShareOwned, quiet: boolean): void;
+ /** 本机为同账号另一台电脑上的分享生成链接后,那条分享出现新申请:由本机弹审批窗。 */
+ watchedRequested(item: ProviderShareWatchedRequest): void;
/** 成员不再 active(暂停、删除、退出):结束它的任务、断开它的连接;purge 时清理本机数据。 */
revoked(member: ProviderShareMemberRef, purge: boolean): void;
/**
@@ -54,6 +68,24 @@ export interface ProviderShareMemberRef {
memberId: string;
}
+/** 同账号另一台电脑上的分享里、由本机负责弹窗的待审批申请。 */
+export interface ProviderShareWatchedRequest {
+ request: ProviderShareRequestItem;
+ share: { shareId: string; providerId: string; providerLabel: string };
+ hostDeviceId: string;
+}
+
+/** 同账号管理的 owned 回包;只把申请用于本机弹窗,不作为受邀者准入快照。 */
+export type ProviderShareWatchedSnapshot = Pick<ProviderShareOwned, 'shareId' | 'providerId' | 'providerLabel' | 'requests'>;
+
+interface RemoteLinkWatch {
+ hostDeviceId: string;
+ providerId: string;
+ linkId?: string;
+ until: number;
+ readShares(): Promise<readonly ProviderShareWatchedSnapshot[]>;
+}
+
interface Runtime {
events: ProviderShareHostEvents;
scope: string | null;
@@ -62,16 +94,100 @@ interface Runtime {
hotUntil: number;
timer: ReturnType<typeof setTimeout> | null;
refreshing: Promise<void> | null;
+ remoteRefreshing: Map<string, Promise<void>>;
lastOnDemandAt: number;
knownRequests: Set<string>;
reconciled: boolean;
stopped: boolean;
+ /** 本机分享:供应商 → 另一台电脑生成的链接的窗口期截止时刻。 */
+ quietUntil: Map<string, number>;
+ /** 本机分享:服务端返回 linkId 时,按具体链接归属的窗口期截止时刻。 */
+ quietLinks: Map<string, number>;
+ /** 本机分享里由另一台电脑弹窗的申请。 */
+ quietRequests: Set<string>;
+ /** 本机为另一台电脑上的分享生成了链接,窗口期内关注那条分享。 */
+ watches: RemoteLinkWatch[];
+ /** 关注到、仍待审批的申请。 */
+ watched: Map<string, ProviderShareWatchedRequest>;
+ watchedSeen: Set<string>;
+}
+
+interface RetainedRemoteLinkState {
+ watches: RemoteLinkWatch[];
+ watched: Map<string, ProviderShareWatchedRequest>;
+ watchedSeen: Set<string>;
}
let runtime: Runtime | null = null;
/** 分享快照变化的旁听者(见 onProviderShareHostChanged)。 */
const snapshotListeners = new Set<() => void>();
+/**
+ * 远程管理生成链接后,host runtime 可能因设备互联断开、重新接管或账号边界重建。
+ * 同进程重建时保留回调与去重;完整进程重启则从按账号保存的七分钟窗口恢复,不存申请或链接口令。
+ */
+const retainedQuietUntilByScope = new Map<string, Map<string, number>>();
+const retainedQuietLinksByScope = new Map<string, Map<string, number>>();
+const retainedRemoteLinkStateByScope = new Map<string, RetainedRemoteLinkState>();
+
+function activeQuietUntil(source: ReadonlyMap<string, number>): Map<string, number> {
+ const now = Date.now();
+ return new Map([...source].filter(([, until]) => until > now));
+}
+
+function retainQuietUntil(rt: Runtime): void {
+ if (rt.scope === null) return;
+ const active = activeQuietUntil(rt.quietUntil);
+ if (active.size > 0) retainedQuietUntilByScope.set(rt.scope, active);
+ else retainedQuietUntilByScope.delete(rt.scope);
+ const activeLinks = activeQuietUntil(rt.quietLinks);
+ if (activeLinks.size > 0) retainedQuietLinksByScope.set(rt.scope, activeLinks);
+ else retainedQuietLinksByScope.delete(rt.scope);
+}
+
+function restoreQuietUntil(scope: string | null): Map<string, number> {
+ if (scope === null) return new Map();
+ const retained = retainedQuietUntilByScope.get(scope);
+ retainedQuietUntilByScope.delete(scope);
+ return retained ? activeQuietUntil(retained) : new Map();
+}
+
+function restoreQuietLinks(scope: string | null): Map<string, number> {
+ if (scope === null) return new Map();
+ const retained = retainedQuietLinksByScope.get(scope);
+ retainedQuietLinksByScope.delete(scope);
+ return retained ? activeQuietUntil(retained) : new Map();
+}
+
+function activeRemoteLinkWatches(source: readonly RemoteLinkWatch[]): RemoteLinkWatch[] {
+ const now = Date.now();
+ return source.filter((watch) => watch.until > now);
+}
+
+function retainRemoteLinkState(rt: Runtime): void {
+ if (rt.scope === null) return;
+ const watches = activeRemoteLinkWatches(rt.watches);
+ const watched = new Map(rt.watched);
+ const watchedSeen = new Set(rt.watchedSeen);
+ if (watches.length > 0) {
+ retainedRemoteLinkStateByScope.set(rt.scope, { watches, watched, watchedSeen });
+ } else {
+ retainedRemoteLinkStateByScope.delete(rt.scope);
+ }
+}
+
+function restoreRemoteLinkState(scope: string | null): RetainedRemoteLinkState {
+ if (scope === null) return { watches: [], watched: new Map(), watchedSeen: new Set() };
+ const retained = retainedRemoteLinkStateByScope.get(scope);
+ retainedRemoteLinkStateByScope.delete(scope);
+ if (!retained) return { watches: [], watched: new Map(), watchedSeen: new Set() };
+ return {
+ watches: activeRemoteLinkWatches(retained.watches),
+ watched: new Map(retained.watched),
+ watchedSeen: new Set(retained.watchedSeen),
+ };
+}
+
function current(rt: Runtime): boolean {
return runtime === rt && !rt.stopped && getAuthState().isAuthenticated && !isAppSessionBoundaryPending()
&& providerShareOwnerKey() === rt.scope;
@@ -90,8 +206,8 @@ function schedule(rt: Runtime): void {
rt.timer = null;
// 暂时不可用(账号边界切换中等)时照常排下一次,拉取本身会核对作用域;只有停掉运行时才断链。
if (runtime !== rt || rt.stopped) return;
- const pending = rt.shares.some((share) => share.requests.length > 0);
- const hot = Date.now() < rt.hotUntil || pending;
+ const pending = rt.shares.some((share) => share.requests.length > 0) || rt.watched.size > 0;
+ const hot = Date.now() < rt.hotUntil || pending || rt.watches.some((watch) => watch.until > Date.now());
if (!hot && rt.shares.length === 0 && rt.fetchedAt > 0) return;
rt.timer = setTimeout(() => { void refreshProviderShareHost('poll'); }, hot ? FAST_POLL_MS : SLOW_POLL_MS);
(rt.timer as { unref?: () => void }).unref?.();
@@ -110,13 +226,29 @@ function applySnapshot(rt: Runtime, next: ProviderShareOwned[]): void {
else if (member.status === 'active' && after.status !== 'active') rt.events.revoked({ shareId: share.shareId, memberId: member.memberId }, false);
}
}
+ const now = Date.now();
+ const pendingIds = new Set<string>();
for (const share of next) {
for (const request of share.requests) {
+ pendingIds.add(request.requestId);
if (rt.knownRequests.has(request.requestId)) continue;
rt.knownRequests.add(request.requestId);
- rt.events.requested(request, share);
+ const quiet = request.linkId
+ ? (rt.quietLinks.get(`${share.providerId}:${request.linkId}`) ?? 0) > now
+ : (rt.quietUntil.get(share.providerId) ?? 0) > now;
+ if (quiet) rt.quietRequests.add(request.requestId);
+ rt.events.requested(request, share, quiet);
}
}
+ for (const requestId of rt.quietRequests) {
+ if (!pendingIds.has(requestId)) rt.quietRequests.delete(requestId);
+ }
+ for (const [providerId, until] of rt.quietUntil) {
+ if (until <= now) rt.quietUntil.delete(providerId);
+ }
+ for (const [key, until] of rt.quietLinks) {
+ if (until <= now) rt.quietLinks.delete(key);
+ }
rt.events.changed(next);
for (const listener of snapshotListeners) {
try {
@@ -145,20 +277,80 @@ export function getProviderShareHostLoadedSnapshot(): readonly ProviderShareOwne
return rt.shares;
}
-export function startProviderShareHost(events: ProviderShareHostEvents): void {
+/**
+ * 同账号其他电脑上的分享:窗口期内关注的那条分享出现的申请由本机弹窗;已关注的申请从快照里消失
+ * (在任一台电脑上处理、撤回或过期)时移除。只用于弹窗,不进入本机快照,不影响受邀者准入。
+ */
+function applyWatched(rt: Runtime, hostDeviceId: string, shares: readonly ProviderShareWatchedSnapshot[]): void {
+ const now = Date.now();
+ const present = new Set<string>();
+ for (const share of shares) {
+ for (const request of share.requests) present.add(request.requestId);
+ }
+ for (const [requestId, item] of rt.watched) {
+ if (item.hostDeviceId === hostDeviceId && !present.has(requestId)) rt.watched.delete(requestId);
+ }
+ for (const share of shares) {
+ const watches = rt.watches.filter((watch) => watch.hostDeviceId === hostDeviceId && watch.providerId === share.providerId && watch.until > now);
+ if (watches.length === 0) continue;
+ for (const request of share.requests) {
+ // 旧窗口只接无标识的旧回包,不能接管升级后其它电脑生成的链接。
+ if (!watches.some((watch) => watch.linkId === request.linkId)) continue;
+ // 弹过一次的不再弹(本机处理后,处理前发出的那次拉取可能还带着它)。
+ if (rt.watchedSeen.has(request.requestId)) continue;
+ rt.watchedSeen.add(request.requestId);
+ const item: ProviderShareWatchedRequest = {
+ request,
+ share: { shareId: share.shareId, providerId: share.providerId, providerLabel: share.providerLabel },
+ hostDeviceId,
+ };
+ rt.watched.set(request.requestId, item);
+ rt.events.watchedRequested(item);
+ }
+ }
+}
+
+export function startProviderShareHost(events: ProviderShareHostEvents, options: {
+ readWatchedShares?: (hostDeviceId: string) => Promise<readonly ProviderShareWatchedSnapshot[]>;
+} = {}): void {
stopProviderShareHost();
+ const scope = providerShareOwnerKey();
+ const remoteLinkState = restoreRemoteLinkState(scope);
+ const saved = scope === null ? null : readProviderShareApprovalWindows();
+ const retainedQuiet = restoreQuietUntil(scope);
+ const retainedQuietLinks = restoreQuietLinks(scope);
+ // 启动的第一轮快照之前恢复两侧归属。读远端的函数由新运行时接线提供,不能从磁盘恢复旧账号闭包。
+ if (saved) {
+ remoteLinkState.watches = saved.watches.flatMap((watch) => {
+ const retained = remoteLinkState.watches.find((item) => item.hostDeviceId === watch.hostDeviceId
+ && item.providerId === watch.providerId && item.linkId === watch.linkId);
+ const readShares = options.readWatchedShares
+ ? () => options.readWatchedShares!(watch.hostDeviceId)
+ : retained?.readShares;
+ return readShares ? [{ ...watch, readShares }] : [];
+ });
+ }
const rt: Runtime = {
events,
- scope: providerShareOwnerKey(),
+ scope,
shares: [],
fetchedAt: 0,
hotUntil: 0,
timer: null,
refreshing: null,
+ remoteRefreshing: new Map(),
lastOnDemandAt: 0,
knownRequests: new Set(),
reconciled: false,
stopped: false,
+ quietUntil: saved ? new Map(Object.entries(saved.quietUntil)) : retainedQuiet,
+ quietLinks: saved
+ ? new Map((saved.quietLinks ?? []).map((item) => [`${item.providerId}:${item.linkId}`, item.until]))
+ : retainedQuietLinks,
+ quietRequests: new Set(),
+ watches: remoteLinkState.watches,
+ watched: remoteLinkState.watched,
+ watchedSeen: remoteLinkState.watchedSeen,
};
runtime = rt;
void refreshProviderShareHost('start');
@@ -169,15 +361,16 @@ export function stopProviderShareHost(): void {
if (!rt) return;
rt.stopped = true;
if (rt.timer) clearTimeout(rt.timer);
+ retainQuietUntil(rt);
+ retainRemoteLinkState(rt);
runtime = null;
}
-/** 拉一次分享快照。并发调用合并为一次。 */
+/** 拉一次分享快照。本机与每台关注电脑各自合并在途读取,不让一个 peer 卡住下一轮。 */
export function refreshProviderShareHost(reason: string): Promise<void> {
const rt = runtime;
if (!rt) return Promise.resolve();
- if (rt.refreshing) return rt.refreshing;
- const run = (async () => {
+ const readLocal = async () => {
try {
const shares = await providerShareApi.listOwned();
if (!current(rt)) return;
@@ -189,13 +382,34 @@ export function refreshProviderShareHost(reason: string): Promise<void> {
}
} catch (error) {
if (current(rt)) log.warn('provider share snapshot refresh failed', { reason, error: error instanceof Error ? error.message : String(error) });
- } finally {
- rt.refreshing = null;
- schedule(rt);
}
- })();
- rt.refreshing = run;
- return run;
+ };
+ // REST 只返回本机分享。远端申请经已有同账号管理通道读取,每台电脑最多一次在途;
+ // 拉取本机或某个 peer 仍在途时只跳过它,不延迟其它电脑。
+ const local = rt.refreshing ?? readLocal().finally(() => {
+ rt.refreshing = null;
+ schedule(rt);
+ });
+ rt.refreshing = local;
+ schedule(rt);
+ const pendingHosts = new Set([...rt.watched.values()].map((item) => item.hostDeviceId));
+ rt.watches = rt.watches.filter((watch) => watch.until > Date.now() || pendingHosts.has(watch.hostDeviceId));
+ const readers = new Map(rt.watches.map((watch) => [watch.hostDeviceId, watch.readShares]));
+ const remote = [...readers].flatMap(([hostDeviceId, readShares]) => {
+ if (rt.remoteRefreshing.has(hostDeviceId)) return [];
+ const read = (async () => {
+ try {
+ if (!current(rt)) return;
+ const shares = await readShares();
+ if (current(rt)) applyWatched(rt, hostDeviceId, shares);
+ } catch {
+ if (current(rt)) log.warn('provider share watched snapshot refresh failed', { reason, hostDeviceId });
+ }
+ })().finally(() => { rt.remoteRefreshing.delete(hostDeviceId); });
+ rt.remoteRefreshing.set(hostDeviceId, read);
+ return [read];
+ });
+ return Promise.all([local, ...remote]).then(() => undefined);
}
/** 生成链接、打开管理页时进入快速拉取。 */
@@ -210,6 +424,79 @@ export function getProviderShareHostSnapshot(): readonly ProviderShareOwned[] {
return runtime?.shares ?? [];
}
+/** 同账号另一台电脑经管理生成的链接:只将这条链接的申请交给那台弹窗。 */
+export async function quietProviderShareRequests(providerId: string, linkId?: string): Promise<void> {
+ const rt = runtime;
+ assertApprovalWindowCurrent(rt);
+ const assertCurrent = () => assertApprovalWindowCurrent(rt);
+ const until = Date.now() + PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS;
+ await updateProviderShareApprovalWindows((value) => linkId
+ ? {
+ ...value,
+ quietLinks: [...(value.quietLinks ?? []).filter((item) => item.providerId !== providerId || item.linkId !== linkId),
+ { providerId, linkId, until }],
+ }
+ : { ...value, quietUntil: { ...value.quietUntil, [providerId]: until } }, assertCurrent);
+ if (linkId) rt.quietLinks.set(`${providerId}:${linkId}`, until);
+ else rt.quietUntil.set(providerId, until);
+}
+
+/** 本机新链接清除旧版按供应商静默的窗口;其它链接的精确归属保持不变。 */
+export async function clearProviderShareRequestQuiet(providerId: string): Promise<void> {
+ const rt = runtime;
+ assertApprovalWindowCurrent(rt);
+ const assertCurrent = () => assertApprovalWindowCurrent(rt);
+ await updateProviderShareApprovalWindows((value) => {
+ const quietUntil = { ...value.quietUntil };
+ delete quietUntil[providerId];
+ return { ...value, quietUntil };
+ }, assertCurrent);
+ rt.quietUntil.delete(providerId);
+}
+
+/** 本机为另一台电脑上的分享生成了链接:窗口期内关注那条分享,新申请由本机弹窗。 */
+export async function watchProviderShareRequests(
+ hostDeviceId: string,
+ providerId: string,
+ linkIdOrReadShares: string | RemoteLinkWatch['readShares'],
+ maybeReadShares?: RemoteLinkWatch['readShares'],
+): Promise<void> {
+ const rt = runtime;
+ assertApprovalWindowCurrent(rt);
+ const assertCurrent = () => assertApprovalWindowCurrent(rt);
+ const until = Date.now() + PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS;
+ const linkId = typeof linkIdOrReadShares === 'string' ? linkIdOrReadShares : undefined;
+ const readShares = typeof linkIdOrReadShares === 'function' ? linkIdOrReadShares : maybeReadShares;
+ if (!readShares) throwIpcError('PRECONDITION_FAILED', 'Provider share approval reader is unavailable');
+ await updateProviderShareApprovalWindows((value) => ({
+ ...value,
+ watches: [...value.watches.filter((watch) => watch.hostDeviceId !== hostDeviceId || watch.providerId !== providerId || watch.linkId !== linkId),
+ { hostDeviceId, providerId, ...(linkId ? { linkId } : {}), until }],
+ }), assertCurrent);
+ rt.watches = [
+ ...rt.watches.filter((watch) => watch.hostDeviceId !== hostDeviceId || watch.providerId !== providerId || watch.linkId !== linkId),
+ { hostDeviceId, providerId, ...(linkId ? { linkId } : {}), until, readShares },
+ ];
+ markProviderShareHostActive(PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS);
+}
+
+function assertApprovalWindowCurrent(rt: Runtime | null): asserts rt is Runtime {
+ if (!rt || !current(rt)) throwIpcError('PRECONDITION_FAILED', 'The account or runtime changed during provider share approval setup');
+}
+
+/** 本机经管理处理了关注到的申请:立即移除,不等下一次拉取。 */
+export function forgetWatchedProviderShareRequest(requestId: string): void {
+ runtime?.watched.delete(requestId);
+}
+
+export function getProviderShareQuietRequestIds(): string[] {
+ return [...(runtime?.quietRequests ?? [])];
+}
+
+export function getProviderShareWatchedRequests(): ProviderShareWatchedRequest[] {
+ return [...(runtime?.watched.values() ?? [])];
+}
+
/** 受邀者对端被拒的原因(只进日志,不发给对方)。 */
export type ProviderShareGuestDenial =
| 'host-not-running'
diff --git a/apps/desktop/src/main/device-link/providerShareReshare.ts b/apps/desktop/src/main/device-link/providerShareReshare.ts
index 1defdab604..7df3540498 100644
--- a/apps/desktop/src/main/device-link/providerShareReshare.ts
+++ b/apps/desktop/src/main/device-link/providerShareReshare.ts
@@ -228,20 +228,25 @@ export async function decideProviderShareReshare(
id: string,
decision: 'approve' | 'reject',
now = Date.now(),
+ assertCurrent: () => void = () => undefined,
): Promise<{ record: ProviderShareReshareRecord; previous: RemoteAgentReshareState } | null> {
+ assertCurrent();
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;
- }),
- }));
+ await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ return {
+ 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;
}
diff --git a/apps/desktop/src/main/device-link/providerShareRuntime.ts b/apps/desktop/src/main/device-link/providerShareRuntime.ts
index 848fdbb880..45ee2cf38d 100644
--- a/apps/desktop/src/main/device-link/providerShareRuntime.ts
+++ b/apps/desktop/src/main/device-link/providerShareRuntime.ts
@@ -40,6 +40,9 @@ import { getGatewayModelPricing, getModelPriceQuote } from '../usage/modelPricin
import { computePriceQuoteTurnMoney, normalizeModelIdForPricing } from '../usage/turnCostCalculator.js';
import { rememberIssuedClipboardText } from '../textClipboard.js';
import { ownerScopedUserDataPath } from '../appSessionState.js';
+import { captureProviderManagementScope } from '../provider-group/managementScope.js';
+import { readProviderManagementShares } from '../provider-group/managementClient.js';
+import type { ProviderShareManagementCommand } from '../../shared/providerManagement.js';
import { throwIpcError } from '../utils/ipcValidate.js';
import {
abortProviderShareReshareRuns,
@@ -50,6 +53,7 @@ import {
} from './dispatch.js';
import { getDeviceLinkInvokeContext } from './invoke-context.js';
import { fetchIdentityCard, providerShareApi, providerShareLinkFor, sha256Hex } from './providerShareApi.js';
+import { configureProviderShareApprovalWindows } from './providerShareApprovalWindows.js';
import {
findReceivedShare,
getReceivedShares,
@@ -73,12 +77,16 @@ import { setProviderShareCredentialConsentFromIpc } from './providerShareGuestPr
import {
applyLocalMemberChange,
applyLocalRequestDecision,
+ clearProviderShareRequestQuiet,
ensureProviderSharePeerKnown,
getProviderShareHostSnapshot,
+ getProviderShareQuietRequestIds,
+ getProviderShareWatchedRequests,
markProviderShareHostActive,
providerShareGuestAccess,
providerShareGuestDenial,
providerShareMemberMatcher,
+ quietProviderShareRequests,
refreshProviderShareHost,
startProviderShareHost,
stopProviderShareHost,
@@ -100,7 +108,7 @@ const log = createLogger('provider-share');
type Broadcast = (channel: string, payload: unknown) => void;
/** 经设备互联读分享者电脑的目录(index.ts 注入 remoteBackgroundInvoke,避免循环依赖)。 */
-type ShareInvoke = (agentDeviceId: string, channel: string, args: unknown[]) => Promise<InvokeResultPayload>;
+type ShareInvoke = (agentDeviceId: string, channel: string, args: unknown[], options?: { preSend?: () => void }) => Promise<InvokeResultPayload>;
let broadcastFn: Broadcast | null = null;
let shareInvoke: ShareInvoke | null = null;
@@ -213,26 +221,47 @@ const reshareEvents: ProviderShareReshareEvents = {
/** 设备互联连上(本实例持有连接)时启动;断开、登出或失去持有权时停止。 */
export function startProviderShareRuntime(broadcast: Broadcast, options: { invoke?: ShareInvoke } = {}): void {
+ // 启动仲裁可能早于 IPC 注册;必须在 host 的第一轮快照前配置持久归属。
+ configureProviderShareApprovalWindows({
+ filePath: () => ownerScopedUserDataPath('provider-share-approval-windows.json'),
+ scopeKey: () => {
+ captureProviderManagementScope();
+ return ownerScopedUserDataPath();
+ },
+ });
invalidateProviderShareGuestPrefsCache();
broadcastFn = broadcast;
shareInvoke = options.invoke ?? null;
+ const readInvoke = options.invoke;
running = true;
setProviderShareReshareEvents(reshareEvents);
startProviderShareHost({
changed() {
emit(PROVIDER_SHARE_IPC.OWNED_CHANGED, null);
},
- requested(request, share) {
+ requested(request, share, quiet) {
emit(PROVIDER_SHARE_IPC.REQUESTED, {
request,
share: { shareId: share.shareId, providerId: share.providerId, providerLabel: share.providerLabel },
+ ...(quiet ? { quiet: true } : {}),
});
+ // 链接由另一台电脑生成:那台弹窗并发通知,这里只进管理页与提示点。
+ if (quiet) return;
void notify(
t('providerShare.notification.requestTitle'),
format(t('providerShare.notification.requestBody'), { name: request.displayName, provider: share.providerLabel }),
() => emit(PROVIDER_SHARE_IPC.OPEN_MANAGE, { providerId: share.providerId }),
);
},
+ watchedRequested(item) {
+ emit(PROVIDER_SHARE_IPC.REQUESTED, item);
+ // 审批弹窗已在排队:点通知只把窗口拉到前台。
+ void notify(
+ t('providerShare.notification.requestTitle'),
+ format(t('providerShare.notification.requestBody'), { name: item.request.displayName, provider: item.share.providerLabel }),
+ () => undefined,
+ );
+ },
revoked(member, purge) {
revoke(providerShareMemberMatcher(member), purge);
// 成员被删除或退出:他报上来的转分享请求一并删掉(暂停时保留,恢复后照旧)。
@@ -249,7 +278,7 @@ export function startProviderShareRuntime(broadcast: Broadcast, options: { invok
// 转分享记录按账号存放,只会属于这台电脑上的分享:已不在快照里的成员与分享一并删掉。
pruneReshares((record) => !owned.get(record.shareId)?.has(record.memberId));
},
- });
+ }, { readWatchedShares: readInvoke ? (hostDeviceId) => readProviderManagementShares(readInvoke, hostDeviceId) : undefined });
startProviderShareGuest({
changed(received) {
emit(PROVIDER_SHARE_IPC.RECEIVED_CHANGED, received);
@@ -295,7 +324,7 @@ function usageRange(range: unknown): ProviderShareUsageRange {
return range;
}
-function parseCommand(raw: unknown): ProviderShareCommand {
+export function parseProviderShareCommand(raw: unknown): ProviderShareCommand {
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throwIpcError('INVALID_PARAMS', 'Invalid command');
const value = raw as Record<string, unknown>;
switch (value.action) {
@@ -410,6 +439,8 @@ async function ownerState(range: ProviderShareUsageRange): Promise<ProviderShare
};
})),
}))),
+ quietRequestIds: getProviderShareQuietRequestIds(),
+ watchedRequests: getProviderShareWatchedRequests(),
};
}
@@ -444,17 +475,24 @@ async function ownUsage(providerId: string, range: ProviderShareUsageRange): Pro
};
}
-async function createLink(providerId: string): Promise<ProviderShareLinkCreated> {
+async function createLink(
+ providerId: string,
+ assertCurrent: () => void = () => undefined,
+ requireLinkId = false,
+): Promise<ProviderShareLinkCreated> {
+ assertCurrent();
requireRunning();
// 逐级开启:允许远程控制 → 允许被远程调用 → 分享。
if (!readDeviceLinkSettings().remoteControlEnabled) throwIpcError('PRECONDITION_FAILED', 'Remote control is off');
if (!isRemoteProviderInvocationAllowed(providerId)) throwIpcError('PRECONDITION_FAILED', 'Remote invocation is off for this provider');
const providers = await getDesktopProviderService().listProviders({ allowSideEffects: false });
+ assertCurrent();
const provider = providers.find((item) => item.id === providerId);
if (!provider || !provider.connected || provider.agents.length === 0) throwIpcError('PRECONDITION_FAILED', 'Provider is not available');
const hostDeviceId = getDeviceId();
if (!hostDeviceId) throwIpcError('DEVICE_LINK_NOT_CONNECTED', 'Device is not registered');
const identityCard = await fetchIdentityCard('share-link', sha256Hex(`${hostDeviceId}:${providerId}`));
+ assertCurrent();
const created = await providerShareApi.createLink({
providerId,
// 名称可能自动带上登录身份(如「OpenAI · 邮箱」),分享出去前去掉。
@@ -463,43 +501,55 @@ async function createLink(providerId: string): Promise<ProviderShareLinkCreated>
deviceName: PROVIDER_SHARE_NEUTRAL_DEVICE_NAME,
identityCard,
});
+ assertCurrent();
+ if (requireLinkId && !created.linkId) {
+ throwIpcError('UNSUPPORTED_CAPABILITY', 'Remote share links require an update to the provider share server');
+ }
markProviderShareHostActive();
void refreshProviderShareHost('link');
// 倒计时按本机收到响应的时刻计算:链接刚签发,服务端从签发起算 5 分钟。不拿服务端的绝对时间
// 和本机时钟相减(两边时钟可能有偏差,偏快会一生成就显示已过期),并留出请求往返的余量。
const expiresAt = new Date(Date.now() + PROVIDER_SHARE_LINK_TTL_MS - LINK_TTL_SAFETY_MS).toISOString();
const link = providerShareLinkFor(created.invitation);
- rememberIssuedClipboardText(link, expiresAt);
- return { link, expiresAt };
+ return { link, expiresAt, ...(created.linkId ? { linkId: created.linkId } : {}) };
}
-async function execute(command: ProviderShareCommand): Promise<unknown> {
+async function execute(command: ProviderShareCommand, assertCurrent: () => void = () => undefined): Promise<unknown> {
+ assertCurrent();
switch (command.action) {
case 'owned':
if (running) markProviderShareHostActive(60_000);
return ownerState(command.range);
case 'own-usage':
return ownUsage(command.providerId, command.range);
- case 'create-link':
- return createLink(command.providerId);
+ case 'create-link': {
+ const created = await createLink(command.providerId, assertCurrent);
+ await clearProviderShareRequestQuiet(command.providerId);
+ assertCurrent();
+ rememberIssuedClipboardText(created.link, created.expiresAt);
+ return created;
+ }
case 'approve':
case 'reject':
requireRunning();
if (command.action === 'approve') await providerShareApi.approve(command.requestId);
else await providerShareApi.reject(command.requestId);
+ assertCurrent();
applyLocalRequestDecision(command.requestId);
void refreshProviderShareHost(command.action);
return { ok: true };
case 'set-member': {
requireRunning();
const result = await providerShareApi.setMember(command.memberId, command.status);
+ assertCurrent();
applyLocalMemberChange(command.memberId, result.status);
void refreshProviderShareHost('member');
return { ok: true };
}
case 'reshare-decide': {
// 只改本机记录(不经服务端);撤回立即结束这个人经组转来的任务。
- const decided = await decideProviderShareReshare(command.id, command.decision);
+ const decided = await decideProviderShareReshare(command.id, command.decision, Date.now(), assertCurrent);
+ assertCurrent();
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);
@@ -534,6 +584,39 @@ async function execute(command: ProviderShareCommand): Promise<unknown> {
}
}
+/**
+ * 同账号管理只执行分享者操作;申请和成员必须属于这台电脑的分享。经管理生成的链接由发起的那台电脑
+ * 弹审批窗,本机在窗口期内静默;返回的 owned 只含这台电脑的分享,不带本机自己的弹窗安排。
+ */
+export async function executeProviderShareManagementCommand(command: ProviderShareManagementCommand): Promise<unknown> {
+ const assertCurrent = captureProviderManagementScope();
+ if (command.action === 'approve' || command.action === 'reject' || command.action === 'set-member') {
+ requireRunning();
+ await refreshProviderShareHost('management');
+ assertCurrent();
+ const shares = getProviderShareHostSnapshot();
+ const found = command.action === 'set-member'
+ ? shares.some((share) => share.members.some((member) => member.memberId === command.memberId))
+ : shares.some((share) => share.requests.some((request) => request.requestId === command.requestId));
+ if (!found) throwIpcError('NOT_FOUND', 'The share request or member is no longer on this computer');
+ }
+ if (command.action === 'create-link') {
+ const created = await createLink(command.providerId, assertCurrent, true);
+ assertCurrent();
+ await quietProviderShareRequests(command.providerId, created.linkId);
+ assertCurrent();
+ rememberIssuedClipboardText(created.link, created.expiresAt);
+ return created;
+ }
+ const result = await execute(command, assertCurrent);
+ assertCurrent();
+ if (command.action === 'owned') {
+ const { ready, shares } = result as ProviderShareOwnerState;
+ return { ready, shares } satisfies ProviderShareOwnerState;
+ }
+ return result;
+}
+
const CATALOG_READ_TIMEOUT_MS = 10_000;
const LINK_TTL_SAFETY_MS = 5_000;
@@ -608,7 +691,7 @@ export function registerProviderShareIpc(): void {
// 账号级操作:只接受本机应用窗口,不经设备互联代理。
if (getDeviceLinkInvokeContext()) throwIpcError('PERMISSION_DENIED', 'Provider sharing is local only');
assertTrustedAppRendererEvent(event);
- return execute(parseCommand(raw));
+ return execute(parseProviderShareCommand(raw));
});
}
diff --git a/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts b/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts
index 54bff2407f..246bc72e68 100644
--- a/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/ipc.test.ts
@@ -1,7 +1,8 @@
/**
* 供应商组设置的 IPC 业务体:入参校验,以及「新加入的电脑必须是这台电脑已经能用的同一个供应商」。
*/
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ipcMain, type IpcMainInvokeEvent } from 'electron';
vi.mock('electron', () => ({ ipcMain: { handle: vi.fn() } }));
vi.mock('../runtime.js', () => ({
@@ -10,20 +11,38 @@ vi.mock('../runtime.js', () => ({
getProviderGroupRemoteClient: vi.fn(),
readProviderGroupOfSession: vi.fn(),
}));
-vi.mock('../store.js', () => ({ readProviderGroup: vi.fn(), writeProviderGroup: vi.fn() }));
+vi.mock('../store.js', () => ({ readProviderGroup: vi.fn(), writeProviderGroup: vi.fn(), listProviderGroups: vi.fn() }));
vi.mock('../bindings.js', () => ({ pruneProviderGroupBindings: vi.fn() }));
-vi.mock('../../appSessionState.js', () => ({ activeOwnerScopeKey: () => 'owner-a' }));
-vi.mock('../../device-link/index.js', () => ({ broadcast: vi.fn(), getSelfDeviceId: vi.fn(() => 'self') }));
+vi.mock('../../appSessionState.js', () => ({
+ activeOwnerScopeKey: vi.fn(() => 'owner-a'),
+ isAppSessionBoundaryPending: vi.fn(() => false),
+}));
+vi.mock('../../security/trustedAppRenderer.js', () => ({ assertTrustedAppRendererEvent: vi.fn() }));
+vi.mock('../../device-link/index.js', () => ({ broadcast: vi.fn(), getSelfDeviceId: vi.fn(() => 'self'), remoteInvoke: vi.fn(), remoteBackgroundInvoke: vi.fn() }));
+// 同账号管理的转发另有 managementClient.test.ts;IPC 回归只替换转发,不拉进分享运行时。
+vi.mock('../managementClient.js', () => ({ invokeProviderManagement: vi.fn() }));
+vi.mock('../../device-link/providerShareRuntime.js', () => ({
+ executeProviderShareManagementCommand: vi.fn(), parseProviderShareCommand: vi.fn(),
+}));
vi.mock('../../logger.js', () => ({ createLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn() }) }));
import type { ProviderGroupCandidate, ProviderGroupConfig } from '../../../shared/providerGroup';
+import type { ProviderManagementRequest } from '../../../shared/providerManagement';
import {
executeProviderGroupCommand,
markMembersUnreachableHere,
parseProviderGroupCommand,
+ registerProviderGroupIpc,
PROVIDER_GROUP_REACHABILITY_CHECK_TIMEOUT_MS,
type ProviderGroupCommandDeps,
} from '../ipc';
+import { handleProviderManagementRequest, parseProviderManagementRequest } from '../management';
+import { activeOwnerScopeKey, isAppSessionBoundaryPending } from '../../appSessionState';
+import { executeProviderShareManagementCommand, parseProviderShareCommand } from '../../device-link/providerShareRuntime';
+import { getProviderGroupDirectory, getProviderGroupRouter } from '../runtime';
+import { invokeProviderManagement } from '../managementClient';
+import { pruneProviderGroupBindings } from '../bindings';
+import { readProviderGroup, writeProviderGroup } from '../store';
const LOCAL = { key: 'local', kind: 'local' as const, agentDeviceId: null, providerId: 'anthropic', limit: 4, weight: 1, paused: false };
const MINI = {
@@ -36,6 +55,11 @@ const MINI = {
weight: 1,
paused: false,
};
+const SHARED = {
+ ...MINI, key: 'share:s1:anthropic', kind: 'share' as const, agentDeviceId: 'share:s1', providerId: 'anthropic',
+};
+
+afterEach(() => vi.mocked(isAppSessionBoundaryPending).mockReturnValue(false));
function deps(candidates: ProviderGroupCandidate[], existing: ProviderGroupConfig | null = null) {
let stored = existing;
@@ -84,6 +108,27 @@ describe('parseProviderGroupCommand', () => {
expect(() => parseProviderGroupCommand({ action: 'session-group' })).toThrow();
expect(() => parseProviderGroupCommand({ action: 'session-group', sessionId: '../x' })).toThrow();
});
+
+ it('requires an explicit editing snapshot for conditional writes and rejects legacy remote writes', () => {
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
+ for (const action of ['save-if-current', 'delete-if-current'] as const) {
+ for (const expectedConfig of [null, config]) {
+ const parsed = parseProviderGroupCommand({ action, providerId: 'anthropic', config, expectedConfig });
+ expect(parsed).toMatchObject({ action, expectedConfig });
+ expect(parseProviderManagementRequest({ action: 'manage-group', command: parsed })).toEqual({
+ action: 'manage-group', command: parsed,
+ });
+ }
+ for (const expectedConfig of [undefined, false, [], {}, { members: [] }]) {
+ expect(() => parseProviderGroupCommand({ action, providerId: 'anthropic', config, expectedConfig }))
+ .toThrow(/INVALID_PARAMS/);
+ }
+ }
+ for (const action of ['save', 'delete']) {
+ expect(() => parseProviderManagementRequest({ action: 'manage-group', command: { action, providerId: 'anthropic', config } }))
+ .toThrow(/UNSUPPORTED_CAPABILITY/);
+ }
+ });
});
describe('executeProviderGroupCommand reads', () => {
@@ -123,8 +168,8 @@ describe('executeProviderGroupCommand reads', () => {
],
};
// 这台电脑读不到 mini 的目录(连不上)。
- const readDeviceCatalog = vi.fn<(agentDeviceId: string) => Promise<never[]>>(async () => {
- throw new Error('[DEVICE_LINK_DEVICE_UNRESPONSIVE] target device mini is unresponsive (circuit open)');
+ const readDeviceCatalog = vi.fn(async (agentDeviceId: string): Promise<never[]> => {
+ throw new Error('[DEVICE_LINK_DEVICE_UNRESPONSIVE] target device ' + agentDeviceId + ' is unresponsive (circuit open)');
});
const marked = await markMembersUnreachableHere(view, { readDeviceCatalog }, 'self');
// 只核对组所在电脑看着能用、由这台直连的「我的其他电脑」:组所在电脑自己、本机这台、冷却中的都不读。
@@ -139,12 +184,12 @@ describe('executeProviderGroupCommand reads', () => {
expect(marked.members[1]).toMatchObject({ state: 'available', running: 2 });
});
- it('leaves another computer’s group as it is when this computer can reach it or cannot tell', async () => {
- const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL, MINI] };
+ it.each([MINI, SHARED])('leaves a reachable $kind member unchanged, and skips probing before login', async (member) => {
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL, member] };
const view = {
providerId: 'anthropic',
config,
- members: [{ key: MINI.key, kind: 'device' as const, label: 'mini', state: 'available' as const, running: 0, limit: 4, weight: 1, paused: false }],
+ members: [{ key: member.key, kind: member.kind, label: 'member', state: 'available' as const, running: 0, limit: 4, weight: 1, paused: false }],
};
const reachable = vi.fn(async () => []);
expect(await markMembersUnreachableHere(view, { readDeviceCatalog: reachable }, 'self')).toBe(view);
@@ -154,14 +199,28 @@ describe('executeProviderGroupCommand reads', () => {
expect(unused).not.toHaveBeenCalled();
});
- it('does not hold the group view on a slow computer, and does not mark it', async () => {
+ it.each(['available', 'full'] as const)('marks a shared member reported as %s when it is unavailable on this computer', async (state) => {
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL, SHARED] };
+ const view = {
+ providerId: 'anthropic', config,
+ members: [{ key: SHARED.key, kind: SHARED.kind, label: 'Kai', state, running: 4, limit: 4, weight: 1, paused: false }],
+ };
+ // 分享按账号收到,跨区连接却按电脑启用:组所在电脑能用,不代表查看电脑也能直连。
+ const readDeviceCatalog = vi.fn(async () => { throw new Error('[REMOTE_AGENT_SHARE_REMOVED] share not found'); });
+ const result = await markMembersUnreachableHere(view, { readDeviceCatalog }, 'self');
+ expect(readDeviceCatalog).toHaveBeenCalledExactlyOnceWith('share:s1');
+ expect(result.members[0]).toEqual({ ...view.members[0], unreachableHere: true });
+ expect(view.members[0]).not.toHaveProperty('unreachableHere');
+ });
+
+ it.each([MINI, SHARED])('does not hold the group view on a slow $kind member, and does not mark it', async (member) => {
vi.useFakeTimers();
try {
- const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL, MINI] };
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL, member] };
const view = {
providerId: 'anthropic',
config,
- members: [{ key: MINI.key, kind: 'device' as const, label: 'mini', state: 'available' as const, running: 0, limit: 4, weight: 1, paused: false }],
+ members: [{ key: member.key, kind: member.kind, label: 'member', state: 'available' as const, running: 0, limit: 4, weight: 1, paused: false }],
};
// 读目录一直没有结果(还没超时、熔断也还没打开)。
const slow = vi.fn(() => new Promise<never[]>(() => undefined));
@@ -183,7 +242,186 @@ describe('executeProviderGroupCommand reads', () => {
});
});
+describe('provider group IPC remote management', () => {
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL, MINI] };
+ const view = {
+ providerId: 'anthropic', config,
+ members: [{ key: MINI.key, kind: 'device' as const, label: 'mini', state: 'available' as const, running: 2, limit: 4, weight: 1, paused: false }],
+ };
+ const groupRequests: ProviderManagementRequest[] = [
+ { action: 'manage-group', command: { action: 'get', providerId: 'anthropic' } },
+ { action: 'manage-group', command: { action: 'save-if-current', providerId: 'anthropic', config, expectedConfig: config } },
+ ];
+ // 走真正注册的 IPC listener,确保进入管理页的路径也使用查看端可达性投影。
+ function invokeRemoteCommand(
+ d: ProviderGroupCommandDeps,
+ remoteManage: (deviceId: string, request: ProviderManagementRequest) => Promise<unknown>,
+ request: ProviderManagementRequest,
+ ) {
+ vi.mocked(activeOwnerScopeKey).mockImplementation(d.ownerKey);
+ vi.mocked(getProviderGroupDirectory).mockReturnValue(d.directory);
+ vi.mocked(getProviderGroupRouter).mockReturnValue(d.router);
+ vi.mocked(invokeProviderManagement).mockImplementation((_invoke, deviceId, command) => remoteManage(deviceId, command));
+ registerProviderGroupIpc();
+ const listener = vi.mocked(ipcMain.handle).mock.calls.at(-1)![1];
+ return listener({} as IpcMainInvokeEvent, { action: 'remote-manage', deviceId: 'group-host', request });
+ }
+
+ afterEach(() => vi.mocked(activeOwnerScopeKey).mockReturnValue('owner-a'));
+
+ it.each(['entry', 'remote reply', 'reachability read'])('rejects management when teardown starts at %s without changing the owner key', async (stage) => {
+ const d = deps([]);
+ const remoteManage = vi.fn(async () => {
+ if (stage === 'remote reply') vi.mocked(isAppSessionBoundaryPending).mockReturnValue(true);
+ return view;
+ });
+ const readDeviceCatalog = vi.fn(async () => {
+ vi.mocked(isAppSessionBoundaryPending).mockReturnValue(true);
+ return [];
+ });
+ Object.assign(d, { directory: { ...d.directory, readDeviceCatalog } });
+ if (stage === 'entry') vi.mocked(isAppSessionBoundaryPending).mockReturnValue(true);
+ await expect(invokeRemoteCommand(d, remoteManage, groupRequests[0])).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(remoteManage).toHaveBeenCalledTimes(stage === 'entry' ? 0 : 1);
+ expect(readDeviceCatalog).toHaveBeenCalledTimes(stage === 'reachability read' ? 1 : 0);
+ });
+
+ it.each(groupRequests)('marks unreachable members in a remote $command.action result without changing the group state', async (request) => {
+ const d = deps([]);
+ const remoteManage = vi.fn(async () => view);
+ const readDeviceCatalog = vi.fn(async () => { throw new Error('unreachable from this computer'); });
+ Object.assign(d, { directory: { ...d.directory, readDeviceCatalog } });
+ const result = await invokeRemoteCommand(d, remoteManage, request);
+ expect(remoteManage).toHaveBeenCalledExactlyOnceWith('group-host', request);
+ expect(readDeviceCatalog).toHaveBeenCalledExactlyOnceWith('mini');
+ expect(result).toMatchObject({ members: [{ key: MINI.key, state: 'available', running: 2, unreachableHere: true }] });
+ expect(view.members[0]).not.toHaveProperty('unreachableHere');
+ });
+
+ it.each(groupRequests)('probes shared members from this computer after remote $command.action', async (request) => {
+ const d = deps([]);
+ const sharedView = {
+ ...view, config: { ...config, members: [LOCAL, SHARED] },
+ members: [{ ...view.members[0], key: SHARED.key, kind: SHARED.kind, state: 'full' as const }],
+ };
+ const remoteManage = vi.fn(async () => sharedView);
+ const readDeviceCatalog = vi.fn(async () => { throw new Error('share is unavailable from this computer'); });
+ Object.assign(d, { directory: { ...d.directory, readDeviceCatalog } });
+ const result = await invokeRemoteCommand(d, remoteManage, request);
+ expect(readDeviceCatalog).toHaveBeenCalledExactlyOnceWith('share:s1');
+ expect(result).toMatchObject({ members: [{ key: SHARED.key, state: 'full', running: 2, unreachableHere: true }] });
+ expect(sharedView.members[0]).not.toHaveProperty('unreachableHere');
+ });
+
+ it('keeps candidates and share management results unchanged, and accepts a deleted group without probing members', async () => {
+ const d = deps([]);
+ const readDeviceCatalog = vi.fn();
+ const remoteManage = vi.fn();
+ Object.assign(d, { directory: { ...d.directory, readDeviceCatalog } });
+ const cases: { request: ProviderManagementRequest; result: unknown }[] = [
+ { request: { action: 'manage-group', command: { action: 'candidates', providerId: 'anthropic' } }, result: [] },
+ { request: { action: 'manage-share', command: { action: 'owned', range: '7d' } }, result: { ready: true, shares: [] } },
+ { request: { action: 'manage-group', command: { action: 'delete-if-current', providerId: 'anthropic', expectedConfig: config } }, result: { providerId: 'anthropic', config: null, members: [] } },
+ ];
+ for (const { request, result } of cases) {
+ remoteManage.mockResolvedValueOnce(result);
+ expect(await invokeRemoteCommand(d, remoteManage, request)).toEqual(result);
+ }
+ expect(remoteManage).toHaveBeenCalledTimes(3);
+ expect(readDeviceCatalog).not.toHaveBeenCalled();
+ });
+
+ it.each(['remote reply', 'reachability read'])('drops a remote group view when the account changes during %s', async (stage) => {
+ const d = deps([]);
+ const remoteManage = vi.fn(async () => {
+ if (stage === 'remote reply') d.switchOwner('owner-b');
+ return view;
+ });
+ const readDeviceCatalog = vi.fn(async () => {
+ d.switchOwner('owner-b');
+ return [];
+ });
+ Object.assign(d, { directory: { ...d.directory, readDeviceCatalog } });
+ await expect(invokeRemoteCommand(d, remoteManage, groupRequests[0]))
+ .rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(readDeviceCatalog).toHaveBeenCalledTimes(stage === 'remote reply' ? 0 : 1);
+ });
+});
+
describe('executeProviderGroupCommand save', () => {
+ it.each(['save-if-current', 'delete-if-current'] as const)('refuses %s before any work while the old owner is being torn down', async (action) => {
+ const d = deps([]);
+ vi.mocked(isAppSessionBoundaryPending).mockReturnValue(true);
+ await expect(executeProviderGroupCommand(d, {
+ action, providerId: 'anthropic', expectedConfig: null,
+ config: { strategy: 'least', autoSwitch: true, members: [LOCAL] },
+ })).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(d.directory.listCandidates).not.toHaveBeenCalled();
+ expect(d.writeGroup).not.toHaveBeenCalled();
+ expect(d.pruneBindings).not.toHaveBeenCalled();
+ });
+
+ it('does not save when teardown starts during candidate lookup with the owner key unchanged', async () => {
+ const candidate = { key: MINI.key, kind: 'device' as const, agentDeviceId: 'mini', providerId: MINI.providerId, label: 'Mac mini', providerName: 'Claude' };
+ const d = deps([candidate]);
+ vi.mocked(d.directory.listCandidates).mockImplementationOnce(async () => {
+ vi.mocked(isAppSessionBoundaryPending).mockReturnValue(true);
+ return [candidate];
+ });
+ await expect(executeProviderGroupCommand(d, {
+ action: 'save-if-current', providerId: 'anthropic', expectedConfig: null,
+ config: { strategy: 'least', autoSwitch: true, members: [LOCAL, MINI] },
+ })).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(d.writeGroup).not.toHaveBeenCalled();
+ expect(d.pruneBindings).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ ['save-if-current', 'write'], ['save-if-current', 'prune'], ['save-if-current', 'view'],
+ ['delete-if-current', 'write'], ['delete-if-current', 'prune'], ['delete-if-current', 'view'],
+ ] as const)('stops %s after teardown begins during %s', async (action, stage) => {
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
+ const d = deps([], config);
+ const beginBoundary = () => vi.mocked(isAppSessionBoundaryPending).mockReturnValue(true);
+ if (stage === 'write') d.writeGroup.mockImplementationOnce(async () => { beginBoundary(); return config; });
+ if (stage === 'prune') d.pruneBindings.mockImplementationOnce(async () => { beginBoundary(); });
+ if (stage === 'view') vi.mocked(d.router.view).mockImplementationOnce(async () => { beginBoundary(); return { providerId: 'anthropic', config, members: [] }; });
+ await expect(executeProviderGroupCommand(d, { action, providerId: 'anthropic', config, expectedConfig: config }))
+ .rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(d.pruneBindings).toHaveBeenCalledTimes(stage === 'write' ? 0 : 1);
+ expect(d.changed).toHaveBeenCalledTimes(stage === 'view' ? 1 : 0);
+ expect(d.router.view).toHaveBeenCalledTimes(stage === 'view' ? 1 : 0);
+ });
+
+ it('passes the editing snapshot through candidate validation to the atomic writer', async () => {
+ const initial: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
+ const d = deps([{ key: MINI.key, kind: 'device', agentDeviceId: 'mini', providerId: MINI.providerId, label: 'Mac mini', providerName: 'Claude' }], initial);
+ // 目录读取期间另一个编辑已落盘;最终写入处检查,而不是只在开始时检查。
+ d.writeGroup.mockRejectedValueOnce(new Error('[PROVIDER_GROUP_CHANGED] changed while reading candidates'));
+ await expect(executeProviderGroupCommand(d, {
+ action: 'save-if-current', providerId: 'anthropic', expectedConfig: initial,
+ config: { ...initial, members: [LOCAL, MINI] },
+ })).rejects.toThrow(/PROVIDER_GROUP_CHANGED/);
+ expect(d.directory.listCandidates).toHaveBeenCalled();
+ expect(d.writeGroup).toHaveBeenCalledWith('anthropic', expect.objectContaining({
+ members: [LOCAL, { ...MINI, label: 'Mac mini', providerName: 'Claude' }],
+ }), initial);
+ expect(d.pruneBindings).not.toHaveBeenCalled();
+ expect(d.changed).not.toHaveBeenCalled();
+ });
+
+ it('does not release task bindings when a stale delete is rejected', async () => {
+ const initial: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
+ const d = deps([], initial);
+ d.writeGroup.mockRejectedValueOnce(new Error('[PROVIDER_GROUP_CHANGED] changed before delete'));
+ await expect(executeProviderGroupCommand(d, {
+ action: 'delete-if-current', providerId: 'anthropic', expectedConfig: initial,
+ })).rejects.toThrow(/PROVIDER_GROUP_CHANGED/);
+ expect(d.writeGroup).toHaveBeenCalledWith('anthropic', null, initial);
+ expect(d.pruneBindings).not.toHaveBeenCalled();
+ expect(d.changed).not.toHaveBeenCalled();
+ });
+
it('accepts computers this computer can already use and takes their names from the directory', async () => {
const d = deps([{ key: MINI.key, kind: 'device', agentDeviceId: 'mini', providerId: MINI.providerId, label: 'Mac mini', providerName: 'Claude' }]);
await executeProviderGroupCommand(d, {
@@ -297,3 +535,57 @@ describe('executeProviderGroupCommand save', () => {
expect(d.pruneBindings).not.toHaveBeenCalled();
});
});
+
+describe('provider management receiver account boundary', () => {
+ it('refreshes reshare coordination after a remote group edit without adding local-only consent details to the reply', async () => {
+ const config: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
+ const d = deps([], config);
+ vi.mocked(getProviderGroupDirectory).mockReturnValue(d.directory);
+ vi.mocked(getProviderGroupRouter).mockReturnValue(d.router);
+ vi.mocked(readProviderGroup).mockReturnValue(config);
+ vi.mocked(writeProviderGroup).mockResolvedValue(config);
+ vi.mocked(pruneProviderGroupBindings).mockResolvedValue();
+ const onGroupChanged = vi.fn();
+ const reply = await handleProviderManagementRequest({
+ action: 'manage-group', command: { action: 'save-if-current', providerId: 'anthropic', config, expectedConfig: config },
+ }, { onGroupChanged });
+ expect(onGroupChanged).toHaveBeenCalledExactlyOnceWith('anthropic');
+ expect(reply.result).toEqual({ providerId: 'anthropic', config, members: [] });
+ });
+
+ it('accepts reshare decisions as owner operations and keeps forwarding operations outside the management scope', async () => {
+ const command = { action: 'reshare-decide', id: 'rs-pending', decision: 'approve' } as const;
+ vi.mocked(parseProviderShareCommand).mockReturnValue(command);
+ expect(parseProviderManagementRequest({ action: 'manage-share', command })).toEqual({ action: 'manage-share', command });
+ vi.mocked(executeProviderShareManagementCommand).mockResolvedValueOnce({ ok: true });
+ expect(await handleProviderManagementRequest({ action: 'manage-share', command })).toMatchObject({ result: { ok: true } });
+ expect(executeProviderShareManagementCommand).toHaveBeenLastCalledWith(command);
+ vi.mocked(parseProviderShareCommand).mockReturnValueOnce({ action: 'received' });
+ expect(() => parseProviderManagementRequest({ action: 'manage-share', command: { action: 'received' } }))
+ .toThrow(/PERMISSION_DENIED/);
+ });
+
+ it.each([
+ { action: 'manage-group', command: { action: 'get', providerId: 'anthropic' } },
+ { action: 'manage-share', command: { action: 'owned', range: '7d' } },
+ { action: 'manage-share', command: { action: 'reshare-decide', id: 'rs-pending', decision: 'approve' } },
+ ] satisfies ProviderManagementRequest[])('refuses $action before dispatch when teardown is pending', async (request) => {
+ vi.mocked(getProviderGroupRouter).mockClear();
+ vi.mocked(executeProviderShareManagementCommand).mockClear();
+ vi.mocked(isAppSessionBoundaryPending).mockReturnValue(true);
+ await expect(handleProviderManagementRequest(request)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(getProviderGroupRouter).not.toHaveBeenCalled();
+ expect(executeProviderShareManagementCommand).not.toHaveBeenCalled();
+ });
+
+ it('does not return a successful share response after teardown begins with the same owner key', async () => {
+ const command = { action: 'owned', range: '7d' } as const;
+ vi.mocked(parseProviderShareCommand).mockReturnValueOnce(command);
+ vi.mocked(executeProviderShareManagementCommand).mockImplementationOnce(async () => {
+ vi.mocked(isAppSessionBoundaryPending).mockReturnValue(true);
+ return { ready: true, shares: [] };
+ });
+ await expect(handleProviderManagementRequest({ action: 'manage-share', command }))
+ .rejects.toThrow(/PRECONDITION_FAILED/);
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/managementClient.test.ts b/apps/desktop/src/main/provider-group/__tests__/managementClient.test.ts
new file mode 100644
index 0000000000..ff9eac7780
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/__tests__/managementClient.test.ts
@@ -0,0 +1,194 @@
+/**
+ * 同账号管理的控制端:只转发明确的管理操作;本机生成的链接由本机弹审批窗(provider-sharing.md §4.1 第 4 步)。
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const state = vi.hoisted(() => ({ owner: 'owner-a', boundaryPending: false }));
+const host = vi.hoisted(() => ({ watch: vi.fn(), forget: vi.fn() }));
+const clipboard = vi.hoisted(() => ({ remember: vi.fn() }));
+
+vi.mock('../../appSessionState.js', () => ({
+ activeOwnerScopeKey: () => state.owner,
+ isAppSessionBoundaryPending: () => state.boundaryPending,
+}));
+vi.mock('../../device-link/providerShareHost.js', () => ({
+ watchProviderShareRequests: host.watch,
+ forgetWatchedProviderShareRequest: host.forget,
+}));
+vi.mock('../../textClipboard.js', () => ({ rememberIssuedClipboardText: clipboard.remember }));
+
+import { PROVIDER_GROUP_REMOTE_CHANNEL } from '@cindy/device-link';
+
+import type { ProviderManagementRequest } from '../../../shared/providerManagement';
+import { invokeProviderManagement } from '../managementClient';
+import type { ProviderGroupRemoteInvoke } from '../remoteClient';
+
+function replying(result: unknown): ProviderGroupRemoteInvoke {
+ return vi.fn(async () => ({ ok: true, result: { result, respondedAt: Date.now() } })) as unknown as ProviderGroupRemoteInvoke;
+}
+
+const createLink: ProviderManagementRequest = { action: 'manage-share', command: { action: 'create-link', providerId: 'anthropic' } };
+const LINK_ID = 'a'.repeat(64);
+
+beforeEach(() => {
+ state.owner = 'owner-a';
+ state.boundaryPending = false;
+ host.watch.mockReset();
+ host.forget.mockReset();
+ clipboard.remember.mockReset();
+});
+
+describe('provider management client', () => {
+ it('does not dispatch management while account teardown is pending with the same owner key', async () => {
+ state.boundaryPending = true;
+ const invoke = replying(null);
+ await expect(invokeProviderManagement(invoke, 'group-host', createLink)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(invoke).not.toHaveBeenCalled();
+ });
+
+ it('rechecks the account boundary after waiting to send', async () => {
+ const send = vi.fn();
+ const invoke: ProviderGroupRemoteInvoke = async (_deviceId, _channel, _args, options) => {
+ state.boundaryPending = true;
+ options?.preSend?.();
+ send();
+ return { ok: true };
+ };
+ await expect(invokeProviderManagement(invoke, 'group-host', createLink)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(send).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ createLink,
+ { action: 'manage-share', command: { action: 'approve', requestId: 'r1' } },
+ ] satisfies ProviderManagementRequest[])('drops a $command.action reply during teardown before changing local state', async (request) => {
+ const invoke: ProviderGroupRemoteInvoke = async () => {
+ state.boundaryPending = true;
+ return { ok: true, result: { result: { link: 'https://cindy.app/s#test', linkId: LINK_ID, expiresAt: new Date(Date.now() + 60_000).toISOString() }, respondedAt: Date.now() } };
+ };
+ await expect(invokeProviderManagement(invoke, 'group-host', request)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(host.watch).not.toHaveBeenCalled();
+ expect(host.forget).not.toHaveBeenCalled();
+ expect(clipboard.remember).not.toHaveBeenCalled();
+ });
+
+ it('watches the group computer\'s share after generating a link there, so the request prompts here', async () => {
+ const expiresAt = new Date(Date.now() + 60_000).toISOString();
+ const invoke = replying({ link: 'https://cindy.app/s#token', linkId: LINK_ID, expiresAt });
+ const snapshot = { ready: true, shares: [{ shareId: 'share-1', providerId: 'anthropic', providerLabel: 'Anthropic', requests: [] }] };
+ const readInvoke = replying(snapshot);
+ const created = await invokeProviderManagement(invoke, 'group-host', createLink, readInvoke) as { link: string };
+ expect(invoke).toHaveBeenCalledWith('group-host', PROVIDER_GROUP_REMOTE_CHANNEL, [createLink], expect.anything());
+ expect(created.link).toBe('https://cindy.app/s#token');
+ expect(clipboard.remember).toHaveBeenCalledWith('https://cindy.app/s#token', expect.any(String));
+ expect(host.watch).toHaveBeenCalledWith('group-host', 'anthropic', LINK_ID, expect.any(Function));
+ const readShares = host.watch.mock.calls[0][3];
+ await expect(readShares()).resolves.toEqual(snapshot.shares);
+ expect(invoke).toHaveBeenCalledTimes(1);
+ expect(readInvoke).toHaveBeenCalledWith('group-host', PROVIDER_GROUP_REMOTE_CHANNEL, [
+ { action: 'manage-share', command: { action: 'owned', range: '7d' } },
+ ], expect.anything());
+ vi.mocked(readInvoke).mockResolvedValue({ ok: true, result: { result: { ready: false, shares: [] }, respondedAt: Date.now() } });
+ await expect(readShares()).rejects.toThrow(/PRECONDITION_FAILED/);
+ });
+
+ it('does not watch when the link response is invalid or the account changed on the way', async () => {
+ await expect(invokeProviderManagement(replying({ link: '', linkId: LINK_ID }), 'group-host', createLink)).rejects.toThrow(/PRECONDITION_FAILED/);
+ const switching = vi.fn(async () => {
+ state.owner = 'owner-b';
+ return { ok: true, result: { result: { link: 'x', linkId: LINK_ID, expiresAt: new Date().toISOString() }, respondedAt: Date.now() } };
+ }) as unknown as ProviderGroupRemoteInvoke;
+ await expect(invokeProviderManagement(switching, 'group-host', createLink)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(host.watch).not.toHaveBeenCalled();
+ expect(clipboard.remember).not.toHaveBeenCalled();
+ });
+
+ it.each([undefined, 'not-a-digest', 'A'.repeat(64), null])('does not copy or watch a remote link with invalid linkId %s', async (linkId) => {
+ const invoke = replying({ link: 'https://cindy.app/s#test', linkId, expiresAt: new Date(Date.now() + 60_000).toISOString() });
+ await expect(invokeProviderManagement(invoke, 'group-host', createLink))
+ .rejects.toThrow(linkId === undefined ? /UNSUPPORTED_CAPABILITY/ : /PRECONDITION_FAILED/);
+ expect(host.watch).not.toHaveBeenCalled();
+ expect(clipboard.remember).not.toHaveBeenCalled();
+ expect(invoke).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not register a link for copying until its approval watch has been saved', async () => {
+ let finishSave!: () => void;
+ host.watch.mockImplementationOnce(() => new Promise<void>((resolve) => { finishSave = resolve; }));
+ const invoke = replying({ link: 'https://cindy.app/s#test', linkId: LINK_ID, expiresAt: new Date(Date.now() + 60_000).toISOString() });
+ const creating = invokeProviderManagement(invoke, 'group-host', createLink);
+ await vi.waitFor(() => expect(host.watch).toHaveBeenCalledTimes(1));
+ expect(clipboard.remember).not.toHaveBeenCalled();
+ finishSave();
+ await expect(creating).resolves.toMatchObject({ link: 'https://cindy.app/s#test' });
+ expect(clipboard.remember).toHaveBeenCalledTimes(1);
+ expect(invoke).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not subtract link creation time before the remote response', async () => {
+ let now = 100_000;
+ const nowSpy = vi.spyOn(Date, 'now').mockImplementation(() => now);
+ try {
+ const invoke: ProviderGroupRemoteInvoke = vi.fn(async () => {
+ now = 200_000;
+ return {
+ ok: true,
+ result: {
+ result: { link: 'https://cindy.app/s#slow', linkId: LINK_ID, expiresAt: new Date(1_300_000).toISOString() },
+ respondedAt: 1_000_000,
+ },
+ };
+ }) as unknown as ProviderGroupRemoteInvoke;
+ host.watch.mockImplementationOnce(async () => {
+ now = 230_000;
+ });
+
+ await expect(invokeProviderManagement(invoke, 'group-host', createLink)).resolves.toMatchObject({
+ link: 'https://cindy.app/s#slow',
+ });
+ expect(clipboard.remember).toHaveBeenCalledWith(
+ 'https://cindy.app/s#slow',
+ new Date(500_000).toISOString(),
+ );
+ } finally {
+ nowSpy.mockRestore();
+ }
+ });
+
+ it('does not register or return a link when saving its approval watch fails', async () => {
+ host.watch.mockRejectedValueOnce(new Error('[PRECONDITION_FAILED] approval setup failed'));
+ const invoke = replying({ link: 'https://cindy.app/s#test', linkId: LINK_ID, expiresAt: new Date(Date.now() + 60_000).toISOString() });
+ await expect(invokeProviderManagement(invoke, 'group-host', createLink)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(clipboard.remember).not.toHaveBeenCalled();
+ expect(invoke).toHaveBeenCalledTimes(1);
+ });
+
+ it('drops a watched request once it is approved or rejected here, but not when the group computer refused', async () => {
+ await invokeProviderManagement(replying({ ok: true }), 'group-host', { action: 'manage-share', command: { action: 'approve', requestId: 'r1' } });
+ await invokeProviderManagement(replying({ ok: true }), 'group-host', { action: 'manage-share', command: { action: 'reject', requestId: 'r2' } });
+ expect(host.forget.mock.calls).toEqual([['r1'], ['r2']]);
+
+ const refused = vi.fn(async () => ({ ok: false, error: { code: 'IPC_ERROR', message: '[NOT_FOUND] gone' } })) as unknown as ProviderGroupRemoteInvoke;
+ await expect(invokeProviderManagement(refused, 'group-host', { action: 'manage-share', command: { action: 'approve', requestId: 'r3' } }))
+ .rejects.toThrow('[NOT_FOUND] gone');
+ expect(host.forget).toHaveBeenCalledTimes(2);
+ });
+
+ it('reports an old group computer as needing an update', async () => {
+ const old = vi.fn(async () => ({ ok: false, error: { code: 'IPC_ERROR', message: '[INVALID_PARAMS] unknown provider group action' } })) as unknown as ProviderGroupRemoteInvoke;
+ await expect(invokeProviderManagement(old, 'group-host', createLink)).rejects.toThrow(/UNSUPPORTED_CAPABILITY/);
+ expect(host.watch).not.toHaveBeenCalled();
+ });
+
+ it('forwards conditional writes and never retries a conflict or falls back to an unconditional old-host write', async () => {
+ const request: ProviderManagementRequest = {
+ action: 'manage-group', command: { action: 'delete-if-current', providerId: 'anthropic', expectedConfig: null },
+ };
+ const conflict = vi.fn(async () => ({ ok: false, error: { code: 'IPC_ERROR', message: '[PROVIDER_GROUP_CHANGED] changed' } })) as unknown as ProviderGroupRemoteInvoke;
+ await expect(invokeProviderManagement(conflict, 'group-host', request)).rejects.toThrow('[PROVIDER_GROUP_CHANGED]');
+ expect(conflict).toHaveBeenCalledExactlyOnceWith('group-host', PROVIDER_GROUP_REMOTE_CHANNEL, [request], expect.anything());
+ const old = vi.fn(async () => ({ ok: false, error: { code: 'IPC_ERROR', message: '[INVALID_PARAMS] unknown provider group action' } })) as unknown as ProviderGroupRemoteInvoke;
+ await expect(invokeProviderManagement(old, 'group-host', request)).rejects.toThrow(/UNSUPPORTED_CAPABILITY/);
+ expect(old).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
index 455fc641c1..74b8268bea 100644
--- a/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/remoteHandler.test.ts
@@ -522,7 +522,7 @@ describe('完整用量报告分批传输', () => {
});
describe('decorateProviderListWithGroups', () => {
- it('adds the group summary only to providers that have a group and stay open for remote use', () => {
+ it('adds group summaries even when remote use is closed, while keeping running counts restricted', () => {
const result = decorateProviderListWithGroups({
providers: [
{ id: 'anthropic', remoteInvocationEnabled: true },
@@ -540,9 +540,9 @@ describe('decorateProviderListWithGroups', () => {
{ key: MINI.key, kind: 'device', agentDeviceId: 'mini', providerId: MINI.providerId, label: 'Mini', paused: false },
],
});
- // 只有本机设置能产生组摘要;没开放的不带。
+ // 只有本机设置能产生组摘要;关闭远程调用的组仍需保留管理入口。
expect(result.providers[1]).not.toHaveProperty('group');
- expect(result.providers[2]).not.toHaveProperty('group');
+ expect(result.providers[2].group).toEqual(result.providers[0].group);
});
it('leaves the sharer’s computer name out of shared members', () => {
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 738b8aaa60..71f5bf8e03 100644
--- a/apps/desktop/src/main/provider-group/__tests__/stores.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/stores.test.ts
@@ -7,6 +7,8 @@ import path from 'node:path';
import { afterAll, afterEach, describe, expect, it, vi } from 'vitest';
+const scope = vi.hoisted(() => ({ boundaryPending: false }));
+
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'provider-group-store-test-'));
let activeOwner = 'owner-test';
@@ -17,16 +19,71 @@ vi.mock('../../maker-host/logger-adapter.js', () => ({
vi.mock('../../appSessionState.js', () => ({
ownerScopedUserDataPath: (name: string) => activeOwner === 'owner-test' ? path.join(tmpDir, name) : path.join(tmpDir, activeOwner, name),
activeOwnerScopeKey: () => activeOwner,
+ isAppSessionBoundaryPending: () => scope.boundaryPending,
}));
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(); });
+afterEach(() => { scope.boundaryPending = false; activeOwner = 'owner-test'; vi.restoreAllMocks(); });
afterAll(async () => { await fs.promises.rm(tmpDir, { recursive: true, force: true }); });
describe('provider group store', () => {
+ it.each(['save', 'delete'])('does not %s when teardown starts before the file lock is acquired', async (action) => {
+ const initial = (await store.writeProviderGroup('boundary', { members: [{ kind: 'local' }] }))!;
+ const pending = store.writeProviderGroup('boundary', action === 'delete' ? null : { ...initial, autoSwitch: false }, initial);
+ // updateAtomic 已开始等待写锁,但 owner key 尚未推进。
+ scope.boundaryPending = true;
+ await expect(pending).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(store.readProviderGroup('boundary')).toEqual(initial);
+ });
+
+ it.each(['remove', 'delete'].flatMap((action) => ['owner', 'teardown'].map((boundary) => ({ action, boundary }))))(
+ 'keeps committed $action cleanup through $boundary, restart and rejoin', async ({ action, boundary }) => {
+ const providerId = `committed-${action}-${boundary}`;
+ const sessionId = `${providerId}-task`;
+ const initial = (await store.writeProviderGroup(providerId, {
+ members: [{ kind: 'local' }, { kind: 'device', agentDeviceId: 'mini', providerId }],
+ }))!;
+ const removedKey = initial.members[1].key;
+ await bindings.writeProviderGroupBinding(sessionId, { providerId, memberKey: removedKey }, 1);
+ await bindings.writeProviderGroupBinding(`${sessionId}-kept`, { providerId, memberKey: 'local' }, 1);
+ const withLock = locks.withCrossProcessLock;
+ vi.spyOn(locks, 'withCrossProcessLock').mockImplementationOnce(async (...args) => {
+ const result = await withLock(...args);
+ if (boundary === 'owner') activeOwner = 'new-owner';
+ else scope.boundaryPending = true;
+ return result;
+ });
+ const next = action === 'delete' ? null : { ...initial, members: [initial.members[0]] };
+ await expect(store.writeProviderGroup(providerId, next)).rejects.toThrow(/PRECONDITION_FAILED/);
+ if (boundary === 'owner') {
+ expect(store.readProviderGroup(providerId)).toBeNull();
+ expect(bindings.readProviderGroupBinding(sessionId)).toBeNull();
+ expect(bindings.isProviderGroupReleased(sessionId, { providerId })).toBe(false);
+ }
+ activeOwner = 'owner-test';
+ scope.boundaryPending = false;
+ expect(store.readProviderGroup(providerId)).toEqual(next);
+ // 模拟请求被账号边界拒绝,IPC 根本没有执行 pruneBindings;切回后先把成员加回来。
+ await store.writeProviderGroup(providerId, initial);
+ vi.resetModules();
+ const restarted = await import('../bindings.js');
+ expect(restarted.readProviderGroupBinding(sessionId)).toBeNull();
+ expect(restarted.isProviderGroupReleased(sessionId, { providerId })).toBe(true);
+ expect(restarted.listProviderGroupBindings()[sessionId]).toBeUndefined();
+ expect(restarted.isProviderGroupReleased(`${sessionId}-kept`, { providerId })).toBe(action === 'delete');
+ // 新分配先完成旧清理,不能把新绑定吞掉;原任务只有显式重新分配才回到组里。
+ await restarted.writeProviderGroupBinding(`${sessionId}-new`, { providerId, memberKey: removedKey }, 2);
+ expect(restarted.readProviderGroupBinding(`${sessionId}-new`)).not.toBeNull();
+ expect(restarted.isProviderGroupReleased(sessionId, { providerId })).toBe(true);
+ await restarted.writeProviderGroupBinding(sessionId, { providerId, memberKey: removedKey }, 3);
+ expect(restarted.readProviderGroupBinding(sessionId)).not.toBeNull();
+ expect(restarted.isProviderGroupReleased(sessionId, { providerId })).toBe(false);
+ },
+ );
+
it('drops invalid groups and empty groups when reading', () => {
expect(store.__testing.normalize({
groups: {
@@ -56,6 +113,43 @@ describe('provider group store', () => {
expect(store.readProviderGroup('anthropic')).toBeNull();
});
+ it('preserves another editor’s members and limits instead of overwriting them with an old snapshot', async () => {
+ const initial = (await store.writeProviderGroup('stale', { members: [{ kind: 'local' }] }))!;
+ const updated = (await store.writeProviderGroup('stale', {
+ ...initial,
+ members: [{ ...initial.members[0], limit: 8 }, { kind: 'device', agentDeviceId: 'mini', providerId: 'stale' }],
+ }, initial))!;
+ await expect(store.writeProviderGroup('stale', { ...initial, autoSwitch: false }, initial))
+ .rejects.toThrow('[PROVIDER_GROUP_CHANGED]');
+ await expect(store.writeProviderGroup('stale', null, initial)).rejects.toThrow('[PROVIDER_GROUP_CHANGED]');
+ expect(store.readProviderGroup('stale')).toEqual(updated);
+ // 重新读取后由用户再次修改,保留另一台已添加的电脑和上限。
+ const saved = await store.writeProviderGroup('stale', { ...updated, autoSwitch: false }, updated);
+ expect(saved).toEqual({ ...updated, autoSwitch: false });
+ });
+
+ it('compares under the file lock so only one of two concurrent edits can use the same snapshot', async () => {
+ const initial = (await store.writeProviderGroup('concurrent', { members: [{ kind: 'local' }] }))!;
+ const edits = [{ ...initial, autoSwitch: false }, { ...initial, strategy: 'round' as const }];
+ const results = await Promise.allSettled(edits.map((config) => store.writeProviderGroup('concurrent', config, initial)));
+ expect(results.filter((result) => result.status === 'fulfilled')).toHaveLength(1);
+ expect(results.filter((result) => result.status === 'rejected')).toEqual([
+ expect.objectContaining({ reason: expect.objectContaining({ code: 'PROVIDER_GROUP_CHANGED' }) }),
+ ]);
+ expect(store.readProviderGroup('concurrent')).toEqual(edits[results.findIndex((result) => result.status === 'fulfilled')]);
+ });
+
+ it('protects concurrent creation and does not recreate a group deleted after it was read', async () => {
+ const config = { members: [{ kind: 'local' }] };
+ const created = await store.writeProviderGroup('creation', config, null);
+ await expect(store.writeProviderGroup('creation', { ...config, autoSwitch: false }, null))
+ .rejects.toThrow('[PROVIDER_GROUP_CHANGED]');
+ expect(store.readProviderGroup('creation')).toEqual(created);
+ await store.writeProviderGroup('creation', null, created);
+ await expect(store.writeProviderGroup('creation', created, created)).rejects.toThrow('[PROVIDER_GROUP_CHANGED]');
+ expect(store.readProviderGroup('creation')).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);
@@ -101,9 +195,175 @@ describe('provider group store', () => {
fs.writeFileSync(file, previous);
}
});
+
+ it('retains every removed member across rejoin and ignores an older cleanup acknowledgement', async () => {
+ const providerId = 'successive-cleanups';
+ const initial = (await store.writeProviderGroup(providerId, { members: [
+ { kind: 'local' },
+ { kind: 'device', agentDeviceId: 'mini', providerId },
+ { kind: 'device', agentDeviceId: 'studio', providerId },
+ ] }))!;
+ for (const member of initial.members) {
+ await bindings.writeProviderGroupBinding(`successive-${member.kind === 'local' ? 'local' : member.agentDeviceId}`,
+ { providerId, memberKey: member.key }, 1);
+ }
+ await store.writeProviderGroup(providerId, { ...initial, members: [initial.members[0], initial.members[2]] });
+ const first = store.listProviderGroupBindingCleanups()[providerId];
+ await store.writeProviderGroup(providerId, initial);
+ expect(store.listProviderGroupBindingCleanups()[providerId].token).toBe(first.token);
+ await store.writeProviderGroup(providerId, { ...initial, members: [initial.members[0], initial.members[1]] });
+ const second = store.listProviderGroupBindingCleanups()[providerId];
+ expect(second.token).not.toBe(first.token);
+ await store.completeProviderGroupBindingCleanup(providerId, first.token);
+ expect(store.listProviderGroupBindingCleanups()[providerId].token).toBe(second.token);
+ expect(bindings.readProviderGroupBinding('successive-local')).not.toBeNull();
+ expect(bindings.readProviderGroupBinding('successive-mini')).toBeNull();
+ expect(bindings.readProviderGroupBinding('successive-studio')).toBeNull();
+ await bindings.writeProviderGroupBinding('successive-new', { providerId, memberKey: 'local' }, 2);
+ expect(bindings.isProviderGroupReleased('successive-mini', { providerId })).toBe(true);
+ expect(bindings.isProviderGroupReleased('successive-studio', { providerId })).toBe(true);
+ expect(store.listProviderGroupBindingCleanups()[providerId]).toBeUndefined();
+ });
+
+ it('keeps the committed cleanup active if writing the binding release fails', async () => {
+ const providerId = 'pending-write-failure';
+ const config = (await store.writeProviderGroup(providerId, { members: [{ kind: 'local' }] }))!;
+ await bindings.writeProviderGroupBinding('pending-old', { providerId, memberKey: 'local' }, 1);
+ await store.writeProviderGroup(providerId, null);
+ await store.writeProviderGroup(providerId, config);
+ const pending = store.listProviderGroupBindingCleanups()[providerId];
+ const file = path.join(tmpDir, 'provider-group-bindings.json');
+ const before = fs.readFileSync(file, 'utf8');
+ const rename = fs.renameSync;
+ vi.spyOn(fs, 'renameSync').mockImplementation((source, target) => {
+ if (target === file) throw new Error('disk unavailable');
+ rename(source, target);
+ });
+ await expect(bindings.writeProviderGroupBinding('pending-new', { providerId, memberKey: 'local' }, 2))
+ .rejects.toThrow('disk unavailable');
+ expect(fs.readFileSync(file, 'utf8')).toBe(before);
+ expect(store.listProviderGroupBindingCleanups()[providerId]).toEqual(pending);
+ expect(bindings.readProviderGroupBinding('pending-old')).toBeNull();
+ expect(bindings.isProviderGroupReleased('pending-old', { providerId })).toBe(true);
+ vi.restoreAllMocks();
+ await bindings.writeProviderGroupBinding('pending-new', { providerId, memberKey: 'local' }, 2);
+ expect(store.listProviderGroupBindingCleanups()[providerId]).toBeUndefined();
+ expect(bindings.isProviderGroupReleased('pending-old', { providerId })).toBe(true);
+ expect(bindings.readProviderGroupBinding('pending-new')).not.toBeNull();
+ });
+
+ it('retains pending binding cleanup through an older group-settings writer', async () => {
+ const providerId = 'legacy-pending';
+ const config = (await store.writeProviderGroup(providerId, { members: [{ kind: 'local' }] }))!;
+ await bindings.writeProviderGroupBinding('legacy-pending-task', { providerId, memberKey: 'local' }, 1);
+ await store.writeProviderGroup(providerId, null);
+ const pending = store.listProviderGroupBindingCleanups()[providerId];
+ const { createOverrideSettingsFile } = await import('../../maker-host/override-settings-file.js');
+ const legacy = createOverrideSettingsFile<{ groups: Record<string, unknown> }>({
+ filePath: () => path.join(tmpDir, 'provider-group-prefs.json'),
+ defaults: { groups: {} },
+ normalize: (raw) => ({ groups: (raw as { groups?: Record<string, unknown> })?.groups ?? {} }),
+ log: { info: () => {}, warn: () => {} },
+ label: 'legacy-provider-group',
+ });
+ legacy.writePatch({ groups: { ...legacy.read().groups, [providerId]: config } });
+ vi.resetModules();
+ const restarted = await import('../bindings.js');
+ expect(store.listProviderGroupBindingCleanups()[providerId]).toEqual(pending);
+ expect(restarted.readProviderGroupBinding('legacy-pending-task')).toBeNull();
+ expect(restarted.isProviderGroupReleased('legacy-pending-task', { providerId })).toBe(true);
+ });
+
+ it('replays an unacknowledged cleanup if teardown begins after the release was committed', async () => {
+ const providerId = 'pending-ack';
+ const config = (await store.writeProviderGroup(providerId, { members: [{ kind: 'local' }] }))!;
+ await bindings.writeProviderGroupBinding('pending-ack-old', { providerId, memberKey: 'local' }, 1);
+ await store.writeProviderGroup(providerId, null);
+ const pending = store.listProviderGroupBindingCleanups()[providerId];
+ const withLock = locks.withCrossProcessLock;
+ let interrupted = false;
+ vi.spyOn(locks, 'withCrossProcessLock').mockImplementation(async (...args) => {
+ const result = await withLock(...args);
+ if (!interrupted && args[0].endsWith('provider-group-bindings.json.lock')) {
+ interrupted = true;
+ scope.boundaryPending = true;
+ }
+ return result;
+ });
+ await expect(bindings.pruneProviderGroupBindings(providerId, null)).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(store.listProviderGroupBindingCleanups()[providerId]).toEqual(pending);
+ const file = JSON.parse(fs.readFileSync(path.join(tmpDir, 'provider-group-bindings.json'), 'utf8'));
+ expect(file.released['pending-ack-old'].providerId).toBe(providerId);
+ scope.boundaryPending = false;
+ await store.writeProviderGroup(providerId, config);
+ await bindings.writeProviderGroupBinding('pending-ack-new', { providerId, memberKey: 'local' }, 2);
+ expect(store.listProviderGroupBindingCleanups()[providerId]).toBeUndefined();
+ expect(bindings.isProviderGroupReleased('pending-ack-old', { providerId })).toBe(true);
+ expect(bindings.readProviderGroupBinding('pending-ack-new')).not.toBeNull();
+ });
+
+ it('does not let a concurrent stale cleanup remove a fresh assignment', async () => {
+ const providerId = 'concurrent-pending';
+ const config = (await store.writeProviderGroup(providerId, { members: [{ kind: 'local' }] }))!;
+ await bindings.writeProviderGroupBinding('concurrent-pending-old', { providerId, memberKey: 'local' }, 1);
+ await store.writeProviderGroup(providerId, null);
+ await store.writeProviderGroup(providerId, config);
+ const withLock = locks.withCrossProcessLock;
+ let queued = false;
+ let startingSecond = false;
+ let second: Promise<void> | undefined;
+ let resumeSecond!: () => void;
+ const pauseSecond = new Promise<void>((resolve) => { resumeSecond = resolve; });
+ vi.spyOn(locks, 'withCrossProcessLock').mockImplementation(async (...args) => {
+ if (args[0].endsWith('provider-group-bindings.json.lock')) {
+ if (!queued) {
+ const result = await withLock(...args);
+ queued = true;
+ // 第一轮已解除旧绑定、尚未确认意图;另一写方此时仍可看到待清理快照。
+ startingSecond = true;
+ second = bindings.writeProviderGroupBinding('concurrent-pending-b', { providerId, memberKey: 'local' }, 3);
+ startingSecond = false;
+ return result;
+ }
+ if (startingSecond) await pauseSecond;
+ }
+ return withLock(...args);
+ });
+ try {
+ await bindings.writeProviderGroupBinding('concurrent-pending-a', { providerId, memberKey: 'local' }, 2);
+ } finally {
+ resumeSecond();
+ }
+ await second;
+ expect(bindings.readProviderGroupBinding('concurrent-pending-a')).not.toBeNull();
+ expect(bindings.readProviderGroupBinding('concurrent-pending-b')).not.toBeNull();
+ expect(bindings.isProviderGroupReleased('concurrent-pending-old', { providerId })).toBe(true);
+ });
+
+ it('does not prune a fresh assignment when an older delete command resumes after group recreation', async () => {
+ const providerId = 'late-delete';
+ const config = (await store.writeProviderGroup(providerId, { members: [{ kind: 'local' }] }))!;
+ await bindings.writeProviderGroupBinding('late-delete-old', { providerId, memberKey: 'local' }, 1);
+ await store.writeProviderGroup(providerId, null);
+ await store.writeProviderGroup(providerId, config);
+ await bindings.writeProviderGroupBinding('late-delete-new', { providerId, memberKey: 'local' }, 2);
+ // 之前的 delete 请求刚从 writeGroup 返回,此时不应再按旧的 null 快照解除新绑定。
+ await bindings.pruneProviderGroupBindings(providerId, null, 3);
+ expect(bindings.isProviderGroupReleased('late-delete-old', { providerId })).toBe(true);
+ expect(bindings.readProviderGroupBinding('late-delete-new')).not.toBeNull();
+ });
});
describe('provider group bindings', () => {
+ it('keeps bindings and release records unchanged when teardown starts during the write-lock wait', async () => {
+ await bindings.writeProviderGroupBinding('boundary-task', { providerId: 'boundary', memberKey: 'local' }, 1);
+ const pending = bindings.pruneProviderGroupBindings('boundary', null);
+ scope.boundaryPending = true;
+ await expect(pending).rejects.toThrow(/PRECONDITION_FAILED/);
+ expect(bindings.readProviderGroupBinding('boundary-task')).toMatchObject({ providerId: 'boundary', memberKey: 'local' });
+ expect(bindings.isProviderGroupReleased('boundary-task', { providerId: 'boundary' })).toBe(false);
+ });
+
it('keeps only well-formed bindings', () => {
expect(bindings.__testing.normalize({
sessions: {
@@ -161,6 +421,43 @@ describe('provider group bindings', () => {
expect(bindings.isProviderGroupReleased('scope-task', { providerId: 'anthropic' })).toBe(false);
activeOwner = 'owner-test';
expect(bindings.readProviderGroupBinding('scope-task')).toBeNull();
+ expect(bindings.isProviderGroupReleased('scope-task', { providerId: 'anthropic' })).toBe(true);
+ // 切回原账号并重建运行时,解除记录仍须保留,不能把任务重新自动纳入。
+ vi.resetModules();
+ const restarted = await import('../bindings.js');
+ expect(restarted.readProviderGroupBinding('scope-task')).toBeNull();
+ expect(restarted.isProviderGroupReleased('scope-task', { providerId: 'anthropic' })).toBe(true);
+ });
+
+ it('persists the release with binding removal if teardown begins during lock release', async () => {
+ await bindings.writeProviderGroupBinding('teardown-release', { providerId: 'boundary-release', memberKey: 'local' }, 1);
+ const withLock = locks.withCrossProcessLock;
+ vi.spyOn(locks, 'withCrossProcessLock').mockImplementationOnce(async (...args) => {
+ const result = await withLock(...args);
+ scope.boundaryPending = true;
+ return result;
+ });
+ await bindings.pruneProviderGroupBindings('boundary-release', null, 10);
+ expect(bindings.readProviderGroupBinding('teardown-release')).toBeNull();
+ expect(bindings.isProviderGroupReleased('teardown-release', { providerId: 'boundary-release' })).toBe(true);
+ const persisted = JSON.parse(fs.readFileSync(path.join(tmpDir, 'provider-group-bindings.json'), 'utf8'));
+ expect(persisted.sessions?.['teardown-release']).toBeUndefined();
+ expect(persisted.released['teardown-release']).toEqual({ providerId: 'boundary-release', at: 10 });
+ });
+
+ it('keeps the binding and release unchanged if the atomic replacement fails', async () => {
+ await bindings.writeProviderGroupBinding('failed-release', { providerId: 'failed-release', memberKey: 'local' }, 1);
+ const file = path.join(tmpDir, 'provider-group-bindings.json');
+ const before = fs.readFileSync(file, 'utf8');
+ const rename = fs.renameSync;
+ vi.spyOn(fs, 'renameSync').mockImplementation((source, target) => {
+ if (target === file) throw new Error('disk unavailable');
+ rename(source, target);
+ });
+ await expect(bindings.pruneProviderGroupBindings('failed-release', null, 10)).rejects.toThrow('disk unavailable');
+ expect(fs.readFileSync(file, 'utf8')).toBe(before);
+ expect(bindings.readProviderGroupBinding('failed-release')).toMatchObject({ providerId: 'failed-release', at: 1 });
+ expect(bindings.isProviderGroupReleased('failed-release', { providerId: 'failed-release' })).toBe(false);
});
it('remembers, per group, the tasks released by removing a computer or deleting the group', async () => {
@@ -202,6 +499,52 @@ describe('provider group bindings', () => {
});
});
+ it('normalizes inline local releases without accepting another computer’s group', () => {
+ expect(bindings.__testing.normalize({
+ sessions: { valid: { providerId: 'anthropic', memberKey: 'local', at: 20 } },
+ released: {
+ valid: { providerId: 'anthropic', at: 10 },
+ remote: { providerId: 'anthropic', groupDeviceId: 'mini', at: 10 },
+ invalid: { providerId: 'bad id', at: 10 },
+ },
+ })).toEqual({ sessions: {}, released: { valid: { providerId: 'anthropic', at: 10 } } });
+ });
+
+ it('retains inline releases through an older writer and clears them on explicit reassignment', async () => {
+ await bindings.writeProviderGroupBinding('legacy-release', { providerId: 'legacy-group', memberKey: 'local' }, 1);
+ await bindings.pruneProviderGroupBindings('legacy-group', null, 10);
+ const { createOverrideSettingsFile } = await import('../../maker-host/override-settings-file.js');
+ // 旧版本只认识 sessions;共享存储基座仍须原样保留未知 released 根字段。
+ const legacy = createOverrideSettingsFile<{ sessions: Record<string, unknown> }>({
+ filePath: () => path.join(tmpDir, 'provider-group-bindings.json'),
+ defaults: { sessions: {} },
+ normalize: (raw) => ({ sessions: (raw as { sessions?: Record<string, unknown> }).sessions ?? {} }),
+ label: 'legacy-bindings',
+ log: { info: () => {}, warn: () => {} },
+ });
+ legacy.writePatch({ sessions: { ...legacy.read().sessions, 'legacy-release': { providerId: 'legacy-group', memberKey: 'local', at: 20 } } });
+ vi.resetModules();
+ const restarted = await import('../bindings.js');
+ expect(restarted.readProviderGroupBinding('legacy-release')).toBeNull();
+ expect(restarted.isProviderGroupReleased('legacy-release', { providerId: 'legacy-group' })).toBe(true);
+ await restarted.writeProviderGroupBinding('legacy-release', { providerId: 'legacy-group', memberKey: 'local' }, 30);
+ expect(restarted.readProviderGroupBinding('legacy-release')).toMatchObject({ providerId: 'legacy-group', at: 30 });
+ expect(restarted.isProviderGroupReleased('legacy-release', { providerId: 'legacy-group' })).toBe(false);
+ expect(JSON.parse(fs.readFileSync(path.join(tmpDir, 'provider-group-bindings.json'), 'utf8')).released?.['legacy-release']).toBeUndefined();
+ });
+
+ it('preserves an unreadable binding file and refuses to overwrite its release records', async () => {
+ const file = path.join(tmpDir, 'provider-group-bindings.json');
+ const previous = fs.readFileSync(file, 'utf8');
+ fs.writeFileSync(file, '{broken-json');
+ try {
+ await expect(bindings.writeProviderGroupBinding('unreadable-release', { providerId: 'anthropic', memberKey: 'local' })).rejects.toThrow(/unreadable/);
+ expect(fs.readFileSync(file, 'utf8')).toBe('{broken-json');
+ } finally {
+ fs.writeFileSync(file, previous);
+ }
+ });
+
it('keeps bindings to a group on another computer in their own file, one group per task', async () => {
await bindings.writeProviderGroupBinding('r1', { providerId: 'anthropic', memberKey: 'local', groupDeviceId: 'mini' }, 7);
expect(bindings.readProviderGroupBinding('r1')).toEqual({ providerId: 'anthropic', memberKey: 'local', groupDeviceId: 'mini', at: 7 });
diff --git a/apps/desktop/src/main/provider-group/bindings.ts b/apps/desktop/src/main/provider-group/bindings.ts
index 22730ecc14..a13531e828 100644
--- a/apps/desktop/src/main/provider-group/bindings.ts
+++ b/apps/desktop/src/main/provider-group/bindings.ts
@@ -9,13 +9,23 @@
* (`provider-group-remote-bindings.json`,多记组所在电脑)。分开存放,降级到旧版本时旧版本只读得到
* 本机的那份,不会把另一台电脑上的组误当成本机的同名组。
*
- * 另记一份「因组内电脑被移出或组被删除而解除过」的任务(`provider-group-released.json`):没归过组、
- * 正用着组那一项的老任务会被纳入组(service.ts),这些任务不纳入(§9.4)。旧版本不读它,也不改写它。
+ * 本机删组或移出组员时,在绑定文件的 `released` 中同时记下解除过的任务,避免两次落盘之间切换账号
+ * 丢掉解除记录。其他解除路径仍写 `provider-group-released.json`,两处记录共同阻止老任务自动纳入(§9.4)。
+ * 旧文件缺少 `released` 视为空;旧版本写绑定时保留这个未知根字段。
+ * 组设置先在 `provider-group-prefs.json` 同步记下待清理意图;绑定读方立即按意图失效,
+ * 新写绑定前完成解除并逐代确认,避免组已提交但账号切换阻止后续清理时被重新加入恢复。
*/
import { activeOwnerScopeKey, ownerScopedUserDataPath } from '../appSessionState.js';
import { desktopMakerLogger } from '../maker-host/logger-adapter.js';
import { createOverrideSettingsFile } from '../maker-host/override-settings-file.js';
import { isProviderGroupProviderId } from '../../shared/providerGroup.js';
+import { captureProviderManagementScope, withProviderGroupMutation } from './managementScope.js';
+import {
+ completeProviderGroupBindingCleanup,
+ listProviderGroupBindingCleanups,
+ readProviderGroup,
+ type ProviderGroupBindingCleanup,
+} from './store.js';
export interface ProviderGroupBinding {
/** 组所属的供应商(组所在电脑上的供应商 id)。 */
@@ -30,6 +40,8 @@ export interface ProviderGroupBinding {
interface BindingFile {
sessions: Record<string, ProviderGroupBinding>;
+ /** 本机组的解除记录,与对应绑定的删除在同一次原子替换中提交。 */
+ released?: Record<string, ProviderGroupRelease>;
}
/** 哪个组:组所属的供应商,组在另一台电脑上时再加那台的设备 id(本机的组为 null)。 */
@@ -84,15 +96,22 @@ function prune<T extends { at: number }>(sessions: Record<string, T>): Record<st
}
function normalizeFile(raw: unknown, remote: boolean): BindingFile {
- const sessions = (raw as Partial<BindingFile> | null)?.sessions;
- if (!sessions || typeof sessions !== 'object' || Array.isArray(sessions)) return { sessions: {} };
+ const rawSessions = (raw as Partial<BindingFile> | null)?.sessions;
+ const sessions = rawSessions && typeof rawSessions === 'object' && !Array.isArray(rawSessions) ? rawSessions : {};
const out: Record<string, ProviderGroupBinding> = {};
for (const [sessionId, value] of Object.entries(sessions)) {
if (!SESSION_ID_PATTERN.test(sessionId)) continue;
const binding = normalizeBinding(value, remote);
if (binding) out[sessionId] = binding;
}
- return { sessions: prune(out) };
+ const released = remote ? {} : Object.fromEntries(Object.entries(normalizeReleased({
+ sessions: (raw as Partial<BindingFile> | null)?.released,
+ }).sessions).filter(([, release]) => !release.groupDeviceId));
+ // 旧版本保留未知字段,但可能重新写入已解除任务的绑定;升级后仍以解除记录为准。
+ for (const [sessionId, release] of Object.entries(released)) {
+ if (out[sessionId] && sameGroup(release, out[sessionId])) delete out[sessionId];
+ }
+ return { sessions: prune(out), ...(Object.keys(released).length > 0 ? { released } : {}) };
}
const normalize = (raw: unknown) => normalizeFile(raw, false);
@@ -123,6 +142,7 @@ const store = createOverrideSettingsFile<BindingFile>({
log,
label: 'provider-group-bindings',
maxBytes: 2 * 1024 * 1024,
+ preserveUnreadableFile: true,
logLoadedValue: false,
});
const remoteStore = createOverrideSettingsFile<BindingFile>({
@@ -146,15 +166,60 @@ const releasedStore = createOverrideSettingsFile<ReleaseFile>({
logLoadedValue: false,
});
+function readLocalFile(): BindingFile {
+ store.invalidateIfChanged();
+ return store.read();
+}
+
+function pendingRelease(
+ binding: ProviderGroupBinding,
+ cleanups: Readonly<Record<string, ProviderGroupBindingCleanup>>,
+): boolean {
+ const cleanup = cleanups[binding.providerId];
+ return cleanup !== undefined && (cleanup.keepMemberKeys === null || !cleanup.keepMemberKeys.includes(binding.memberKey));
+}
+
+/** 组文件里的清理意图先使旧绑定失效,完成本机解除落盘后再逐代确认。 */
+async function finishPendingCleanups(assertCurrent: () => void): Promise<void> {
+ for (;;) {
+ assertCurrent();
+ const cleanups = listProviderGroupBindingCleanups();
+ const pending = Object.entries(cleanups);
+ if (pending.length === 0) return;
+ await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ const sessions = { ...value.sessions };
+ const released = { ...value.released };
+ let changed = false;
+ for (const [sessionId, binding] of Object.entries(sessions)) {
+ if (!pendingRelease(binding, cleanups)) continue;
+ delete sessions[sessionId];
+ released[sessionId] = { providerId: binding.providerId, at: cleanups[binding.providerId].at };
+ changed = true;
+ }
+ return changed ? { sessions, released: prune(released) } : {};
+ });
+ assertCurrent();
+ for (const [providerId, cleanup] of pending) {
+ await completeProviderGroupBindingCleanup(providerId, cleanup.token);
+ assertCurrent();
+ }
+ }
+}
+
/** 这个任务的绑定(本机的组或另一台电脑上的组,至多一个)。 */
export function readProviderGroupBinding(sessionId: string): ProviderGroupBinding | null {
if (!SESSION_ID_PATTERN.test(sessionId)) return null;
- return store.read().sessions[sessionId] ?? remoteStore.read().sessions[sessionId] ?? null;
+ const cleanups = listProviderGroupBindingCleanups();
+ const local = readLocalFile().sessions[sessionId];
+ if (local) return pendingRelease(local, cleanups) ? null : local;
+ return remoteStore.read().sessions[sessionId] ?? null;
}
/** 本机的组的绑定(本机分配器据此统计各组内电脑上正在运行的任务)。 */
export function listProviderGroupBindings(): Record<string, ProviderGroupBinding> {
- return store.read().sessions;
+ const cleanups = listProviderGroupBindingCleanups();
+ return Object.fromEntries(Object.entries(readLocalFile().sessions).filter(([, binding]) => !pendingRelease(binding, cleanups)));
}
/** 另一台电脑上的组的绑定(据此向组所在电脑报告正在运行的任务)。 */
@@ -166,12 +231,21 @@ async function writeIn(
target: typeof store,
sessionId: string,
binding: ProviderGroupBinding | null,
+ assertCurrent: () => void,
): Promise<void> {
await target.updateAtomic(({ value }) => {
+ assertCurrent();
const sessions = { ...value.sessions };
if (binding) sessions[sessionId] = binding;
else if (sessionId in sessions) delete sessions[sessionId];
else return {};
+ const release = value.released?.[sessionId];
+ if (binding && release && sameGroup(release, binding)) {
+ // 显式重新分配给这个组时,同一次提交清除本机解除记录;其他组的记录仍保留。
+ const released = { ...value.released };
+ delete released[sessionId];
+ return { sessions: prune(sessions), released };
+ }
return { sessions: prune(sessions) };
});
}
@@ -185,41 +259,66 @@ export async function writeProviderGroupBinding(
binding: { providerId: string; memberKey: string; groupDeviceId?: string | null } | null,
now: number = Date.now(),
): Promise<void> {
+ const assertCurrent = captureProviderManagementScope();
if (!SESSION_ID_PATTERN.test(sessionId)) throw new Error('Invalid session id');
const remote = typeof binding?.groupDeviceId === 'string';
const normalized = binding ? normalizeBinding({ ...binding, at: now }, remote) : null;
if (binding && !normalized) throw new Error('Invalid provider group binding');
- await writeIn(remote ? remoteStore : store, sessionId, normalized);
- await writeIn(remote ? store : remoteStore, sessionId, null);
- // 重新由同一个组分配(例如清空后当作新任务):之前解除过的记录作废。
- const release = normalized ? releasedStore.read().sessions[sessionId] : undefined;
- if (normalized && release && sameGroup(release, normalized)) {
- await releasedStore.updateAtomic(({ value }) => {
- const current = value.sessions[sessionId];
- if (!current || !sameGroup(current, normalized)) return {};
- const sessions = { ...value.sessions };
- delete sessions[sessionId];
- return { sessions };
- });
- }
+ await withProviderGroupMutation(async () => {
+ // 先完成之前已提交的移出,避免新分配覆盖旧绑定后失去该任务的解除证据。
+ await finishPendingCleanups(assertCurrent);
+ assertCurrent();
+ await writeIn(remote ? remoteStore : store, sessionId, normalized, assertCurrent);
+ assertCurrent();
+ await writeIn(remote ? store : remoteStore, sessionId, null, assertCurrent);
+ assertCurrent();
+ // 重新由同一个组分配(例如清空后当作新任务):之前解除过的记录作废。
+ const release = normalized ? releasedStore.read().sessions[sessionId] : undefined;
+ if (normalized && release && sameGroup(release, normalized)) {
+ await releasedStore.updateAtomic(({ value }) => {
+ assertCurrent();
+ const current = value.sessions[sessionId];
+ if (!current || !sameGroup(current, normalized)) return {};
+ const sessions = { ...value.sessions };
+ delete sessions[sessionId];
+ return { sessions };
+ });
+ assertCurrent();
+ }
+ });
+ assertCurrent();
}
/** 这个任务曾因组内电脑被移出或这个组被删除而解除过这个组的绑定:不再自动纳入这个组(§9.4)。 */
export function isProviderGroupReleased(sessionId: string, group: ProviderGroupRef): boolean {
if (!SESSION_ID_PATTERN.test(sessionId)) return false;
+ const cleanups = listProviderGroupBindingCleanups();
+ const localFile = readLocalFile();
+ const localRelease = localFile.released?.[sessionId];
+ if (localRelease && sameGroup(localRelease, group)) return true;
+ const binding = localFile.sessions[sessionId];
+ if (binding && sameGroup(binding, group) && pendingRelease(binding, cleanups)) return true;
const release = releasedStore.read().sessions[sessionId];
return release !== undefined && sameGroup(release, group);
}
-async function writeReleases(sessionIds: readonly string[], group: ProviderGroupRef, now: number): Promise<void> {
+async function writeReleases(
+ sessionIds: readonly string[],
+ group: ProviderGroupRef,
+ now: number,
+ assertCurrent: () => void = () => undefined,
+): Promise<void> {
+ assertCurrent();
const release = normalizeRelease({ ...group, groupDeviceId: group.groupDeviceId ?? undefined, at: now });
const ids = sessionIds.filter((id) => SESSION_ID_PATTERN.test(id));
if (!release || ids.length === 0) return;
await releasedStore.updateAtomic(({ value }) => {
+ assertCurrent();
const sessions = { ...value.sessions };
for (const id of ids) sessions[id] = release;
return { sessions: prune(sessions) };
});
+ assertCurrent();
}
/** 记下这个任务因组内电脑被移出或组被删除而解除了这个组的绑定。 */
@@ -241,22 +340,30 @@ 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 };
- released.length = 0;
- for (const [sessionId, binding] of Object.entries(sessions)) {
- if (binding.providerId !== providerId) continue;
- if (keepMemberKeys?.has(binding.memberKey)) continue;
- delete sessions[sessionId];
- released.push(sessionId);
- }
- return released.length > 0 ? { sessions } : {};
+ const assertCurrent = captureProviderManagementScope();
+ await withProviderGroupMutation(async () => {
+ await finishPendingCleanups(assertCurrent);
+ assertCurrent();
+ // 已提交的移出已由意图回放完成;旧 IPC 请求恢复时,不能按过期快照再解除新分配。
+ const current = readProviderGroup(providerId);
+ if (current && (keepMemberKeys === null || current.members.length !== keepMemberKeys.size
+ || current.members.some((member) => !keepMemberKeys.has(member.key)))) return;
+ await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ const sessions = { ...value.sessions };
+ const released = { ...value.released };
+ let changed = false;
+ for (const [sessionId, binding] of Object.entries(sessions)) {
+ if (binding.providerId !== providerId) continue;
+ if (keepMemberKeys?.has(binding.memberKey)) continue;
+ delete sessions[sessionId];
+ released[sessionId] = { providerId, at: now };
+ changed = true;
+ }
+ // 删除绑定与阻止自动恢复的记录共用一份文件、一把锁;提交后无需再写另一份文件。
+ return changed ? { sessions, released: prune(released) } : {};
+ });
});
- // 原子写落盘后的锁释放也会等待;旧账号的解除记录不能落到此时切入的新账号。
- if (activeOwnerScopeKey() !== owner) return;
- await writeReleases(released, { providerId }, now);
}
export const __testing = { normalize, normalizeRemote, normalizeReleased, prune };
diff --git a/apps/desktop/src/main/provider-group/ipc.ts b/apps/desktop/src/main/provider-group/ipc.ts
index 08986c5183..ac953f47e5 100644
--- a/apps/desktop/src/main/provider-group/ipc.ts
+++ b/apps/desktop/src/main/provider-group/ipc.ts
@@ -1,5 +1,5 @@
/**
- * 供应商组设置的 IPC:只接受本机应用窗口,不经设备互联代理(组是这台电脑上的设置)。
+ * 本机窗口的组命令入口;同账号远程管理由专用命令转交组所在电脑。
*/
import { ipcMain } from 'electron';
@@ -9,14 +9,17 @@ import {
PROVIDER_GROUP_IPC,
isProviderGroupProviderId,
normalizeProviderGroupConfig,
+ parseProviderGroupRemoteView,
type ProviderGroupCommand,
+ type ProviderGroupLocalCommand,
type ProviderGroupConfig,
type ProviderGroupReshareSummary,
type ProviderGroupSessionGroup,
type ProviderGroupView,
} from '../../shared/providerGroup.js';
import { tapWindowBroadcast } from '../device-link/broadcast-tap.js';
-import { broadcast, getSelfDeviceId } from '../device-link/index.js';
+import { broadcast, getSelfDeviceId, remoteBackgroundInvoke, remoteInvoke } from '../device-link/index.js';
+import { isProviderManagementRequest } from '../../shared/providerManagement.js';
import { getDeviceLinkInvokeContext } from '../device-link/invoke-context.js';
import { createLogger } from '../logger.js';
import { MAKER_PUSH } from '../maker-ipc/channels.js';
@@ -32,6 +35,8 @@ import {
readProviderGroupOfSession,
} from './runtime.js';
import { listProviderGroups, readProviderGroup, writeProviderGroup } from './store.js';
+import { invokeProviderManagement } from './managementClient.js';
+import { captureProviderManagementScope } from './managementScope.js';
const log = createLogger('provider-group');
@@ -39,7 +44,7 @@ export interface ProviderGroupCommandDeps {
router: ProviderGroupRouter;
directory: ProviderGroupDirectory;
readGroup(providerId: string): ProviderGroupConfig | null;
- writeGroup(providerId: string, config: unknown): Promise<ProviderGroupConfig | null>;
+ writeGroup(providerId: string, config: unknown, expectedConfig?: ProviderGroupConfig | null): Promise<ProviderGroupConfig | null>;
/** 解除指向已不在组里的电脑的任务绑定;keep 为 null = 整个组已删除。 */
pruneBindings(providerId: string, keep: ReadonlySet<string> | null): Promise<void>;
/** 当前账号:等远端目录期间换了账号时不写入(否则会把上一个账号的组写进新账号)。 */
@@ -86,6 +91,14 @@ const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
export function parseProviderGroupCommand(raw: unknown): ProviderGroupCommand {
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throwIpcError('INVALID_PARAMS', 'command required');
const value = raw as Record<string, unknown>;
+ if (value.action === 'remote-manage') {
+ if (typeof value.deviceId !== 'string' || !REMOTE_DEVICE_ID_PATTERN.test(value.deviceId)
+ || !isProviderManagementRequest(value.request) || !value.request.command
+ || typeof value.request.command !== 'object' || Array.isArray(value.request.command)) {
+ throwIpcError('INVALID_PARAMS', 'Invalid remote provider management command');
+ }
+ return { action: 'remote-manage', deviceId: value.deviceId, request: value.request };
+ }
if (value.action === 'list') return { action: 'list' };
if (value.action === 'session-group') {
if (typeof value.sessionId !== 'string' || !SESSION_ID_PATTERN.test(value.sessionId)) {
@@ -110,6 +123,18 @@ export function parseProviderGroupCommand(raw: unknown): ProviderGroupCommand {
if (!value.config || typeof value.config !== 'object') throwIpcError('INVALID_PARAMS', 'config required');
return { action: 'save', providerId, config: value.config as ProviderGroupConfig };
}
+ case 'save-if-current':
+ case 'delete-if-current': {
+ const expectedConfig = normalizeProviderGroupConfig(value.expectedConfig, providerId);
+ if (value.expectedConfig !== null && !expectedConfig) {
+ throwIpcError('INVALID_PARAMS', 'expectedConfig must be a group snapshot or null');
+ }
+ if (value.action === 'delete-if-current') return { action: value.action, providerId, expectedConfig };
+ if (!value.config || typeof value.config !== 'object' || Array.isArray(value.config)) {
+ throwIpcError('INVALID_PARAMS', 'config required');
+ }
+ return { action: value.action, providerId, config: value.config as ProviderGroupConfig, expectedConfig };
+ }
default:
throwIpcError('INVALID_PARAMS', 'unknown provider group action');
}
@@ -133,7 +158,7 @@ function readsCatalog(
}
/**
- * 另一台电脑上的组:状态是组所在电脑看到的。组里的「我的其他电脑」由这台电脑直接连过去(§4 同账号直连),
+ * 另一台电脑上的组:状态是组所在电脑看到的。组里的同账号电脑与分享来的电脑都由这台电脑直连(§4),
* 组所在电脑那边看它能用、这台却读不到它的目录时标出来(`unreachableHere`):否则这里显示能用,换电脑时却总换不过去。
* 目录有短时缓存;每台最多等 3 秒,到点还没结果的不标,照组所在电脑的状态显示。
*/
@@ -145,7 +170,7 @@ export async function markMembersUnreachableHere(
if (!view.config || !selfDeviceId) return view;
const usable = new Set(view.members.filter((m) => m.state === 'available' || m.state === 'full').map((m) => m.key));
const direct = view.config.members.filter((m) =>
- m.kind === 'device' && usable.has(m.key) && m.agentDeviceId !== null && m.agentDeviceId !== selfDeviceId);
+ (m.kind === 'device' || m.kind === 'share') && usable.has(m.key) && m.agentDeviceId !== null && m.agentDeviceId !== selfDeviceId);
if (direct.length === 0) return view;
const reads = await Promise.all(direct.map(async (m) => ({ key: m.key, ok: await readsCatalog(directory, m.agentDeviceId!) })));
const unreachable = new Set(reads.filter((r) => r.ok === false).map((r) => r.key));
@@ -157,28 +182,45 @@ export async function markMembersUnreachableHere(
}
/** 业务体(依赖注入,单测直接调)。 */
-export async function executeProviderGroupCommand(deps: ProviderGroupCommandDeps, command: ProviderGroupCommand) {
+export async function executeProviderGroupCommand(deps: ProviderGroupCommandDeps, command: ProviderGroupLocalCommand) {
+ const assertCurrent = captureProviderManagementScope(deps.ownerKey);
+ const result = await runProviderGroupCommand(deps, command, assertCurrent);
+ assertCurrent();
+ return result;
+}
+
+async function runProviderGroupCommand(
+ deps: ProviderGroupCommandDeps,
+ command: ProviderGroupLocalCommand,
+ assertCurrent: () => void,
+) {
if (command.action === 'list') return deps.listGroups();
if (command.action === 'session-group') return deps.sessionGroup(command.sessionId);
const { providerId } = command;
switch (command.action) {
- case 'get':
- return withReshare(deps, await deps.router.view(providerId, { includeGuestSupport: true }));
- case 'remote-view':
- return markMembersUnreachableHere(
- await deps.remoteView(command.deviceId, providerId),
- deps.directory,
- deps.localDeviceId(),
- );
+ case 'get': {
+ const view = await deps.router.view(providerId, { includeGuestSupport: true });
+ assertCurrent();
+ return withReshare(deps, view);
+ }
+ case 'remote-view': {
+ const view = await deps.remoteView(command.deviceId, providerId);
+ assertCurrent();
+ return markMembersUnreachableHere(view, deps.directory, deps.localDeviceId());
+ }
case 'candidates':
return deps.directory.listCandidates(providerId, deps.readGroup(providerId));
case 'delete':
- await deps.writeGroup(providerId, null);
+ case 'delete-if-current':
+ if (command.action === 'delete-if-current') await deps.writeGroup(providerId, null, command.expectedConfig);
+ else await deps.writeGroup(providerId, null);
+ assertCurrent();
await deps.pruneBindings(providerId, null);
+ assertCurrent();
deps.changed(providerId);
return deps.router.view(providerId, { includeGuestSupport: true });
- case 'save': {
- const owner = deps.ownerKey();
+ case 'save':
+ case 'save-if-current': {
const next = normalizeProviderGroupConfig(command.config, providerId);
if (next) {
// 新加入的电脑必须是这台电脑已经能用的同一个供应商(§3),不能凭渲染端点名加入。
@@ -194,6 +236,7 @@ export async function executeProviderGroupCommand(deps: ProviderGroupCommandDeps
// 也不能接受渲染端快照自报的物理电脑键(协议兼容规则中的供应商组聚合条目)。
if (added.length > 0 || next.members.some((m) => m.kind === 'share')) {
const candidates = await deps.directory.listCandidates(providerId, deps.readGroup(providerId));
+ assertCurrent();
const byKey = new Map(candidates.map((c) => [c.key, c]));
const allowed = new Set(candidates.filter((c) => !c.blocked).map((c) => c.key));
const rejected = added.filter((m) => !allowed.has(m.key));
@@ -213,13 +256,17 @@ export async function executeProviderGroupCommand(deps: ProviderGroupCommandDeps
}
}
}
- if (deps.ownerKey() !== owner) {
- throwIpcError('PRECONDITION_FAILED', 'The account changed while saving the provider group');
- }
- const written = await deps.writeGroup(providerId, next);
+ assertCurrent();
+ const written = command.action === 'save-if-current'
+ ? await deps.writeGroup(providerId, next, command.expectedConfig)
+ : await deps.writeGroup(providerId, next);
+ assertCurrent();
await deps.pruneBindings(providerId, written ? new Set(written.members.map((m) => m.key)) : null);
+ assertCurrent();
deps.changed(providerId);
- return withReshare(deps, await deps.router.view(providerId, { includeGuestSupport: true }));
+ const view = await deps.router.view(providerId, { includeGuestSupport: true });
+ assertCurrent();
+ return withReshare(deps, view);
}
}
}
@@ -234,9 +281,11 @@ export interface ProviderGroupIpcReshare {
kick(reason: string): void;
}
-export function registerProviderGroupIpc(options: { reshare?: ProviderGroupIpcReshare } = {}): void {
+export function createProviderGroupCommandDeps(
+ options: { reshare?: ProviderGroupIpcReshare; onGroupChanged?: (providerId: string) => void } = {},
+): ProviderGroupCommandDeps {
const reshare = options.reshare;
- const deps: ProviderGroupCommandDeps = {
+ return {
router: getProviderGroupRouter(),
directory: getProviderGroupDirectory(),
readGroup: readProviderGroup,
@@ -250,6 +299,7 @@ export function registerProviderGroupIpc(options: { reshare?: ProviderGroupIpcRe
changed: (providerId) => {
// 组里的电脑变了:重新报转分享(加进来的分享来的电脑要请它的主人同意,移出的不再列着)。
reshare?.kick('group');
+ options.onGroupChanged?.(providerId);
try {
broadcast(PROVIDER_GROUP_IPC.CHANGED, { providerId });
// 同账号其他电脑的模型列表按本机目录里的组摘要收起组内电脑:组变化后让它们重读目录。
@@ -260,10 +310,29 @@ export function registerProviderGroupIpc(options: { reshare?: ProviderGroupIpcRe
},
...(reshare ? { reshare } : {}),
};
+}
+
+export function registerProviderGroupIpc(options: { reshare?: ProviderGroupIpcReshare } = {}): void {
+ const deps = createProviderGroupCommandDeps(options);
ipcMain.handle(PROVIDER_GROUP_IPC.COMMAND, async (event, raw: unknown) => {
if (getDeviceLinkInvokeContext()) throwIpcError('PERMISSION_DENIED', 'Provider groups are local only');
assertTrustedAppRendererEvent(event);
- return executeProviderGroupCommand(deps, parseProviderGroupCommand(raw));
+ const command = parseProviderGroupCommand(raw);
+ if (command.action === 'remote-manage') {
+ const assertOwner = captureProviderManagementScope(deps.ownerKey);
+ const result = await invokeProviderManagement(remoteInvoke, command.deviceId, command.request, remoteBackgroundInvoke);
+ assertOwner();
+ if (command.request.action !== 'manage-group' || command.request.command.action === 'candidates') return result;
+ // 管理读取与保存后的组视图也按查看端直连能力投影,不能把组所在电脑看到的可用误当成本机可达。
+ const view = await markMembersUnreachableHere(
+ parseProviderGroupRemoteView(result, command.request.command.providerId),
+ deps.directory,
+ deps.localDeviceId(),
+ );
+ assertOwner();
+ return view;
+ }
+ return executeProviderGroupCommand(deps, command);
});
}
diff --git a/apps/desktop/src/main/provider-group/management.ts b/apps/desktop/src/main/provider-group/management.ts
new file mode 100644
index 0000000000..5d8b3256dc
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/management.ts
@@ -0,0 +1,40 @@
+/** dispatch 已验证同账号身份;管理范围只含组设置和分享者操作,禁止继续转发。 */
+import type { ProviderManagementReply, ProviderManagementRequest } from '../../shared/providerManagement.js';
+import type { ProviderGroupManagementCommand, ProviderShareManagementCommand } from '../../shared/providerManagement.js';
+import { isProviderManagementRequest } from '../../shared/providerManagement.js';
+import { executeProviderShareManagementCommand, parseProviderShareCommand } from '../device-link/providerShareRuntime.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
+import { createProviderGroupCommandDeps, executeProviderGroupCommand, parseProviderGroupCommand } from './ipc.js';
+import { captureProviderManagementScope } from './managementScope.js';
+
+export function parseProviderManagementRequest(raw: unknown): ProviderManagementRequest {
+ if (!isProviderManagementRequest(raw)) throwIpcError('INVALID_PARAMS', 'Invalid provider management request');
+ if (raw.action === 'manage-group') {
+ const command = parseProviderGroupCommand(raw.command);
+ if (command.action === 'save' || command.action === 'delete') {
+ throwIpcError('UNSUPPORTED_CAPABILITY', 'Update the managing computer to save provider groups with conflict checks');
+ }
+ if (!['get', 'candidates', 'save-if-current', 'delete-if-current'].includes(command.action)) {
+ throwIpcError('PERMISSION_DENIED', 'This group operation is not available through management');
+ }
+ return { action: 'manage-group', command: command as ProviderGroupManagementCommand };
+ }
+ const command = parseProviderShareCommand(raw.command);
+ if (!['owned', 'own-usage', 'create-link', 'approve', 'reject', 'set-member', 'reshare-decide'].includes(command.action)) {
+ throwIpcError('PERMISSION_DENIED', 'Only owner operations are available through management');
+ }
+ return { action: 'manage-share', command: command as ProviderShareManagementCommand };
+}
+
+export async function handleProviderManagementRequest(
+ raw: unknown,
+ options: { onGroupChanged?: (providerId: string) => void } = {},
+): Promise<ProviderManagementReply> {
+ const assertCurrent = captureProviderManagementScope();
+ const request = parseProviderManagementRequest(raw);
+ const result = request.action === 'manage-group'
+ ? await executeProviderGroupCommand(createProviderGroupCommandDeps(options), request.command)
+ : await executeProviderShareManagementCommand(request.command);
+ assertCurrent();
+ return { result, respondedAt: Date.now() };
+}
diff --git a/apps/desktop/src/main/provider-group/managementClient.ts b/apps/desktop/src/main/provider-group/managementClient.ts
new file mode 100644
index 0000000000..c64e2bf75f
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/managementClient.ts
@@ -0,0 +1,71 @@
+/**
+ * 只转发明确的同账号管理操作,不重放写请求;链接在本机 Main 登记后才能复制。
+ * 本机生成的链接由本机弹审批窗(provider-sharing.md §4.1):生成后关注那条分享,本机处理过的申请随即移除。
+ */
+import { PROVIDER_GROUP_REMOTE_CHANNEL, PROVIDER_SHARE_LINK_TTL_MS } from '@cindy/device-link';
+
+import type { ProviderManagementReply, ProviderManagementRequest } from '../../shared/providerManagement.js';
+import type { ProviderShareOwnerState } from '../../shared/providerShare.js';
+import { forgetWatchedProviderShareRequest, watchProviderShareRequests } from '../device-link/providerShareHost.js';
+import { rememberIssuedClipboardText } from '../textClipboard.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
+import type { ProviderGroupRemoteInvoke } from './remoteClient.js';
+import { captureProviderManagementScope } from './managementScope.js';
+
+export async function invokeProviderManagement(
+ invoke: ProviderGroupRemoteInvoke,
+ deviceId: string,
+ request: ProviderManagementRequest,
+ readInvoke: ProviderGroupRemoteInvoke = invoke,
+): Promise<unknown> {
+ const assertOwner = captureProviderManagementScope();
+ const response = await invoke(deviceId, PROVIDER_GROUP_REMOTE_CHANNEL, [request], { preSend: assertOwner });
+ assertOwner();
+ if (!response.ok) {
+ const message = response.error?.message ?? '';
+ if (response.error?.code === 'CHANNEL_NOT_ALLOWED' || /unknown provider group action/.test(message)) {
+ throwIpcError('UNSUPPORTED_CAPABILITY', 'Provider management requires an update on the computer with the group');
+ }
+ throw new Error(/^\[[A-Z_]+\]/.test(message) ? message : '[REMOTE_AGENT_UNAVAILABLE] Provider management failed');
+ }
+ const reply = response.result as ProviderManagementReply | null;
+ if (!reply || typeof reply !== 'object' || !Object.hasOwn(reply, 'result') || !Number.isFinite(reply.respondedAt)) {
+ throwIpcError('PRECONDITION_FAILED', 'Invalid provider management response');
+ }
+ if (request.action === 'manage-share' && request.command.action === 'create-link') {
+ const created = reply.result as { link?: unknown; linkId?: unknown; expiresAt?: unknown } | null;
+ if (created && created.linkId === undefined) {
+ throwIpcError('UNSUPPORTED_CAPABILITY', 'Remote share links require an update on the provider computer and provider share server');
+ }
+ if (!created || typeof created.link !== 'string' || !created.link || created.link.length > 4096
+ || typeof created.linkId !== 'string' || !/^[a-f0-9]{64}$/.test(created.linkId)
+ || typeof created.expiresAt !== 'string' || !Number.isFinite(Date.parse(created.expiresAt))) {
+ throwIpcError('PRECONDITION_FAILED', 'Invalid provider share link');
+ }
+ const responseReceivedAt = Date.now();
+ const remoteRemaining = Math.max(0, Math.min(PROVIDER_SHARE_LINK_TTL_MS, Date.parse(created.expiresAt) - reply.respondedAt));
+ await watchProviderShareRequests(deviceId, request.command.providerId, created.linkId,
+ () => readProviderManagementShares(readInvoke, deviceId));
+ assertOwner();
+ const postResponseElapsed = Math.max(0, Date.now() - responseReceivedAt);
+ const remaining = Math.max(0, remoteRemaining - postResponseElapsed);
+ const expiresAt = new Date(Date.now() + remaining).toISOString();
+ rememberIssuedClipboardText(created.link, expiresAt);
+ return { link: created.link, linkId: created.linkId, expiresAt };
+ }
+ if (request.action === 'manage-share' && (request.command.action === 'approve' || request.command.action === 'reject')) {
+ forgetWatchedProviderShareRequest(request.command.requestId);
+ }
+ return reply.result;
+}
+
+/** 原始生成和重启恢复共用同一只读通道;仍在发送前与回包后核对当前账号。 */
+export async function readProviderManagementShares(invoke: ProviderGroupRemoteInvoke, deviceId: string) {
+ const snapshot = await invokeProviderManagement(invoke, deviceId, {
+ action: 'manage-share', command: { action: 'owned', range: '7d' },
+ }) as ProviderShareOwnerState | null;
+ if (!snapshot?.ready || !Array.isArray(snapshot.shares)) {
+ throwIpcError('PRECONDITION_FAILED', 'Provider share snapshot is not available on the managing computer');
+ }
+ return snapshot.shares;
+}
diff --git a/apps/desktop/src/main/provider-group/managementScope.ts b/apps/desktop/src/main/provider-group/managementScope.ts
new file mode 100644
index 0000000000..23cbd0e0f0
--- /dev/null
+++ b/apps/desktop/src/main/provider-group/managementScope.ts
@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { activeOwnerScopeKey, isAppSessionBoundaryPending, ownerScopedUserDataPath } from '../appSessionState.js';
+import { withCrossProcessLock } from '../device-link/crossProcessLock.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
+
+/** 账号进入清理边界时旧 owner key 仍有效,管理操作必须同时核对切换状态。 */
+export function captureProviderManagementScope(ownerKey: () => string = activeOwnerScopeKey): () => void {
+ const owner = ownerKey();
+ const assertCurrent = () => {
+ if (isAppSessionBoundaryPending() || ownerKey() !== owner) {
+ throwIpcError('PRECONDITION_FAILED', 'The account changed during provider management');
+ }
+ };
+ assertCurrent();
+ return assertCurrent;
+}
+
+/** 锁顺序固定为账号级组修改锁 → 各数据文件锁,清理回放和新分配不能交错。 */
+export async function withProviderGroupMutation<T>(task: () => Promise<T>): Promise<T> {
+ const assertCurrent = captureProviderManagementScope();
+ const file = ownerScopedUserDataPath('provider-group-mutation.lock');
+ fs.mkdirSync(path.dirname(file), { recursive: true });
+ return withCrossProcessLock(file, { label: 'provider-group-mutation', waitMs: 12_000 }, async (status) => {
+ if (!status.held) throwIpcError('PRECONDITION_FAILED', 'Provider group settings are busy in another process');
+ assertCurrent();
+ return task();
+ });
+}
diff --git a/apps/desktop/src/main/provider-group/remoteHandler.ts b/apps/desktop/src/main/provider-group/remoteHandler.ts
index f95a5f75fb..30d6723d49 100644
--- a/apps/desktop/src/main/provider-group/remoteHandler.ts
+++ b/apps/desktop/src/main/provider-group/remoteHandler.ts
@@ -60,9 +60,10 @@ const pendingUsageReports = new WeakMap<object, Map<string, PendingUsageReport>>
export const PROVIDER_GROUP_USAGE_PART_TTL_MS = 10 * 60_000;
/**
- * 给同账号电脑的 `maker:provider:list` 补组摘要与运行数,都只加在仍允许被远程调用的供应商上:
- * 建了组的带 `group`;`running`(这台电脑上每个供应商正在运行一轮的任务数,localLoad.ts)给出时每个都带
- * `runningTurns`,没在跑的为 0,读不到(null)时不带。结果里已有的这两个字段一律先去掉,只有本机能产生它们。
+ * 给同账号电脑的 `maker:provider:list` 补组摘要与运行数:建了组的供应商都带 `group`,
+ * 让关闭远程调用的组仍能从设置进入管理;`running`(这台电脑上每个供应商正在运行一轮的任务数,
+ * localLoad.ts)只给仍允许被远程调用的供应商附加 `runningTurns`,没在跑的为 0,读不到(null)时不带。
+ * 结果里已有的这两个字段一律先去掉,只有本机能产生它们。
*/
export function decorateProviderListWithGroups(
result: unknown,
@@ -79,9 +80,10 @@ export function decorateProviderListWithGroups(
const entry = { ...(provider as Record<string, unknown>) };
delete entry.group;
delete entry[PROVIDER_RUNNING_TURNS_FIELD];
- if (entry.remoteInvocationEnabled !== true || typeof entry.id !== 'string') return entry;
+ if (typeof entry.id !== 'string') return entry;
const config = readGroup(entry.id);
if (config) entry.group = providerGroupSummaryForWire(config);
+ if (entry.remoteInvocationEnabled !== true) return entry;
if (running) entry[PROVIDER_RUNNING_TURNS_FIELD] = running.get(entry.id) ?? 0;
return entry;
}),
diff --git a/apps/desktop/src/main/provider-group/remoteRegistration.ts b/apps/desktop/src/main/provider-group/remoteRegistration.ts
index 7e67d072bb..e50c9b0967 100644
--- a/apps/desktop/src/main/provider-group/remoteRegistration.ts
+++ b/apps/desktop/src/main/provider-group/remoteRegistration.ts
@@ -18,8 +18,10 @@ import {
readProviderRunningTurnsByProvider,
} from './runtime.js';
import { readProviderGroup } from './store.js';
+import { isProviderManagementRequest } from '../../shared/providerManagement.js';
+import { handleProviderManagementRequest } from './management.js';
-export function registerProviderGroupRemoteHandler(): void {
+export function registerProviderGroupRemoteHandler(options: { onGroupChanged?: (providerId: string) => void } = {}): void {
const deps: ProviderGroupRemoteHandlerDeps = {
scope: getProviderGroupOwnerScope,
readGroup: readProviderGroup,
@@ -30,7 +32,8 @@ export function registerProviderGroupRemoteHandler(): void {
sessionGroup: readProviderGroupOfSession,
};
setProviderGroupRemoteHandler({
- handle: (controller, raw) => handleProviderGroupRemote(deps, controller, raw),
+ handle: (controller, raw) => isProviderManagementRequest(raw)
+ ? handleProviderManagementRequest(raw, options) : handleProviderGroupRemote(deps, controller, raw),
decorateProviderList: async (result) =>
decorateProviderListWithGroups(result, readProviderGroup, await readProviderRunningTurnsByProvider()),
sharedGroupSize: (providerId) => sharedProviderGroupSize(deps, providerId),
diff --git a/apps/desktop/src/main/provider-group/store.ts b/apps/desktop/src/main/provider-group/store.ts
index 29e9670d9a..93cae5f96b 100644
--- a/apps/desktop/src/main/provider-group/store.ts
+++ b/apps/desktop/src/main/provider-group/store.ts
@@ -3,10 +3,13 @@
* 组只是「这台电脑上这个供应商」的一项设置,没有账号级的组(docs/product-rules/provider-groups.md §3)。
*/
import { randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
import { activeOwnerScopeKey, ownerScopedUserDataPath } from '../appSessionState.js';
import { desktopMakerLogger } from '../maker-host/logger-adapter.js';
import { createOverrideSettingsFile } from '../maker-host/override-settings-file.js';
+import { throwIpcError } from '../utils/ipcValidate.js';
+import { captureProviderManagementScope, withProviderGroupMutation } from './managementScope.js';
import {
isProviderGroupProviderId,
normalizeProviderGroupConfig,
@@ -15,10 +18,19 @@ import {
interface ProviderGroupFile {
groups: Record<string, ProviderGroupConfig>;
+ /** 组修改已提交但绑定可能尚未解除;重新加入也不能撤销这次清理。 */
+ bindingCleanups?: Record<string, ProviderGroupBindingCleanup>;
/** 分享来的电脑离开全部组后,等空名单确认再删除;代次防止迟到确认吞掉再次移出的清理。 */
reshareCleanups?: Record<string, string>;
}
+export interface ProviderGroupBindingCleanup {
+ token: string;
+ /** 多次移出取交集,null 表示整组删除;不能被后续重新加入覆盖。 */
+ keepMemberKeys: string[] | null;
+ at: number;
+}
+
/** 防止损坏文件无限膨胀的存储边界,远高于实际用量。 */
const MAX_GROUPS = 1024;
@@ -40,7 +52,23 @@ function normalize(raw: unknown): ProviderGroupFile {
}
}
}
- return { groups: out, ...(Object.keys(reshareCleanups).length > 0 ? { reshareCleanups } : {}) };
+ const bindingCleanups: Record<string, ProviderGroupBindingCleanup> = {};
+ if (source?.bindingCleanups && typeof source.bindingCleanups === 'object' && !Array.isArray(source.bindingCleanups)) {
+ for (const [providerId, cleanup] of Object.entries(source.bindingCleanups)) {
+ if (!isProviderGroupProviderId(providerId) || !cleanup || typeof cleanup !== 'object') continue;
+ const { token, keepMemberKeys, at } = cleanup;
+ if (typeof token !== 'string' || !/^[0-9a-f-]{36}$/.test(token)) continue;
+ if (typeof at !== 'number' || !Number.isFinite(at) || at <= 0) continue;
+ if (keepMemberKeys !== null && (!Array.isArray(keepMemberKeys)
+ || !keepMemberKeys.every((key) => typeof key === 'string' && /^[A-Za-z0-9_.:-]{1,300}$/.test(key)))) continue;
+ bindingCleanups[providerId] = { token, keepMemberKeys, at };
+ }
+ }
+ return {
+ groups: out,
+ ...(Object.keys(reshareCleanups).length > 0 ? { reshareCleanups } : {}),
+ ...(Object.keys(bindingCleanups).length > 0 ? { bindingCleanups } : {}),
+ };
}
/** 同一分享可能同时加入几个组;最后一个引用移出时才清空这台电脑的转分享名单。 */
@@ -78,10 +106,18 @@ export function listProviderGroups(): Record<string, ProviderGroupConfig> {
export async function writeProviderGroup(
providerId: string,
config: unknown,
+ expectedConfig?: ProviderGroupConfig | null,
): Promise<ProviderGroupConfig | null> {
+ const assertCurrent = captureProviderManagementScope();
if (!isProviderGroupProviderId(providerId)) throw new Error('Invalid provider id');
const normalized = config === null ? null : normalizeProviderGroupConfig(config, providerId);
- const next = await store.updateAtomic(({ value }) => {
+ const expected = expectedConfig === undefined ? undefined : normalizeProviderGroupConfig(expectedConfig, providerId);
+ const next = await withProviderGroupMutation(() => store.updateAtomic(({ value }) => {
+ assertCurrent();
+ // 必须在已有跨进程写锁内重读并比较,不能在等待目录或写锁前检查后再无条件覆盖。
+ if (expected !== undefined && !isDeepStrictEqual(value.groups[providerId] ?? null, expected)) {
+ throwIpcError('PROVIDER_GROUP_CHANGED', 'The provider group changed while it was being edited');
+ }
const groups = { ...value.groups };
if (normalized) groups[providerId] = normalized;
else delete groups[providerId];
@@ -90,12 +126,43 @@ export async function writeProviderGroup(
for (const device of sharedDevices(value.groups)) {
if (!remaining.has(device)) reshareCleanups[device] = randomUUID();
}
+ const bindingCleanups = { ...value.bindingCleanups };
+ const keep = normalized?.members.map((member) => member.key) ?? null;
+ if (keep === null || value.groups[providerId]?.members.some((member) => !keep.includes(member.key))) {
+ const previousKeep = bindingCleanups[providerId]?.keepMemberKeys;
+ bindingCleanups[providerId] = {
+ token: randomUUID(),
+ keepMemberKeys: previousKeep === null || keep === null
+ ? null
+ : previousKeep === undefined ? keep : keep.filter((key) => previousKeep.includes(key)),
+ at: Date.now(),
+ };
+ }
// 与移出组同一把锁、同一次原子替换:崩溃、离线、重新加入都不能丢掉清空旧同意的意图。
- return { groups, reshareCleanups };
- });
+ return { groups, reshareCleanups, bindingCleanups };
+ }));
+ assertCurrent();
return next.groups[providerId] ?? null;
}
+export function listProviderGroupBindingCleanups(): Readonly<Record<string, ProviderGroupBindingCleanup>> {
+ store.invalidateIfChanged();
+ return store.read().bindingCleanups ?? {};
+}
+
+/** 绑定与解除记录已经原子提交,只确认本次清理;迟到回执不清掉下一次移出的意图。 */
+export async function completeProviderGroupBindingCleanup(providerId: string, token: string): Promise<void> {
+ const assertCurrent = captureProviderManagementScope();
+ await store.updateAtomic(({ value }) => {
+ assertCurrent();
+ if (value.bindingCleanups?.[providerId]?.token !== token) return {};
+ const bindingCleanups = { ...value.bindingCleanups };
+ delete bindingCleanups[providerId];
+ return { bindingCleanups };
+ });
+ assertCurrent();
+}
+
/** 在同一把写锁内基于最新组配置做最小更新;更新器返回 undefined 表示放弃写入。 */
export async function updateProviderGroup(
providerId: string,
diff --git a/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts b/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts
index ee468b88c6..76d0e9b8e9 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts
@@ -325,9 +325,14 @@ describe('remote agent round trip', () => {
});
const sessionId = `grant-${randomUUID()}`;
const full = { sessionId, workingDir: project, model: 'm', permissionMode: 'bypassPermissions' as const };
+ let skip = false;
const depsFor = (deviceId: string) => ({
...makeDeps(host),
- credentialConsent: { description: 'Only this task.', grant: credentialGrantFor(sessionId, deviceId) },
+ credentialConsent: {
+ description: 'Only this task.',
+ skip: () => skip,
+ grant: credentialGrantFor(sessionId, deviceId),
+ },
});
let localConfirmations = 0;
// 打开一次 Agent、跑一轮、关闭(相当于 Orca Worker 一轮结束后被回收)。
@@ -358,6 +363,13 @@ describe('remote agent round trip', () => {
// 同一任务、同一分享、权限档未变:重建后不再确认。
await openRunClose(full);
expect(localConfirmations).toBe(1);
+ // 重建期间暂时打开分享级信任:恢复任务级授权不能因此丢失。
+ skip = true;
+ await openRunClose(full);
+ expect(localConfirmations).toBe(1);
+ skip = false;
+ await openRunClose(full);
+ expect(localConfirmations).toBe(1);
// 另一个分享不沿用。
await openRunClose(full, 'share:b');
expect(localConfirmations).toBe(2);
diff --git a/apps/desktop/src/main/remote-agent/controller/startRemote.ts b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
index 1d044784f0..7f95d51aaa 100644
--- a/apps/desktop/src/main/remote-agent/controller/startRemote.ts
+++ b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
@@ -239,7 +239,7 @@ export async function startRemoteAgentSession(
// 同一任务、同一分享、原始权限档未变时恢复之前的「本任务总是允许」(Orca Worker 等会在两轮之间被回收重建)。
const grant = credentialConsent?.grant;
const grantPermission = () => credentialGrantPermission(permissionMode, planMode);
- if (grant?.restore(grantPermission())) gate.allowCredentialsForSession();
+ if (grant?.restore(grantPermission())) gate.restoreCredentialsForSession();
let controller: RemoteAgentHandleController | null = null;
const executor = new RemoteExecutor({
workspace,
diff --git a/apps/desktop/src/main/remote-agent/executor/gate.ts b/apps/desktop/src/main/remote-agent/executor/gate.ts
index c69e5094b9..398bac082e 100644
--- a/apps/desktop/src/main/remote-agent/executor/gate.ts
+++ b/apps/desktop/src/main/remote-agent/executor/gate.ts
@@ -123,14 +123,18 @@ export class ExecutorGate {
this.mode = mode;
}
- /**
- * 本机用户在凭证确认卡上选择了「本任务总是允许」,或新执行器按任务级记录恢复了这项授权
- * (credentialGrants.ts)。权限档变化即失效。
- */
+ /** 本机用户在凭证确认卡上选择了「本任务总是允许」。 */
allowCredentialsForSession(): void {
if (this.confirmsCredentials()) this.credentialsAllowedForSession = true;
}
+ /** 新执行器按任务级记录恢复「本任务总是允许」;不受当前分享级信任开关影响。 */
+ restoreCredentialsForSession(): void {
+ // 任务级记录的恢复与当前分享级信任开关独立:信任开启时暂时不需要确认,
+ // 但关闭后仍应保留已经明确授予的任务级授权。
+ this.credentialsAllowedForSession = true;
+ }
+
/** 这个任务此刻要不要把凭证类操作交给本机用户确认。 */
private confirmsCredentials(): boolean {
const option = this.options.confirmCredentials;
diff --git a/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx b/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx
index 3783afc402..dd54b226e1 100644
--- a/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx
+++ b/apps/desktop/src/renderer/components/settings/OwnRemoteProviders.tsx
@@ -3,10 +3,10 @@
* 打开了「允许被远程调用」且已连接的供应商——也就是模型列表里能选的那些远程供应商。
*
* 与本机供应商同在左栏,图标右上角带远程角标(与模型列表同一个 RemoteSourceMark);点开在
- * 右栏只读地看它在哪台电脑、开放了哪些模型。修改要到那台电脑上去,这里不提供开关。
+ * 右栏查看所在电脑与开放模型;自己的供应商组可从这里进入「远程与分享」管理。供应商凭证仍在原电脑配置。
*
* 供应商组(provider-groups.md §10):另一台电脑把某个供应商建成了组时,组里的电脑与分享不再单独
- * 列出,组所在电脑那一项标成供应商组,详情里只读列出组内电脑与状态。规则与模型列表同一份。
+ * 列出,组所在电脑那一项标成供应商组,详情列出组内电脑与状态,并提供同账号管理入口。规则与模型列表同一份。
*/
import { useMemo } from 'react';
import { useTranslation } from 'react-i18next';
@@ -18,6 +18,7 @@ import { RemoteSourceMark } from '@/components/icons/RemoteSourceMark';
import { remoteAgentProviders } from '@/components/new-chat/unifiedModelSelection';
import { Tip } from '@/components/ui/tooltip';
import { RemoteProviderGroupMembers } from '@/features/provider-group/RemoteProviderGroupMembers';
+import { ProviderShareEntryButton } from '@/features/provider-share/ProviderShareEntryButton';
import { useLocalProviderGroups } from '@/features/provider-group/useLocalProviderGroups';
import { useControllableDevices } from '@/hooks/useControllableDevices';
import { useDevicesProviders } from '@/hooks/useDevicesProviders';
@@ -68,15 +69,21 @@ export function useOwnRemoteProviderList(): OwnRemoteProviderList {
return catalog ? [{ deviceId: device.deviceId, providers: catalog.providers }] : [];
}),
localGroups,
+ { includeDisabledGroups: true },
);
const entries = devices.flatMap((device) => {
const catalog = catalogs.get(device.deviceId);
if (!catalog) return [];
- return remoteAgentProviders(catalog.providers)
- // 带组的项照常列出:组所在电脑自己的这个供应商掉登录或被停用时,组仍按组员分配,组员也仍收在组里,
- // 不能让组和组员一起从设置里消失。
- .filter((provider) => (provider.connected && !provider.suspended)
+ const remoteProviderIds = new Set(
+ remoteAgentProviders(catalog.providers).map((provider) => provider.id),
+ );
+ return catalog.providers
+ // 带组的项照常列出:组所在电脑自己的这个供应商掉登录、被停用或关闭远程调用时,
+ // 组仍按组员分配,组员也仍收在组里,不能让组和组员一起从设置里消失。
+ .filter((provider) => (remoteProviderIds.has(provider.id)
|| groups.groups.has(remoteProviderEntryKey(device.deviceId, provider.id)))
+ && ((provider.connected && !provider.suspended)
+ || groups.groups.has(remoteProviderEntryKey(device.deviceId, provider.id))))
.filter((provider) => !groups.hidden.has(remoteProviderEntryKey(device.deviceId, provider.id)))
.map((provider): OwnRemoteProvider => {
const key = ownRemoteProviderKey(device.deviceId, provider.id);
@@ -192,8 +199,15 @@ export function OwnRemoteProviderRows({
);
}
-/** 右栏:自己另一台电脑上的一个供应商,只读。 */
-export function OwnRemoteProviderDetail({ entry }: { entry: OwnRemoteProvider }) {
+/**
+ * 右栏:自己另一台电脑上的一个供应商。供应商本身只读;是供应商组时提供「远程与分享」入口,
+ * 提示点只数本机生成的链接带来、由本机负责弹窗的待审批申请。
+ */
+export function OwnRemoteProviderDetail({ entry, pendingShareRequests = 0, onManage }: {
+ entry: OwnRemoteProvider;
+ pendingShareRequests?: number;
+ onManage?: () => void;
+}) {
const { t } = useTranslation();
const name = providerDisplayName(entry.provider, t);
const models = useMemo(
@@ -238,6 +252,9 @@ export function OwnRemoteProviderDetail({ entry }: { entry: OwnRemoteProvider })
/>
{t('settings.providers.remote.statusReady')}
</span>
+ {entry.group && onManage && (
+ <ProviderShareEntryButton groupSize={entry.group.members.length} pendingCount={pendingShareRequests} onOpen={onManage} />
+ )}
</div>
</div>
diff --git a/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx b/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
index f023ae4bc0..0323a88373 100644
--- a/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
+++ b/apps/desktop/src/renderer/components/settings/ProvidersSection.tsx
@@ -96,6 +96,7 @@ import {
OwnRemoteProviderDetail,
OwnRemoteProviderRows,
useOwnRemoteProviderList,
+ type OwnRemoteProvider,
} from './OwnRemoteProviders';
import { LlamaCppProviderDetail } from './LlamaCppProviderDetail';
import { MANAGED_LLAMACPP_PROVIDER_ID } from '../../../shared/llamaCpp';
@@ -2435,16 +2436,18 @@ export function ProvidersSection() {
const codexAuth = useCodexAuth();
const remoteControlEnabled = useRemoteControlEnabled();
// 供应商分享:入口提示点读待审批申请与待处理的转分享请求;管理页是本页的子页面(返回回到供应商详情)。
+ // 带 hostDeviceId 的申请在另一台电脑的分享里(那台的供应商 id 可能与本机重名),只计入那台的组入口。
const pendingShareRequests = useProviderSharePendingRequests();
const pendingReshares = useProviderSharePendingReshares();
const pendingShareCounts = useMemo(
() => pendingRequestCountByProvider([
- ...pendingShareRequests.map((item) => item.share),
+ ...pendingShareRequests.filter((item) => !item.hostDeviceId).map((item) => item.share),
...pendingReshares.map((item) => item.share),
]),
[pendingShareRequests, pendingReshares],
);
const [shareManageProviderId, setShareManageProviderId] = useState<string | null>(null);
+ const [shareManageRemote, setShareManageRemote] = useState<OwnRemoteProvider | null>(null);
const openaiReconnectRequired = codexAuth.state.kind === 'reconnect-required';
const [selectedId, setSelectedId] = useState<string | null>(null);
@@ -2765,6 +2768,7 @@ export function ProvidersSection() {
const target = searchParams.get(PROVIDER_SHARE_MANAGE_PARAM);
if (!target) return;
setShareManageProviderId(target);
+ setShareManageRemote(null);
const next = new URLSearchParams(searchParams);
next.delete(PROVIDER_SHARE_MANAGE_PARAM);
setSearchParams(next, { replace: true });
@@ -2811,6 +2815,7 @@ export function ProvidersSection() {
if (!connect && !wizardFlag && !importId) return;
// 这些深链要显示供应商主页或弹窗:先离开分享管理页,不能被它挡住。
setShareManageProviderId(null);
+ setShareManageRemote(null);
// 不用一次性 ref:消费后立即删参(下方 replace)即防重放;组件常驻期间
// 再次带参导航(如二次深链)仍应生效(review 反馈)。
if (importId) {
@@ -3072,21 +3077,27 @@ export function ProvidersSection() {
// 「分享 {供应商}」管理页:设置内的子页面,返回回到该供应商的详情。只替换主体内容,
// 下方的添加 / 编辑 / 导入弹窗层保持挂载,不会因打开管理页而丢失正在填写的内容。
- const shareManageProvider = shareManageProviderId ? byId.get(shareManageProviderId) ?? null : null;
+ const shareManageProvider = shareManageRemote?.provider ?? (shareManageProviderId ? byId.get(shareManageProviderId) ?? null : null);
const shareManagePage = shareManageProviderId ? (
<ProviderShareManagePage
- key={shareManageProviderId}
+ key={`${shareManageRemote?.deviceId ?? 'local'}:${shareManageProviderId}`}
providerId={shareManageProviderId}
- providerName={shareManageProvider?.name ?? shareManageProviderId}
+ providerName={shareManageProvider ? providerDisplayName(shareManageProvider, t) : shareManageProviderId}
providerIcon={shareManageProvider ? providerIcon(shareManageProvider, 18) : null}
+ deviceId={shareManageRemote?.deviceId}
+ deviceName={shareManageRemote?.deviceName}
+ initialGroup={shareManageRemote?.group}
+ remoteProvider={shareManageRemote?.provider}
// 供应商还没加载出来时不判「未开放」;生成链接时 main 会再校验。
gate={providerShareGate({
- remoteControlEnabled,
+ remoteControlEnabled: shareManageRemote ? true : remoteControlEnabled,
invocationEnabled: !shareManageProvider || shareManageProvider.remoteInvocationEnabled === true,
})}
onBack={() => {
- setSelectedId(shareManageProviderId);
+ if (shareManageRemote) setSelectedRemoteKey(shareManageRemote.key);
+ else setSelectedId(shareManageProviderId);
setShareManageProviderId(null);
+ setShareManageRemote(null);
}}
/>
) : null;
@@ -3248,7 +3259,15 @@ export function ProvidersSection() {
{selectedShare ? (
<ProviderShareReceivedDetail share={selectedShare} />
) : selectedRemote ? (
- <OwnRemoteProviderDetail entry={selectedRemote} />
+ <OwnRemoteProviderDetail
+ entry={selectedRemote}
+ pendingShareRequests={pendingShareRequests.filter((item) =>
+ item.hostDeviceId === selectedRemote.deviceId && item.share.providerId === selectedRemote.provider.id).length}
+ onManage={() => {
+ setShareManageRemote(selectedRemote);
+ setShareManageProviderId(selectedRemote.provider.id);
+ }}
+ />
) : cindySigninActive ? (
/* 登录引导是 brand-scale surface(DESIGN §3):48px 标识 → 24px 名字 →
一行价值主张 → 赠送余额徽标 → 黑 CTA,间距走 8px 系统。底部留白比
@@ -3367,7 +3386,7 @@ export function ProvidersSection() {
provider={effectiveSelected}
remoteControlEnabled={remoteControlEnabled}
pendingShareRequests={pendingShareCounts.get(effectiveSelected.id) ?? 0}
- onManageShare={() => setShareManageProviderId(effectiveSelected.id)}
+ onManageShare={() => { setShareManageRemote(null); setShareManageProviderId(effectiveSelected.id); }}
/>
)}
{!effectiveSelected.suspended &&
diff --git a/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx b/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx
index ed2c6ed43b..430bc5930c 100644
--- a/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx
+++ b/apps/desktop/src/renderer/components/settings/__tests__/OwnRemoteProviders.test.tsx
@@ -123,7 +123,7 @@ describe('useOwnRemoteProviders', () => {
expect([...result.current.hiddenShareIds]).toEqual(['s1']);
});
- it('keeps the group listed when the group computer’s own provider is logged out or paused', () => {
+ it('keeps the group listed when the group computer’s provider is logged out, paused, or closed to remote invocation', () => {
devices.value = [
{ deviceId: 'mini-a', name: "Magi's Mac Mini", platform: 'darwin' },
{ deviceId: 'mini-b', name: 'Studio', platform: 'darwin' },
@@ -132,7 +132,7 @@ describe('useOwnRemoteProviders', () => {
strategy: 'least',
members: [{ kind: 'local' }, { kind: 'device', agentDeviceId: 'mini-b', providerId: 'anthropic' }],
};
- for (const state of [{ connected: false }, { suspended: true }]) {
+ for (const state of [{ connected: false }, { suspended: true }, { remoteInvocationEnabled: false }]) {
catalogs.value = new Map([
['mini-a', { providers: [provider('anthropic', { ...state, group })], loading: false, error: null }],
['mini-b', { providers: [provider('anthropic')], loading: false, error: null }],
diff --git a/apps/desktop/src/renderer/features/provider-group/ProviderGroupAddDialog.tsx b/apps/desktop/src/renderer/features/provider-group/ProviderGroupAddDialog.tsx
index 716864a48e..d94c8b45e4 100644
--- a/apps/desktop/src/renderer/features/provider-group/ProviderGroupAddDialog.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/ProviderGroupAddDialog.tsx
@@ -3,7 +3,7 @@
*
* - 「已经能用的」:这台电脑已经能用的同一个供应商——你的其他电脑(已开「允许被远程调用」)和
* 别人分享给你的,与模型列表里的远程供应商同一个来源,勾选即可加入,不需要再申请;
- * - 「分享链接」:还不能用的别人的电脑,粘贴分享链接走现有申请流程,对方同意后回到这里勾选。
+ * - 「分享链接」:在组所在电脑走现有申请流程;远程管理时引导去那台电脑申请,避免在查看端领用。
*/
import { Check } from 'lucide-react';
import { useEffect, useMemo, useState } from 'react';
@@ -20,6 +20,7 @@ import {
import { ProviderSharePasteDialog } from '@/features/provider-share/ProviderSharePasteDialog';
import { providerShareComputerName } from '@/features/provider-share/providerShareNames';
import { cn } from '@/lib/utils';
+import { providerGroupManagementCommand } from './providerManagement';
import {
PROVIDER_GROUP_DEFAULT_LIMIT,
@@ -38,12 +39,14 @@ export function ProviderGroupAddDialog({
providerId,
providerName,
config,
+ deviceId,
onSave,
onClose,
}: {
providerId: string;
providerName: string;
config: ProviderGroupConfig | null;
+ deviceId?: string;
/** 保存成功返回 true;失败时调用方已提示,弹窗保持打开。 */
onSave: (config: ProviderGroupConfig, success: string) => Promise<boolean>;
onClose: () => void;
@@ -58,8 +61,7 @@ export function ProviderGroupAddDialog({
useEffect(() => {
let alive = true;
- window.electronAPI.providerGroup
- .command({ action: 'candidates', providerId })
+ providerGroupManagementCommand({ action: 'candidates', providerId }, deviceId)
.then((list) => {
if (alive) setCandidates(list);
})
@@ -69,7 +71,7 @@ export function ProviderGroupAddDialog({
return () => {
alive = false;
};
- }, [providerId]);
+ }, [providerId, deviceId]);
const selectable = useMemo(() => (candidates ?? []).filter((c) => !c.blocked), [candidates]);
@@ -234,10 +236,12 @@ export function ProviderGroupAddDialog({
) : (
<>
<p className="mt-3 text-13 leading-[1.5] text-[var(--confirm-desc)]">
- {t('providerGroup.add.linkDescription', { provider: providerName })}
+ {deviceId
+ ? t('providerGroup.add.remoteLinkDescription')
+ : t('providerGroup.add.linkDescription', { provider: providerName })}
</p>
<ProviderShareDialogFooter>
- <Button variant="cta" size="md" onClick={() => setPasteOpen(true)}>
+ <Button variant="cta" size="md" disabled={Boolean(deviceId)} onClick={() => setPasteOpen(true)}>
{t('providerGroup.add.pasteLink')}
</Button>
<Button variant="secondary" size="md" onClick={onClose}>
@@ -247,7 +251,7 @@ export function ProviderGroupAddDialog({
</>
)}
</ProviderShareDialog>
- {pasteOpen && (
+ {pasteOpen && !deviceId && (
<ProviderSharePasteDialog
onClose={() => {
setPasteOpen(false);
diff --git a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
index 20c616b010..7a91a8dcf4 100644
--- a/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/ProviderGroupSection.tsx
@@ -12,7 +12,8 @@
* 账号收在它下面,上限、开关、移出与额度仍按账号各管各的。
*/
import { ChevronRight, CircleMinus, Monitor, MoreHorizontal } from 'lucide-react';
-import { useCallback, useId, useMemo, useState } from 'react';
+import { useCallback, useEffect, useId, useMemo, useState } from 'react';
+import type { ProviderView } from '@cindy/model-providers';
import { useTranslation } from 'react-i18next';
import { formatQuotaResetAt } from '@/components/status/usageCardModel';
@@ -31,7 +32,6 @@ import { Tip } from '@/components/ui/tooltip';
import { useOptionalAuthDeviceId } from '@/contexts/AuthContext';
import { toast } from '@/lib/toast';
import { cn } from '@/lib/utils';
-import { mapIpcErrorToI18nKey } from '@/utils/ipcError';
import {
PROVIDER_GROUP_MAX_LIMIT,
@@ -54,6 +54,7 @@ import {
providerGroupDeviceVersion,
} from './providerGroupPresentation';
import { useProviderGroup } from './useProviderGroup';
+import { providerManagementErrorKey } from './providerManagement';
/**
* Claude 订阅的配额排序已对所有组策略生效(provider-groups.md §5,2026-10-15),不再单列「用量均衡」;
@@ -65,13 +66,27 @@ const selectableStrategy = (strategy: ProviderGroupStrategy): ProviderGroupStrat
const LIMIT_OPTIONS = Array.from({ length: PROVIDER_GROUP_MAX_LIMIT }, (_, i) => String(i + 1));
const WEIGHT_OPTIONS = ['1', '2', '3', '5', '10', '20', '50', String(PROVIDER_GROUP_MAX_WEIGHT)];
-export function ProviderGroupSection({ providerId, providerName }: { providerId: string; providerName: string }) {
+export function ProviderGroupSection({ providerId, providerName, deviceId, deviceName, initialConfig, remoteProvider, onConfigChange }: {
+ providerId: string;
+ providerName: string;
+ deviceId?: string;
+ deviceName?: string;
+ initialConfig?: ProviderGroupConfig | null;
+ remoteProvider?: ProviderView;
+ onConfigChange?: (config: ProviderGroupConfig | null) => void;
+}) {
const { t } = useTranslation();
const { confirm } = useConfirmDialog();
- const group = useProviderGroup(providerId, { live: true });
+ const group = useProviderGroup(providerId, { live: true, deviceId, initialConfig });
+ // 远程页面仍传入供应商详情供上层复用;组策略展示由主干统一采用配额优先规则。
+ void remoteProvider;
const [addOpen, setAddOpen] = useState(false);
const [saving, setSaving] = useState(false);
const config = group.view?.config ?? null;
+ const blocked = saving || group.loading || group.failed;
+ useEffect(() => {
+ if (group.view) onConfigChange?.(group.view.config);
+ }, [group.view, onConfigChange]);
const statuses = useMemo(
() => new Map((group.view?.members ?? []).map((status) => [status.key, status])),
[group.view],
@@ -85,13 +100,13 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
if (success) toast.success(success);
return true;
} catch (error) {
- toast.error(t(mapIpcErrorToI18nKey(error)));
+ toast.error(t(providerManagementErrorKey(error, Boolean(deviceId))));
return false;
} finally {
setSaving(false);
}
},
- [group, t],
+ [group, deviceId, t],
);
const updateMember = useCallback(
@@ -138,11 +153,11 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
await group.remove();
toast.success(t('providerGroup.toast.deleted', { provider: providerName }));
} catch (error) {
- toast.error(t(mapIpcErrorToI18nKey(error)));
+ toast.error(t(providerManagementErrorKey(error, Boolean(deviceId))));
} finally {
setSaving(false);
}
- }, [confirm, group, providerName, t]);
+ }, [confirm, group, providerName, deviceId, t]);
return (
<section className="mt-6 shrink-0" aria-labelledby="provider-group-title" data-testid="provider-group-section">
@@ -154,11 +169,11 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
{config && <span className="text-13 text-[var(--text-tertiary)]">{providerGroupDeviceCount(config.members)}</span>}
<span className="flex-1" />
{config && (
- <Button variant="secondary" size="sm" compact tone="quiet" disabled={saving} onClick={() => void deleteGroup()}>
+ <Button variant="secondary" size="sm" compact tone="quiet" disabled={blocked} onClick={() => void deleteGroup()}>
{t('providerGroup.section.delete')}
</Button>
)}
- <Button variant="primary" size="sm" compact disabled={saving || group.loading} onClick={() => setAddOpen(true)}>
+ <Button variant="primary" size="sm" compact disabled={blocked} onClick={() => setAddOpen(true)}>
{t('providerGroup.section.addComputer')}
</Button>
</div>
@@ -169,7 +184,7 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
{group.loading
? t('providerGroup.section.loading')
: group.failed
- ? t('providerGroup.section.loadFailed')
+ ? t(group.errorKey ?? 'providerGroup.section.loadFailed')
: t('providerGroup.section.empty', { provider: providerName })}
</p>
) : (
@@ -183,7 +198,9 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
strategy={config.strategy}
first={index === 0}
account={account}
- disabled={saving}
+ disabled={blocked}
+ ownerDeviceId={deviceId ?? null}
+ ownerDeviceName={deviceName}
onChange={(patch) => updateMember(member.key, patch)}
onRemove={(label) => void removeMember(member, label)}
/>
@@ -195,7 +212,12 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
data-testid="provider-group-device"
className={cn(index > 0 && 'border-t border-[var(--settings-theme-card-border)]')}
>
- <MemberDeviceHeader members={device.items} statuses={device.items.map((m) => statuses.get(m.key))} />
+ <MemberDeviceHeader
+ members={device.items}
+ statuses={device.items.map((m) => statuses.get(m.key))}
+ ownerDeviceId={deviceId ?? null}
+ ownerDeviceName={deviceName}
+ />
{device.items.map((member, accountIndex) => row(member, accountIndex + 1))}
</div>
);
@@ -210,7 +232,7 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
options={SELECTABLE_STRATEGIES.map((value) => ({
value,
label: t(`providerGroup.strategy.${value}`),
- disabled: saving,
+ disabled: blocked,
}))}
/>
<span className="flex-1" />
@@ -231,7 +253,7 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
</div>
<Switch
checked={config.autoSwitch}
- disabled={saving}
+ disabled={blocked}
aria-label={t('providerGroup.autoSwitch.label')}
onCheckedChange={(autoSwitch) => void save({ ...config, autoSwitch })}
/>
@@ -239,6 +261,11 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
</>
)}
</div>
+ {config && group.failed && (
+ <p role="status" className="mt-2 text-12 leading-[1.5] text-[var(--text-secondary)]">
+ {t(group.errorKey ?? 'providerGroup.section.loadFailed')}
+ </p>
+ )}
{config && (
<p className="mt-2 text-12 leading-[1.5] text-[var(--text-tertiary)]">{t('providerGroup.section.note')}</p>
)}
@@ -247,6 +274,7 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
<ProviderGroupAddDialog
providerId={providerId}
providerName={providerName}
+ deviceId={deviceId}
config={config}
onSave={(next, success) => save(next, success)}
onClose={() => setAddOpen(false)}
@@ -257,18 +285,23 @@ export function ProviderGroupSection({ providerId, providerName }: { providerId:
}
/** 组内电脑的称呼与来源;只有一个账号的电脑行与多个账号时的电脑这一层共用。 */
-function useMemberNames(member: ProviderGroupMember, status: ProviderGroupMemberStatus | undefined) {
+function useMemberNames(
+ member: ProviderGroupMember,
+ status: ProviderGroupMemberStatus | undefined,
+ ownerDeviceId: string | null = null,
+ ownerDeviceName?: string,
+) {
const { t } = useTranslation();
const ownerNameOf = useProviderShareOwnerNameOf();
// 分享来的电脑只用分享者的昵称称呼,不用电脑名(provider-sharing.md §6)。
const ownerName = member.kind === 'share' ? (status?.ownerName ?? ownerNameOf(member.agentDeviceId)) : null;
const label = member.kind === 'local'
- ? t('providerGroup.member.local')
+ ? ownerDeviceId ? (ownerDeviceName ?? status?.label ?? member.key) : t('providerGroup.member.local')
: member.kind === 'share'
? providerShareComputerName(t, ownerName)
: (status?.label ?? member.label ?? member.key);
const source = member.kind === 'local'
- ? status?.label
+ ? ownerDeviceId ? t('providerGroup.member.sourceDevice') : status?.label
: member.kind === 'device'
? t('providerGroup.member.sourceDevice')
: t('providerGroup.member.sourceShare', { name: ownerName ?? '' });
@@ -279,12 +312,16 @@ function useMemberNames(member: ProviderGroupMember, status: ProviderGroupMember
function MemberDeviceHeader({
members,
statuses,
+ ownerDeviceId,
+ ownerDeviceName,
}: {
members: readonly ProviderGroupMember[];
statuses: readonly (ProviderGroupMemberStatus | undefined)[];
+ ownerDeviceId: string | null;
+ ownerDeviceName?: string;
}) {
const { t } = useTranslation();
- const { label, source } = useMemberNames(members[0], statuses.find((status) => status != null));
+ const { label, source } = useMemberNames(members[0], statuses.find((status) => status != null), ownerDeviceId, ownerDeviceName);
return (
<div data-testid="provider-group-device-header" className="flex items-center gap-3 px-4 py-3">
<span
@@ -314,6 +351,8 @@ function MemberRow({
first,
account,
disabled,
+ ownerDeviceId,
+ ownerDeviceName,
onChange,
onRemove,
}: {
@@ -324,11 +363,13 @@ function MemberRow({
/** 同一台电脑上有几个账号时,这是第几个(从 1 起):行收在电脑下面,只写账号;不传就是一台电脑一行。 */
account?: number;
disabled: boolean;
+ ownerDeviceId: string | null;
+ ownerDeviceName?: string;
onChange: (patch: Partial<ProviderGroupMember>) => void;
onRemove: (label: string) => void;
}) {
const { t, i18n } = useTranslation();
- const { ownerName, label: computer, source } = useMemberNames(member, status);
+ const { ownerName, label: computer, source } = useMemberNames(member, status, ownerDeviceId, ownerDeviceName);
const accountName = account === undefined
? null
: providerGroupAccountName(member, status) ?? t('providerGroup.member.accountFallback', { index: account });
@@ -445,7 +486,7 @@ function MemberRow({
<Switch
checked={!member.paused}
disabled={disabled}
- aria-label={t(member.kind === 'local'
+ aria-label={t(member.kind === 'local' && !ownerDeviceId
? 'providerGroup.member.assignLocalAria'
: 'providerGroup.member.assignAria', { name: label })}
onCheckedChange={(on) => onChange({ paused: !on })}
@@ -479,7 +520,7 @@ function MemberRow({
{quotaOpen && (
<GroupMemberQuota
id={quotaId}
- target={groupMemberQuotaTarget(member, null, selfDeviceId)}
+ target={groupMemberQuotaTarget(member, ownerDeviceId, selfDeviceId)}
offline={status?.state === 'offline'}
/>
)}
diff --git a/apps/desktop/src/renderer/features/provider-group/RemoteProviderGroupMembers.tsx b/apps/desktop/src/renderer/features/provider-group/RemoteProviderGroupMembers.tsx
index 3d0d19be85..5daa20d1dc 100644
--- a/apps/desktop/src/renderer/features/provider-group/RemoteProviderGroupMembers.tsx
+++ b/apps/desktop/src/renderer/features/provider-group/RemoteProviderGroupMembers.tsx
@@ -1,7 +1,7 @@
/**
* 另一台电脑上的供应商组,只读(docs/product-rules/provider-groups.md §10):设置页里同账号另一台电脑的
* 供应商被建成了组时,详情里列出组内电脑与它们的状态(在线、正在运行几个任务、冷却到何时)。
- * 组的设置只能在组所在电脑上改。状态没有推送,打开期间定时重读。
+ * 修改从供应商详情的「远程与分享」进入同账号管理页。状态没有推送,打开期间定时重读。
* 与组所在电脑上的列表一样按电脑聚合:一台电脑有几个账号时先列电脑,账号收在它下面(providerGroupPresentation.ts)。
*/
import { ChevronRight, Monitor } from 'lucide-react';
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 c786ec8d63..158a703e27 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
@@ -12,6 +12,7 @@ import type { ProviderGroupConfig, ProviderGroupView } from '../../../../shared/
import { toast } from '@/lib/toast';
import zhCN from '../../../i18n/locales/zh-CN/common.json';
import { memberStatusText, ProviderGroupSection } from '../ProviderGroupSection';
+import { ProviderGroupAddDialog } from '../ProviderGroupAddDialog';
import { __testing as localGroupsTesting, useLocalProviderGroupsState } from '../useLocalProviderGroups';
import { __testing as groupViewTesting } from '../useProviderGroup';
@@ -105,7 +106,8 @@ beforeEach(() => {
groupViewTesting.reset();
confirmSpy.mockClear();
command.mockReset();
- command.mockImplementation(async (cmd: { action: string; config?: ProviderGroupConfig }) => {
+ vi.mocked(toast.error).mockClear();
+ command.mockImplementation(async (cmd: { action: string; config?: ProviderGroupConfig; expectedConfig?: ProviderGroupConfig | null }) => {
if (cmd.action === 'list') return stored ? { anthropic: stored } : {};
if (cmd.action === 'get') return viewOf(stored);
if (cmd.action === 'candidates') {
@@ -114,11 +116,14 @@ beforeEach(() => {
{ key: 'share:s1:anthropic', kind: 'share', agentDeviceId: 'share:s1', providerId: 'anthropic', label: 'Studio-PC', providerName: 'Anthropic', ownerName: 'Kai', blocked: 'member' },
];
}
- if (cmd.action === 'save') {
+ if (cmd.action === 'save-if-current' || cmd.action === 'delete-if-current') {
+ if (JSON.stringify(cmd.expectedConfig) !== JSON.stringify(stored)) throw new Error('[PROVIDER_GROUP_CHANGED] changed elsewhere');
+ }
+ if (cmd.action === 'save-if-current') {
stored = cmd.config ?? null;
return viewOf(stored);
}
- if (cmd.action === 'delete') {
+ if (cmd.action === 'delete-if-current') {
stored = null;
return viewOf(null);
}
@@ -153,8 +158,8 @@ describe('ProviderGroupSection', () => {
expect((candidates[1] as HTMLButtonElement).disabled).toBe(true);
fireEvent.click(candidates[0]);
fireEvent.click(within(dialog).getByRole('button', { name: 'providerGroup.add.confirm' }));
- await waitFor(() => expect(command).toHaveBeenCalledWith(expect.objectContaining({ action: 'save' })));
- const saved = command.mock.calls.find(([cmd]) => cmd.action === 'save')![0].config as ProviderGroupConfig;
+ await waitFor(() => expect(command).toHaveBeenCalledWith(expect.objectContaining({ action: 'save-if-current', expectedConfig: null })));
+ const saved = command.mock.calls.find(([cmd]) => cmd.action === 'save-if-current')![0].config as ProviderGroupConfig;
expect(saved.members.map((m) => m.key)).toEqual(['local', MINI.key]);
expect(saved).toMatchObject({ strategy: 'least', autoSwitch: true });
expect(await screen.findAllByTestId('provider-group-member')).toHaveLength(2);
@@ -162,6 +167,28 @@ describe('ProviderGroupSection', () => {
expect(toast.success).toHaveBeenCalledWith('providerGroup.toast.added:{"count":1,"provider":"Anthropic"}');
});
+ it.each(['save', 'delete'] as const)('refreshes a stale view after a rejected %s without replaying the write', async (operation) => {
+ const initial: ProviderGroupConfig = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
+ stored = initial;
+ render(<ProviderGroupSection providerId="anthropic" providerName="Anthropic" />);
+ await screen.findByTestId('provider-group-member');
+ await waitFor(() => expect((screen.getByRole('button', { name: 'providerGroup.section.delete' }) as HTMLButtonElement).disabled).toBe(false));
+ // 另一台电脑已经添加成员并改了上限,本页尚未轮询到。
+ const updated = { ...initial, members: [{ ...LOCAL, limit: 8 }, MINI] };
+ stored = updated;
+ if (operation === 'save') {
+ fireEvent.click(within(screen.getByTestId('provider-group-member')).getByRole('switch'));
+ } else {
+ fireEvent.click(screen.getByRole('button', { name: 'providerGroup.section.delete' }));
+ }
+ await waitFor(() => expect(toast.error).toHaveBeenCalledWith('ipcError.PROVIDER_GROUP_CHANGED'));
+ expect(await screen.findAllByTestId('provider-group-member')).toHaveLength(2);
+ expect(stored).toEqual(updated);
+ const writes = command.mock.calls.filter(([cmd]) => cmd.action.endsWith('-if-current'));
+ expect(writes).toHaveLength(1);
+ expect(writes[0][0]).toMatchObject({ action: `${operation}-if-current`, expectedConfig: initial });
+ });
+
// 转分享(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();
@@ -412,6 +439,47 @@ describe('ProviderGroupSection', () => {
.toEqual(['Claude Pro已在组里', 'Claude Max已在组里']);
});
+ it('keeps remote management and account quotas when grouping several accounts by computer', async () => {
+ const MINI_B = { ...MINI, key: 'device:mini:anthropic-b', providerId: 'anthropic-b', providerName: 'Claude B' };
+ const initial: ProviderGroupConfig = {
+ strategy: 'least', autoSwitch: true,
+ members: [LOCAL, { ...MINI, providerName: 'Claude A' }, MINI_B],
+ };
+ let finishRead!: (value: ProviderGroupView) => void;
+ command.mockImplementation(async (cmd: { request: { command: { action: string; config?: ProviderGroupConfig } } }) => {
+ const inner = cmd.request.command;
+ if (inner.action === 'get') return new Promise<ProviderGroupView>((resolve) => { finishRead = resolve; });
+ if (inner.action === 'save-if-current') return viewOf(inner.config!);
+ throw new Error('unexpected remote command');
+ });
+ render(<ProviderGroupSection providerId="anthropic" providerName="Claude" deviceId="owner-computer" deviceName="Owner PC" initialConfig={initial} />);
+ const devices = screen.getByTestId('provider-group-device');
+ const accountRows = within(devices).getAllByTestId('provider-group-member');
+ expect(accountRows).toHaveLength(2);
+ expect((within(accountRows[1]).getByRole('switch') as HTMLButtonElement).disabled).toBe(true);
+ expect((screen.getByRole('radio', { name: 'providerGroup.strategy.order' }) as HTMLButtonElement).disabled).toBe(true);
+ await act(async () => finishRead(viewOf(initial)));
+ expect(within(devices).getByTestId('provider-group-device-header').textContent).toContain('Mac mini');
+ fireEvent.click(accountRows[1].querySelector<HTMLButtonElement>('button[aria-expanded]')!);
+ expect(JSON.parse(within(accountRows[1]).getByTestId('member-quota').textContent!).target).toEqual({
+ kind: 'device', deviceId: 'mini', providerId: 'anthropic-b',
+ });
+ const ownerRow = screen.getAllByTestId('provider-group-member')[0];
+ expect(ownerRow.textContent).toContain('Owner PC');
+ fireEvent.click(ownerRow.querySelector<HTMLButtonElement>('button[aria-expanded]')!);
+ expect(JSON.parse(within(ownerRow).getByTestId('member-quota').textContent!).target).toEqual({
+ kind: 'device', deviceId: 'owner-computer', providerId: 'anthropic',
+ });
+ fireEvent.click(within(accountRows[1]).getByRole('switch'));
+ await waitFor(() => expect(command).toHaveBeenCalledWith({
+ action: 'remote-manage', deviceId: 'owner-computer',
+ request: { action: 'manage-group', command: {
+ action: 'save-if-current', providerId: 'anthropic', expectedConfig: initial,
+ config: { ...initial, members: [initial.members[0], initial.members[1], { ...MINI_B, paused: true }] },
+ } },
+ }));
+ });
+
it('shows the quota hint for a subscription group', async () => {
stored = { strategy: 'least', autoSwitch: true, members: [LOCAL] };
render(<ProviderGroupSection providerId="anthropic" providerName="Anthropic" />);
@@ -420,6 +488,30 @@ describe('ProviderGroupSection', () => {
});
});
+describe('ProviderGroupAddDialog share links', () => {
+ it('guides remote managers to the group computer without starting a local share request', async () => {
+ command.mockResolvedValue([]);
+ render(<ProviderGroupAddDialog providerId="anthropic" providerName="Claude" deviceId="owner-computer" config={null} onSave={vi.fn()} onClose={vi.fn()} />);
+ await waitFor(() => expect(command).toHaveBeenCalledWith({
+ action: 'remote-manage', deviceId: 'owner-computer', request: { action: 'manage-group', command: { action: 'candidates', providerId: 'anthropic' } },
+ }));
+ fireEvent.click(screen.getByRole('radio', { name: 'providerGroup.add.tabLink' }));
+ expect(screen.getByText('providerGroup.add.remoteLinkDescription')).toBeTruthy();
+ const paste = screen.getByRole('button', { name: 'providerGroup.add.pasteLink' }) as HTMLButtonElement;
+ expect(paste.disabled).toBe(true);
+ fireEvent.click(paste);
+ expect(screen.queryByTestId('provider-share-paste-dialog')).toBeNull();
+ });
+
+ it('keeps the share-link input available on the group computer', async () => {
+ render(<ProviderGroupAddDialog providerId="anthropic" providerName="Claude" config={null} onSave={vi.fn()} onClose={vi.fn()} />);
+ await screen.findAllByTestId('provider-group-candidate');
+ fireEvent.click(screen.getByRole('radio', { name: 'providerGroup.add.tabLink' }));
+ fireEvent.click(screen.getByRole('button', { name: 'providerGroup.add.pasteLink' }));
+ expect(await screen.findByTestId('provider-share-paste-dialog')).toBeTruthy();
+ });
+});
+
describe('ProviderGroupSection reopened', () => {
/** 让下一次「读组」(要逐台问状态,可能很慢)一直不回来。 */
function holdNextGet() {
diff --git a/apps/desktop/src/renderer/features/provider-group/providerManagement.ts b/apps/desktop/src/renderer/features/provider-group/providerManagement.ts
new file mode 100644
index 0000000000..8ec3e24531
--- /dev/null
+++ b/apps/desktop/src/renderer/features/provider-group/providerManagement.ts
@@ -0,0 +1,27 @@
+/** 页面复用本机管理组件,所有远程操作由本机 Main 转交原来的组所在电脑。 */
+import type { ProviderGroupCommandResult } from '../../../shared/providerGroup';
+import type { ProviderGroupManagementCommand, ProviderShareManagementCommand } from '../../../shared/providerManagement';
+import type { ProviderShareCommandResult } from '../../../shared/providerShare';
+import { extractIpcError, mapIpcErrorToI18nKey } from '@/utils/ipcError';
+
+export function providerGroupManagementCommand<C extends ProviderGroupManagementCommand>(
+ command: C, deviceId?: string,
+): Promise<ProviderGroupCommandResult<C>> {
+ return deviceId
+ ? window.electronAPI.providerGroup.command({ action: 'remote-manage', deviceId, request: { action: 'manage-group', command } }) as Promise<ProviderGroupCommandResult<C>>
+ : window.electronAPI.providerGroup.command(command);
+}
+
+export function providerShareManagementCommand<C extends ProviderShareManagementCommand>(
+ command: C, deviceId?: string,
+): Promise<ProviderShareCommandResult[C['action']]> {
+ return deviceId
+ ? window.electronAPI.providerGroup.command({ action: 'remote-manage', deviceId, request: { action: 'manage-share', command } })
+ : window.electronAPI.providerShare.command(command);
+}
+
+export function providerManagementErrorKey(error: unknown, remote: boolean): string {
+ const code = extractIpcError(error)?.code;
+ if (remote && code === 'UNSUPPORTED_CAPABILITY') return 'providerGroup.management.unsupported';
+ return mapIpcErrorToI18nKey(error);
+}
diff --git a/apps/desktop/src/renderer/features/provider-group/useProviderGroup.ts b/apps/desktop/src/renderer/features/provider-group/useProviderGroup.ts
index 46cf40e504..47cb238200 100644
--- a/apps/desktop/src/renderer/features/provider-group/useProviderGroup.ts
+++ b/apps/desktop/src/renderer/features/provider-group/useProviderGroup.ts
@@ -10,9 +10,11 @@
*/
import { useCallback, useEffect, useRef, useState } from 'react';
-import { getDataOwnerGeneration } from '@/contexts/dataOwnerGeneration';
+import { getDataOwnerGeneration, isDataOwnerGenerationCurrent } from '@/contexts/dataOwnerGeneration';
import type { ProviderGroupConfig, ProviderGroupView } from '../../../shared/providerGroup';
import { peekLocalProviderGroup } from './useLocalProviderGroups';
+import { providerGroupManagementCommand, providerManagementErrorKey } from './providerManagement';
+import { extractIpcError } from '@/utils/ipcError';
/** 组内电脑在线、正在运行等状态的重读间隔。 */
const REFRESH_INTERVAL_MS = 15_000;
@@ -20,18 +22,19 @@ const REFRESH_INTERVAL_MS = 15_000;
/** 上次读到的组,按「账号 + 供应商」存。 */
const lastViews = new Map<string, ProviderGroupView>();
-function cacheKey(providerId: string): string {
- return `${getDataOwnerGeneration().dataOwnerId ?? ''}\u0000${providerId}`;
+function cacheKey(providerId: string, deviceId?: string): string {
+ return `${getDataOwnerGeneration().dataOwnerId ?? ''}\u0000${deviceId ?? ''}\u0000${providerId}`;
}
-function remember(providerId: string, view: ProviderGroupView): void {
- lastViews.set(cacheKey(providerId), view);
+function remember(providerId: string, view: ProviderGroupView, deviceId?: string): void {
+ lastViews.set(cacheKey(providerId, deviceId), view);
}
/** 打开时先显示的组;null = 还不知道有没有组。 */
-function knownView(providerId: string): ProviderGroupView | null {
- const cached = lastViews.get(cacheKey(providerId));
+function knownView(providerId: string, deviceId?: string, initialConfig?: ProviderGroupConfig | null): ProviderGroupView | null {
+ const cached = lastViews.get(cacheKey(providerId, deviceId));
if (cached) return cached;
+ if (deviceId) return initialConfig ? { providerId, config: initialConfig, members: [] } : null;
const local = peekLocalProviderGroup(providerId);
return local.ready ? { providerId, config: local.config, members: [] } : null;
}
@@ -40,37 +43,45 @@ export interface ProviderGroupState {
view: ProviderGroupView | null;
loading: boolean;
failed: boolean;
+ errorKey: string | null;
reload: () => Promise<void>;
save: (config: ProviderGroupConfig) => Promise<ProviderGroupView>;
remove: () => Promise<ProviderGroupView>;
}
-export function useProviderGroup(providerId: string, options: { live?: boolean } = {}): ProviderGroupState {
- const [view, setView] = useState<ProviderGroupView | null>(() => knownView(providerId));
- const [loading, setLoading] = useState(() => knownView(providerId) === null);
+export function useProviderGroup(providerId: string, options: { live?: boolean; deviceId?: string; initialConfig?: ProviderGroupConfig | null } = {}): ProviderGroupState {
+ const { deviceId, initialConfig } = options;
+ const [view, setView] = useState<ProviderGroupView | null>(() => knownView(providerId, deviceId, initialConfig));
+ const [loading, setLoading] = useState(() => knownView(providerId, deviceId, initialConfig) === null || Boolean(deviceId));
const [failed, setFailed] = useState(false);
+ const [errorKey, setErrorKey] = useState<string | null>(null);
const seq = useRef(0);
const reload = useCallback(async () => {
const current = ++seq.current;
+ const owner = getDataOwnerGeneration();
try {
- const next = await window.electronAPI.providerGroup.command({ action: 'get', providerId });
- if (current !== seq.current) return;
- remember(providerId, next);
+ const next = await providerGroupManagementCommand({ action: 'get', providerId }, deviceId);
+ if (current !== seq.current || !isDataOwnerGenerationCurrent(owner)) return;
+ remember(providerId, next, deviceId);
setView(next);
setFailed(false);
- } catch {
- if (current !== seq.current) return;
+ setErrorKey(null);
+ } catch (error) {
+ if (current !== seq.current || !isDataOwnerGenerationCurrent(owner)) return;
setFailed(true);
+ setErrorKey(providerManagementErrorKey(error, Boolean(deviceId)));
} finally {
if (current === seq.current) setLoading(false);
}
- }, [providerId]);
+ }, [providerId, deviceId]);
useEffect(() => {
- const known = knownView(providerId);
+ const known = knownView(providerId, deviceId, initialConfig);
setView(known);
- setLoading(known === null);
+ setLoading(known === null || Boolean(deviceId));
+ setFailed(false);
+ setErrorKey(null);
void reload();
const off = window.electronAPI.providerGroup.onChanged((event) => {
if (event?.providerId === providerId) void reload();
@@ -79,7 +90,7 @@ export function useProviderGroup(providerId: string, options: { live?: boolean }
off();
seq.current += 1;
};
- }, [providerId, reload]);
+ }, [providerId, deviceId, initialConfig, reload]);
useEffect(() => {
if (!options.live) return;
@@ -90,27 +101,45 @@ export function useProviderGroup(providerId: string, options: { live?: boolean }
const apply = useCallback(
(next: ProviderGroupView) => {
seq.current += 1;
- remember(providerId, next);
+ remember(providerId, next, deviceId);
setView(next);
setFailed(false);
+ setErrorKey(null);
setLoading(false);
return next;
},
- [providerId],
+ [providerId, deviceId],
);
const save = useCallback(
- async (config: ProviderGroupConfig) =>
- apply(await window.electronAPI.providerGroup.command({ action: 'save', providerId, config })),
- [apply, providerId],
+ async (config: ProviderGroupConfig) => {
+ try {
+ return apply(await providerGroupManagementCommand({
+ action: 'save-if-current', providerId, config, expectedConfig: view?.config ?? null,
+ }, deviceId));
+ } catch (error) {
+ if (extractIpcError(error)?.code === 'PROVIDER_GROUP_CHANGED') await reload();
+ throw error;
+ }
+ },
+ [apply, providerId, deviceId, view, reload],
);
const remove = useCallback(
- async () => apply(await window.electronAPI.providerGroup.command({ action: 'delete', providerId })),
- [apply, providerId],
+ async () => {
+ try {
+ return apply(await providerGroupManagementCommand({
+ action: 'delete-if-current', providerId, expectedConfig: view?.config ?? null,
+ }, deviceId));
+ } catch (error) {
+ if (extractIpcError(error)?.code === 'PROVIDER_GROUP_CHANGED') await reload();
+ throw error;
+ }
+ },
+ [apply, providerId, deviceId, view, reload],
);
- return { view, loading, failed, reload, save, remove };
+ return { view, loading, failed, errorKey, reload, save, remove };
}
export const __testing = {
diff --git a/apps/desktop/src/renderer/features/provider-share/ProviderShareApproveDialog.tsx b/apps/desktop/src/renderer/features/provider-share/ProviderShareApproveDialog.tsx
index fff1207fab..d67eb85b19 100644
--- a/apps/desktop/src/renderer/features/provider-share/ProviderShareApproveDialog.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/ProviderShareApproveDialog.tsx
@@ -1,14 +1,17 @@
/**
* 分享者审批弹窗(设计稿场景 5):只显示申请人的昵称和头像,以及同一个配对码供核对。
* 右上角 × 与 Esc = 稍后处理,申请留在管理页「待处理」里(24 小时内有效)。
+ * 分享在同账号另一台电脑上时(本机生成的链接),同意 / 拒绝转交那台电脑执行。
*/
import { useState } from 'react';
import { useTranslation } from 'react-i18next';
import { Button } from '@/components/ui/button';
+import { providerManagementErrorKey, providerShareManagementCommand } from '@/features/provider-group/providerManagement';
+import { useDeviceProviders } from '@/hooks/useDeviceProviders';
import { useProviders } from '@/hooks/useProviders';
import { toast } from '@/lib/toast';
-import { extractIpcError, mapIpcErrorToI18nKey } from '@/utils/ipcError';
+import { extractIpcError } from '@/utils/ipcError';
import {
ProviderShareDialog,
@@ -32,17 +35,22 @@ export function ProviderShareApproveDialog({
const { t } = useTranslation();
const time = useShareTimeFormat();
const [busy, setBusy] = useState<'approve' | 'reject' | null>(null);
- const { request, share } = item;
+ const { request, share, hostDeviceId } = item;
const name = request.displayName;
const provider = share.providerLabel;
const { providers } = useProviders();
- const claudeEmail = sharesClaudeLoginEmail(providers.find((view) => view.id === share.providerId));
+ const remote = useDeviceProviders(hostDeviceId);
+ const providerForApproval = (hostDeviceId ? remote.providers : providers).find((view) => view.id === share.providerId);
+ const claudeEmail = sharesClaudeLoginEmail(providerForApproval);
+ // 请求成功不代表目录里有目标供应商;找到它并确认类型后才能同意,避免漏掉 Claude 邮箱告知。
+ const providerClassificationReady = providerForApproval !== undefined
+ && (!hostDeviceId || (!remote.loading && remote.error === null));
const decide = async (action: 'approve' | 'reject') => {
if (busy) return;
setBusy(action);
try {
- await window.electronAPI.providerShare.command({ action, requestId: request.requestId });
+ await providerShareManagementCommand({ action, requestId: request.requestId }, hostDeviceId);
removeProviderSharePendingRequest(request.requestId);
toast.success(
action === 'approve'
@@ -51,7 +59,7 @@ export function ProviderShareApproveDialog({
);
onClose();
} catch (error) {
- toast.error(t(mapIpcErrorToI18nKey(error)));
+ toast.error(t(providerManagementErrorKey(error, Boolean(hostDeviceId))));
// 申请已不在(被撤回、过期或在别处处理):不再停留在这条上。
if (extractIpcError(error)?.code === 'NOT_FOUND') {
removeProviderSharePendingRequest(request.requestId);
@@ -103,7 +111,7 @@ export function ProviderShareApproveDialog({
palette="confirmation"
size="lg"
loading={busy === 'approve'}
- disabled={busy !== null}
+ disabled={busy !== null || !providerClassificationReady}
onClick={() => void decide('approve')}
>
{t('providerShare.approve.approve')}
diff --git a/apps/desktop/src/renderer/features/provider-share/ProviderShareGlobalHost.tsx b/apps/desktop/src/renderer/features/provider-share/ProviderShareGlobalHost.tsx
index 227658c3bb..9243124c7a 100644
--- a/apps/desktop/src/renderer/features/provider-share/ProviderShareGlobalHost.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/ProviderShareGlobalHost.tsx
@@ -3,6 +3,8 @@
*
* - 分享者:启动时读一次 `owned`,把本次运行还没弹过的待审批申请排队;之后靠 REQUESTED 推送。
* 逐条弹审批弹窗,Esc / × = 稍后处理(申请留在管理页)。系统通知点击 → 打开对应管理页。
+ * 弹窗跟着生成链接的电脑(provider-sharing.md §4.1):链接由同账号另一台电脑生成的申请不在这里弹;
+ * 这台电脑为另一台电脑上的分享生成的链接,申请在这里弹。
* 转分享请求(成员经自己的供应商组转给别人用)不弹窗:RESHARE_REQUESTED 时重读,入口亮提示点、管理页处理。
* - 受邀者:分享链接(深链、粘贴、系统通知)→ 申请弹窗。等待期间关掉弹窗的申请,有结果时用
* toast 告知。同时启动「已收到的分享」同步,模型列表随时可用。
@@ -19,7 +21,7 @@ import { useProviderShareFavoriteCleanupFailed } from '@/state/providerShareFavo
import type { ProviderShareSettledEvent } from '../../../shared/providerShare';
import { ProviderShareApplyDialog, isProviderShareRequestTrackedByDialog } from './ProviderShareApplyDialog';
import { ProviderShareApproveDialog } from './ProviderShareApproveDialog';
-import { pendingRequestsFromOwned } from './providerShareFormat';
+import { pendingRequestsFromOwnerState } from './providerShareFormat';
import { providerShareManagePath } from './providerShareNavigation';
import {
addProviderShareRequested,
@@ -80,12 +82,12 @@ export function ProviderShareGlobalHost() {
void refreshProviderShareOwnerPending().then((state) => {
if (disposed || !state?.ready) return;
- enqueue(pendingRequestsFromOwned(state.shares).map((item) => item.request.requestId));
+ enqueue(pendingRequestsFromOwnerState(state).filter((item) => !item.quiet).map((item) => item.request.requestId));
});
const offRequested = api.onRequested((event) => {
addProviderShareRequested(event);
- enqueue([event.request.requestId]);
+ if (!event.quiet) enqueue([event.request.requestId]);
});
// 只在还有待审批申请(含转分享请求)时随推送重读(那时 main 本就在快速拉取),让撤回、过期、已处理的消失。
const offOwned = api.onOwnedChanged(() => {
diff --git a/apps/desktop/src/renderer/features/provider-share/ProviderShareLinkDialog.tsx b/apps/desktop/src/renderer/features/provider-share/ProviderShareLinkDialog.tsx
index 80d1a52cec..fd572b1604 100644
--- a/apps/desktop/src/renderer/features/provider-share/ProviderShareLinkDialog.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/ProviderShareLinkDialog.tsx
@@ -8,7 +8,6 @@ import { useTranslation } from 'react-i18next';
import { Button } from '@/components/ui/button';
import { Spinner } from '@/components/ui/spinner';
import { toast } from '@/lib/toast';
-import { mapIpcErrorToI18nKey } from '@/utils/ipcError';
import {
ProviderShareDialog,
@@ -16,6 +15,7 @@ import {
ProviderShareDialogTitle,
} from './ProviderShareDialog';
import { formatShareCountdown, shareLinkRemainingMs } from './providerShareFormat';
+import { providerManagementErrorKey, providerShareManagementCommand } from '../provider-group/providerManagement';
type LinkState =
| { status: 'creating' }
@@ -41,10 +41,12 @@ export function useShareLinkCountdown(expiresAt: string | null): number {
export function ProviderShareLinkDialog({
providerId,
providerLabel,
+ deviceId,
onClose,
}: {
providerId: string;
providerLabel: string;
+ deviceId?: string;
onClose: () => void;
}) {
const { t } = useTranslation();
@@ -62,16 +64,16 @@ export function ProviderShareLinkDialog({
setState({ status: 'creating' });
setCopied(false);
try {
- const created = await window.electronAPI.providerShare.command({ action: 'create-link', providerId });
+ const created = await providerShareManagementCommand({ action: 'create-link', providerId }, deviceId);
if (seq !== requestSeq.current) return;
setState({ status: 'ready', link: created.link, expiresAt: created.expiresAt });
if (announce) toast.success(tRef.current('providerShare.link.regenerated'));
} catch (error) {
if (seq !== requestSeq.current) return;
- setState({ status: 'error', message: tRef.current(mapIpcErrorToI18nKey(error)) });
+ setState({ status: 'error', message: tRef.current(providerManagementErrorKey(error, Boolean(deviceId))) });
}
},
- [providerId],
+ [providerId, deviceId],
);
useEffect(() => {
diff --git a/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx b/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx
index fb8f91125c..ea1ea1c693 100644
--- a/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/ProviderShareManagePage.tsx
@@ -1,6 +1,6 @@
/**
* 「{供应商} · 远程与分享」页(供应商分享 §7.2;供应商组 §10)。从设置 → 模型供应商「允许被远程调用」一行的
- * 「远程与分享」入口进入,可返回。只列**这台电脑**上的设置:供应商组、按使用方的用量、待审批申请与已分享的人。
+ * 「远程与分享」入口进入,可返回。本机或同账号组所在电脑共用这一页,设置、分享与用量始终读取管理对象所在电脑。
*
* 打开期间每次 OWNED_CHANGED 都按当前时间段重读(main 因此保持快速拉取,申请能尽快出现);
* 关闭、恢复、删除、同意、拒绝都立即生效,结果以 toast 说明。
@@ -8,14 +8,19 @@
import { ArrowLeft } from 'lucide-react';
import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
import { useTranslation } from 'react-i18next';
+import type { ProviderView } from '@cindy/model-providers';
import { Button } from '@/components/ui/button';
import { useConfirmDialog } from '@/components/ui/confirm-dialog-provider';
import { useDeviceLinkDeviceList } from '@/features/device-link/useDeviceLinkDeviceList';
+import { useDeviceProviders } from '@/hooks/useDeviceProviders';
+import { useProviders } from '@/hooks/useProviders';
import { toast } from '@/lib/toast';
import { cn } from '@/lib/utils';
-import { mapIpcErrorToI18nKey } from '@/utils/ipcError';
import { ProviderGroupSection } from '@/features/provider-group/ProviderGroupSection';
+import { providerManagementErrorKey, providerShareManagementCommand } from '@/features/provider-group/providerManagement';
+import { getDataOwnerGeneration, isDataOwnerGenerationCurrent } from '@/contexts/dataOwnerGeneration';
+import type { ProviderGroupConfig } from '../../../shared/providerGroup';
import type {
ProviderOwnUsageView,
@@ -25,7 +30,7 @@ import type {
ProviderShareUsageRange,
} from '../../../shared/providerShare';
import { ProviderShareLinkDialog } from './ProviderShareLinkDialog';
-import { pendingResharesFromOwned, type ProviderShareGate, type ProviderSharePendingRequest } from './providerShareFormat';
+import { pendingResharesFromOwned, sharesClaudeLoginEmail, type ProviderShareGate, type ProviderSharePendingRequest } from './providerShareFormat';
import { ProviderUsageSection } from './ProviderUsageSection';
import { publishProviderShareOwnerState, removeProviderSharePendingRequest } from './providerShareStore';
import { ShareAvatar } from './ShareAvatar';
@@ -38,44 +43,66 @@ export function ProviderShareManagePage({
providerName,
providerIcon,
gate,
+ deviceId,
+ deviceName,
+ initialGroup,
+ remoteProvider,
onBack,
}: {
providerId: string;
providerName: string;
providerIcon: ReactNode;
gate: ProviderShareGate;
+ deviceId?: string;
+ deviceName?: string;
+ initialGroup?: ProviderGroupConfig;
+ remoteProvider?: ProviderView;
onBack: () => void;
}) {
const { t } = useTranslation();
const { confirm } = useConfirmDialog();
const time = useShareTimeFormat();
- const selfDeviceName = useDeviceLinkDeviceList()?.find((device) => device.isSelf)?.name ?? null;
+ const devices = useDeviceLinkDeviceList();
+ const { providers } = useProviders();
+ const remoteCatalog = useDeviceProviders(deviceId);
+ const selfDeviceName = deviceId ? deviceName ?? devices?.find((device) => device.deviceId === deviceId)?.name ?? null
+ : devices?.find((device) => device.isSelf)?.name ?? null;
+ const [remoteGroup, setRemoteGroup] = useState<ProviderGroupConfig | null>(initialGroup ?? null);
const [range, setRange] = useState<ProviderShareUsageRange>('month');
const [state, setState] = useState<ProviderShareOwnerState | null>(null);
const [loadFailed, setLoadFailed] = useState(false);
+ const [loadErrorKey, setLoadErrorKey] = useState<string | null>(null);
const [own, setOwn] = useState<ProviderOwnUsageView | null>(null);
const [ownFailed, setOwnFailed] = useState(false);
const [linkOpen, setLinkOpen] = useState(false);
const [busy, setBusy] = useState<ReadonlySet<string>>(() => new Set());
const loadSeq = useRef(0);
+ const remoteLoadRange = useRef<ProviderShareUsageRange | null>(null);
const rangeRef = useRef(range);
rangeRef.current = range;
const load = useCallback(async () => {
- const seq = ++loadSeq.current;
const range = rangeRef.current;
+ if (deviceId && remoteLoadRange.current === range) return;
+ remoteLoadRange.current = range;
+ const seq = ++loadSeq.current;
+ const owner = getDataOwnerGeneration();
// 本机与我的其他电脑的用量读这台电脑自己的账本,不依赖分享服务,与分享的成员一起按同一个时间段读。
const [owned, ownUsage] = await Promise.allSettled([
- window.electronAPI.providerShare.command({ action: 'owned', range }),
- window.electronAPI.providerShare.command({ action: 'own-usage', providerId, range }),
+ providerShareManagementCommand({ action: 'owned', range }, deviceId),
+ providerShareManagementCommand({ action: 'own-usage', providerId, range }, deviceId),
]);
if (seq !== loadSeq.current) return;
+ remoteLoadRange.current = null;
+ if (!isDataOwnerGenerationCurrent(owner)) return;
if (owned.status === 'fulfilled') {
setState(owned.value);
setLoadFailed(false);
- publishProviderShareOwnerState(owned.value);
+ setLoadErrorKey(null);
+ if (!deviceId) publishProviderShareOwnerState(owned.value);
} else {
setLoadFailed(true);
+ setLoadErrorKey(providerManagementErrorKey(owned.reason, Boolean(deviceId)));
}
if (ownUsage.status === 'fulfilled') {
setOwn(ownUsage.value);
@@ -83,7 +110,7 @@ export function ProviderShareManagePage({
} else {
setOwnFailed(true);
}
- }, [providerId]);
+ }, [providerId, deviceId]);
useEffect(() => {
void load();
@@ -97,6 +124,12 @@ export function ProviderShareManagePage({
};
}, [load]);
+ useEffect(() => {
+ if (!deviceId) return;
+ const timer = window.setInterval(() => { if (document.visibilityState !== 'hidden') void load(); }, 5_000);
+ return () => window.clearInterval(timer);
+ }, [deviceId, load]);
+
// 同一个供应商在这台电脑上只应有一条分享;稳妥起见合并同供应商的全部记录。
const { members, requests, reshares } = useMemo(() => {
const shares = state?.ready ? state.shares.filter((share) => share.providerId === providerId) : [];
@@ -135,7 +168,8 @@ export function ProviderShareManagePage({
(item: ProviderSharePendingRequest, action: 'approve' | 'reject') =>
withBusy(item.request.requestId, async () => {
try {
- await window.electronAPI.providerShare.command({ action, requestId: item.request.requestId });
+ await providerShareManagementCommand({ action, requestId: item.request.requestId }, deviceId);
+ // 远程管理时,本机生成链接带来的申请也在待审批里(由本机弹窗),一并移除。
removeProviderSharePendingRequest(item.request.requestId);
toast.success(
action === 'approve'
@@ -143,18 +177,18 @@ export function ProviderShareManagePage({
: t('providerShare.toast.rejected', { name: item.request.displayName }),
);
} catch (error) {
- toast.error(t(mapIpcErrorToI18nKey(error)));
+ toast.error(t(providerManagementErrorKey(error, Boolean(deviceId))));
}
void load();
}),
- [load, providerName, t, withBusy],
+ [load, providerName, deviceId, t, withBusy],
);
const setMember = useCallback(
(member: ProviderShareMemberView, status: 'pause' | 'resume' | 'remove') =>
withBusy(member.memberId, async () => {
try {
- await window.electronAPI.providerShare.command({ action: 'set-member', memberId: member.memberId, status });
+ await providerShareManagementCommand({ action: 'set-member', memberId: member.memberId, status }, deviceId);
toast.success(
t(
status === 'pause'
@@ -166,19 +200,19 @@ export function ProviderShareManagePage({
),
);
} catch (error) {
- toast.error(t(mapIpcErrorToI18nKey(error)));
+ toast.error(t(providerManagementErrorKey(error, Boolean(deviceId))));
}
void load();
}),
- [load, t, withBusy],
+ [load, deviceId, 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 });
+ await providerShareManagementCommand({ action: 'reshare-decide', id: reshare.id, decision }, deviceId);
toast.success(
decision === 'approve'
? t('providerShare.manage.reshare.toastApproved', { name: reshare.name, owner, provider: providerName })
@@ -187,11 +221,11 @@ export function ProviderShareManagePage({
: t('providerShare.manage.reshare.toastRejected', { name: reshare.name }),
);
} catch (error) {
- toast.error(t(mapIpcErrorToI18nKey(error)));
+ toast.error(t(providerManagementErrorKey(error, Boolean(deviceId))));
}
void load();
}),
- [load, providerName, t, withBusy],
+ [load, providerName, deviceId, t, withBusy],
);
const removeMember = useCallback(
@@ -212,7 +246,12 @@ export function ProviderShareManagePage({
);
const ready = state?.ready === true;
- const canCreateLink = gate === 'on' && ready;
+ const canCreateLink = gate === 'on' && ready && !loadFailed;
+ const providerForApproval = (deviceId ? remoteCatalog.providers : providers).find((provider) => provider.id === providerId);
+ const sharesClaudeEmail = sharesClaudeLoginEmail(providerForApproval);
+ // 审批只用当前目录中的目标供应商分类;进入管理页时的旧投影不能证明它仍然存在。
+ const providerClassificationReady = providerForApproval !== undefined
+ && (!deviceId || (!remoteCatalog.loading && remoteCatalog.error === null));
return (
// 这一页自己滚动(设置页外层在「模型供应商」分区不滚)。始终预留滚动条槽位:展开组内电脑的配额、
@@ -244,7 +283,15 @@ export function ProviderShareManagePage({
</h2>
</div>
- <ProviderGroupSection providerId={providerId} providerName={providerName} />
+ {deviceId && (
+ <p className="mt-2 text-12 leading-[1.5] text-[var(--settings-section-desc)]">
+ {t('providerGroup.management.note', { device: selfDeviceName ?? deviceId })}
+ </p>
+ )}
+ <ProviderGroupSection
+ providerId={providerId} providerName={providerName} deviceId={deviceId} deviceName={deviceName}
+ initialConfig={initialGroup} remoteProvider={remoteProvider} onConfigChange={setRemoteGroup}
+ />
<ProviderUsageSection
providerId={providerId}
@@ -254,6 +301,8 @@ export function ProviderShareManagePage({
members={members}
membersLoading={!state && !loadFailed}
selfDeviceName={selfDeviceName}
+ ownerDeviceId={deviceId}
+ groupConfig={deviceId ? remoteGroup : undefined}
range={range}
onRangeChange={setRange}
time={time}
@@ -285,7 +334,7 @@ export function ProviderShareManagePage({
: gate === 'invocation-off'
? t('providerShare.manage.gateInvocation')
: loadFailed
- ? t('providerShare.manage.loadFailed')
+ ? t(deviceId && loadErrorKey ? loadErrorKey : 'providerShare.manage.loadFailed')
: t('providerShare.manage.notReady')}
</p>
)}
@@ -323,13 +372,18 @@ export function ProviderShareManagePage({
<span aria-hidden="true">·</span>
<span>{t('providerShare.manage.pending.expiresHint')}</span>
</div>
+ {sharesClaudeEmail && (
+ <p data-testid="provider-share-claude-email-callout" className="text-12 leading-[1.5] text-[var(--text-secondary)]">
+ {t('providerShare.approve.calloutClaudeEmail', { name: item.request.displayName })}
+ </p>
+ )}
</div>
<div className="flex shrink-0 items-center gap-1.5">
<Button
variant="secondary"
size="sm"
compact
- disabled={busy.has(item.request.requestId)}
+ disabled={loadFailed || busy.has(item.request.requestId)}
onClick={() => void decide(item, 'reject')}
>
{t('providerShare.approve.reject')}
@@ -338,7 +392,7 @@ export function ProviderShareManagePage({
variant="primary"
size="sm"
compact
- disabled={busy.has(item.request.requestId)}
+ disabled={loadFailed || !providerClassificationReady || busy.has(item.request.requestId)}
onClick={() => void decide(item, 'approve')}
>
{t('providerShare.approve.approve')}
@@ -374,7 +428,7 @@ export function ProviderShareManagePage({
variant="secondary"
size="sm"
compact
- disabled={busy.has(item.reshare.id)}
+ disabled={loadFailed || busy.has(item.reshare.id)}
onClick={() => void decideReshare(item.reshare, item.owner.displayName, 'reject')}
>
{t('providerShare.manage.reshare.reject')}
@@ -383,7 +437,7 @@ export function ProviderShareManagePage({
variant="primary"
size="sm"
compact
- disabled={busy.has(item.reshare.id)}
+ disabled={loadFailed || !providerClassificationReady || busy.has(item.reshare.id)}
onClick={() => void decideReshare(item.reshare, item.owner.displayName, 'approve')}
>
{t('providerShare.manage.reshare.approve')}
@@ -418,11 +472,12 @@ export function ProviderShareManagePage({
key={member.memberId}
member={member}
first={index === 0}
- busy={busy.has(member.memberId)}
+ busy={loadFailed || busy.has(member.memberId)}
time={time}
onPause={() => void setMember(member, member.status === 'paused' ? 'resume' : 'pause')}
onRemove={() => void removeMember(member)}
- reshareBusy={(id) => busy.has(id)}
+ reshareBusy={(id) => loadFailed || busy.has(id)}
+ canApproveReshare={providerClassificationReady}
onReshare={(reshare, decision) => void decideReshare(reshare, member.displayName, decision)}
/>
))
@@ -432,6 +487,7 @@ export function ProviderShareManagePage({
{linkOpen && (
<ProviderShareLinkDialog
+ deviceId={deviceId}
providerId={providerId}
providerLabel={providerName}
onClose={() => setLinkOpen(false)}
@@ -449,6 +505,7 @@ function MemberRow({
onPause,
onRemove,
reshareBusy,
+ canApproveReshare,
onReshare,
}: {
member: ProviderShareMemberView;
@@ -458,6 +515,7 @@ function MemberRow({
onPause: () => void;
onRemove: () => void;
reshareBusy: (id: string) => boolean;
+ canApproveReshare: boolean;
onReshare: (reshare: ProviderShareReshareView, decision: 'approve' | 'reject') => void;
}) {
const { t } = useTranslation();
@@ -550,7 +608,7 @@ function MemberRow({
size="sm"
compact
tone={approved ? 'danger' : undefined}
- disabled={reshareBusy(reshare.id)}
+ disabled={reshareBusy(reshare.id) || (!approved && !canApproveReshare)}
aria-label={t(
approved ? 'providerShare.manage.reshare.revokeAria' : 'providerShare.manage.reshare.approveAria',
{ name: reshare.name },
diff --git a/apps/desktop/src/renderer/features/provider-share/ProviderUsageSection.tsx b/apps/desktop/src/renderer/features/provider-share/ProviderUsageSection.tsx
index 6f27d6af5e..250dc6da53 100644
--- a/apps/desktop/src/renderer/features/provider-share/ProviderUsageSection.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/ProviderUsageSection.tsx
@@ -19,7 +19,7 @@ import { useLocalProviderGroups } from '@/features/provider-group/useLocalProvid
import { formatModelShort } from '@/lib/usageFormat';
import { cn } from '@/lib/utils';
-import { providerGroupPhysicalDeviceKey, PROVIDER_GROUP_LOCAL_MEMBER_KEY } from '../../../shared/providerGroup';
+import { providerGroupPhysicalDeviceKey, PROVIDER_GROUP_LOCAL_MEMBER_KEY, type ProviderGroupConfig } from '../../../shared/providerGroup';
import type {
ProviderOwnUsageView,
ProviderShareMemberView,
@@ -64,6 +64,8 @@ export function ProviderUsageSection({
members,
membersLoading,
selfDeviceName,
+ ownerDeviceId,
+ groupConfig,
range,
onRangeChange,
time,
@@ -77,6 +79,9 @@ export function ProviderUsageSection({
/** 分享服务的成员还没读到。 */
membersLoading: boolean;
selfDeviceName: string | null;
+ ownerDeviceId?: string;
+ /** 远程管理时由页面传入建组电脑上的组;不传时读本机组设置。 */
+ groupConfig?: ProviderGroupConfig | null;
range: ProviderShareUsageRange;
onRangeChange: (range: ProviderShareUsageRange) => void;
time: ShareTimeFormat;
@@ -85,7 +90,8 @@ export function ProviderUsageSection({
const user = useOptionalAuthUser();
const devices = useDeviceLinkDeviceList();
const ownerNameOf = useProviderShareOwnerNameOf();
- const group = useLocalProviderGroups()[providerId] ?? null;
+ const localGroups = useLocalProviderGroups();
+ const group = groupConfig === undefined ? localGroups[providerId] ?? null : groupConfig;
const memberKeys = useMemo(
() => group ? [...new Set(group.members.map(providerGroupPhysicalDeviceKey))] : [PROVIDER_GROUP_LOCAL_MEMBER_KEY],
[group],
@@ -147,7 +153,7 @@ export function ProviderUsageSection({
if (memberKey === null) return { name: t('providerGroup.usage.unattributed'), source: t('providerGroup.usage.unattributedSource') };
const removed = inGroup ? null : t('providerGroup.usage.removedMember');
if (memberKey === PROVIDER_GROUP_LOCAL_MEMBER_KEY) {
- return { name: t('providerGroup.member.local'), source: removed ?? selfDeviceName };
+ return { name: ownerDeviceId ? selfDeviceName ?? t('providerGroup.usage.unknownDevice') : t('providerGroup.member.local'), source: removed ?? (ownerDeviceId ? null : selfDeviceName) };
}
const member = group?.members.find((item) => item.key === memberKey)
?? group?.members.find((item) => providerGroupPhysicalDeviceKey(item) === memberKey);
@@ -166,7 +172,7 @@ export function ProviderUsageSection({
source: removed ?? (owner ? t('providerGroup.member.sourceShare', { name: owner }) : null),
};
},
- [devices, group, ownerNameOf, selfDeviceName, t],
+ [devices, group, ownerNameOf, ownerDeviceId, selfDeviceName, t],
);
const toggle = (key: string) =>
diff --git a/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareGlobalHost.test.tsx b/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareGlobalHost.test.tsx
index 661ea3d3b7..cfefb21c10 100644
--- a/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareGlobalHost.test.tsx
+++ b/apps/desktop/src/renderer/features/provider-share/__tests__/ProviderShareGlobalHost.test.tsx
@@ -26,6 +26,11 @@ vi.mock('react-i18next', () => ({
vi.mock('@/lib/toast', () => ({ toast: { success: vi.fn(), error: vi.fn(), info: vi.fn() } }));
vi.mock('@/contexts/AuthContext', () => ({ useAuth: () => bus.auth }));
vi.mock('@/lib/remoteCatalogSnapshot', () => ({ refreshRemoteCatalogSnapshot: vi.fn(async () => undefined) }));
+vi.mock('@/hooks/useDeviceProviders', () => ({
+ getCachedDeviceProviders: () => null,
+ useDeviceProviders: () => remoteCatalog,
+}));
+vi.mock('@/hooks/useProviders', () => ({ useProviders: () => localCatalog }));
vi.mock('@/features/cc-agent/lib/genericNewMakerRouteState', () => ({
makeGenericNewMakerRouteState: () => ({ workspacePrompt: 'generic' }),
}));
@@ -58,6 +63,17 @@ const bus = vi.hoisted(() => ({
manage: new Set<(event: { providerId: string }) => void>(),
}));
+const localCatalog = vi.hoisted(() => ({
+ providers: [] as Array<{ id: string; source: string; auth: { method: string; native?: string } }>,
+}));
+
+const remoteCatalog = vi.hoisted(() => ({
+ providers: [] as Array<{ id: string; source: string; auth: { method: string; native?: string } }>,
+ loading: false,
+ error: null as string | null,
+ unsupported: false,
+}));
+
function listen<T>(set: Set<T>) {
return (cb: T) => {
set.add(cb);
@@ -88,6 +104,11 @@ beforeEach(() => {
bus.requested.clear();
bus.settled.clear();
bus.manage.clear();
+ localCatalog.providers = [{ id: 'xd', source: 'builtin', auth: { method: 'apiKey' } }];
+ remoteCatalog.providers = [];
+ remoteCatalog.loading = false;
+ remoteCatalog.error = null;
+ remoteCatalog.unsupported = false;
currentOwner = ownerState();
bus.command.mockImplementation(async (command: { action: string }) => {
if (command.action === 'owned') return currentOwner;
@@ -251,6 +272,132 @@ describe('ProviderShareGlobalHost', () => {
);
});
+ // provider-sharing.md §4.1 第 4 步:审批弹窗跟着生成链接的电脑。
+ it('does not pop requests on this computer\'s share when another computer generated the link', async () => {
+ currentOwner = { ...ownerState(), quietRequestIds: ['req-1'] };
+ renderHost();
+ await waitFor(() => expect(bus.command).toHaveBeenCalledWith({ action: 'owned', range: 'month' }));
+ act(() => {
+ for (const listener of bus.requested) {
+ listener({
+ request: { ...request, requestId: 'req-2' },
+ share: { shareId: 'share-1', providerId: 'xd', providerLabel: 'Cindy AI' },
+ quiet: true,
+ });
+ }
+ });
+ await act(async () => { await Promise.resolve(); });
+ expect(screen.queryByTestId('provider-share-approve-dialog')).toBeNull();
+ });
+
+ it('pops a request for another computer\'s share after generating its link here, and hands the decision to that computer', async () => {
+ currentOwner = ownerState([]);
+ remoteCatalog.providers = [{ id: 'anthropic', source: 'builtin', auth: { method: 'oauth' } }];
+ const groupCommand = vi.fn(async () => ({ ok: true }));
+ Object.assign(window.electronAPI, { providerGroup: { command: groupCommand } });
+ renderHost();
+ await waitFor(() => expect(bus.command).toHaveBeenCalledWith({ action: 'owned', range: 'month' }));
+ act(() => {
+ for (const listener of bus.requested) {
+ listener({
+ request: { ...request, requestId: 'req-7', displayName: 'Kai' },
+ share: { shareId: 'share-group', providerId: 'anthropic', providerLabel: 'Anthropic' },
+ hostDeviceId: 'group-host',
+ });
+ }
+ });
+ const dialog = await screen.findByTestId('provider-share-approve-dialog');
+ expect(dialog.textContent).toContain('Kai');
+ fireEvent.click(screen.getByRole('button', { name: 'providerShare.approve.approve' }));
+ await waitFor(() => expect(screen.queryByTestId('provider-share-approve-dialog')).toBeNull());
+ expect(groupCommand).toHaveBeenCalledWith({
+ action: 'remote-manage',
+ deviceId: 'group-host',
+ request: { action: 'manage-share', command: { action: 'approve', requestId: 'req-7' } },
+ });
+ expect(bus.command).not.toHaveBeenCalledWith(expect.objectContaining({ action: 'approve' }));
+ });
+
+ it.each(['empty', 'unrelated'])('blocks a local approval when its provider directory is %s', async (catalog) => {
+ localCatalog.providers = catalog === 'empty' ? [] : [{ id: 'openai', source: 'builtin', auth: { method: 'oauth' } }];
+ renderHost();
+ await screen.findByTestId('provider-share-approve-dialog');
+ const approve = screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement;
+ expect(approve.disabled).toBe(true);
+ fireEvent.click(approve);
+ expect(bus.command).not.toHaveBeenCalledWith({ action: 'approve', requestId: 'req-1' });
+ const reject = screen.getByRole('button', { name: 'providerShare.approve.reject' }) as HTMLButtonElement;
+ expect(reject.disabled).toBe(false);
+ fireEvent.click(reject);
+ await waitFor(() => expect(bus.command).toHaveBeenCalledWith({ action: 'reject', requestId: 'req-1' }));
+ });
+
+ it.each(['empty', 'unrelated', 'loading', 'failed'])(
+ 'blocks a remote approval when its provider directory is %s, even if the local provider is known',
+ async (catalog) => {
+ localCatalog.providers = [{ id: 'anthropic', source: 'builtin', auth: { method: 'oauth' } }];
+ remoteCatalog.providers = catalog === 'empty' ? [] : [{
+ id: catalog === 'unrelated' ? 'openai' : 'anthropic', source: 'builtin', auth: { method: 'oauth' },
+ }];
+ remoteCatalog.loading = catalog === 'loading';
+ remoteCatalog.error = catalog === 'failed' ? 'directory unavailable' : null;
+ currentOwner = {
+ ready: true,
+ shares: [],
+ watchedRequests: [{
+ request,
+ share: { shareId: 'share-1', providerId: 'anthropic', providerLabel: 'Anthropic' },
+ hostDeviceId: 'host',
+ }],
+ };
+ const groupCommand = vi.fn(async () => ({ ok: true }));
+ Object.assign(window.electronAPI, { providerGroup: { command: groupCommand } });
+ renderHost();
+ await screen.findByTestId('provider-share-approve-dialog');
+ const approve = screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement;
+ expect(approve.disabled).toBe(true);
+ fireEvent.click(approve);
+ expect(groupCommand).not.toHaveBeenCalled();
+ const reject = screen.getByRole('button', { name: 'providerShare.approve.reject' }) as HTMLButtonElement;
+ expect(reject.disabled).toBe(false);
+ fireEvent.click(reject);
+ await waitFor(() => expect(groupCommand).toHaveBeenCalledWith({
+ action: 'remote-manage',
+ deviceId: 'host',
+ request: { action: 'manage-share', command: { action: 'reject', requestId: 'req-1' } },
+ }));
+ },
+ );
+
+ it('blocks approval until the remote provider directory classifies the provider', async () => {
+ remoteCatalog.loading = true;
+ currentOwner = {
+ ready: true,
+ shares: [],
+ watchedRequests: [{
+ request,
+ share: { shareId: 'share-1', providerId: 'anthropic', providerLabel: 'Anthropic' },
+ hostDeviceId: 'host',
+ }],
+ };
+ const view = renderHost();
+ await screen.findByTestId('provider-share-approve-dialog');
+ expect((screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement).disabled).toBe(true);
+
+ remoteCatalog.loading = false;
+ remoteCatalog.providers = [{ id: 'anthropic', source: 'builtin', auth: { method: 'oauth' } }];
+ view.rerender(
+ <MemoryRouter initialEntries={['/cc-agent']}>
+ <ProviderShareGlobalHost />
+ <LocationProbe />
+ </MemoryRouter>,
+ );
+ await waitFor(() =>
+ expect((screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement).disabled).toBe(false),
+ );
+ expect(screen.getByTestId('provider-share-approve-dialog').textContent).toContain('providerShare.approve.calloutClaudeEmail');
+ });
+
it('opens the management page from a notification click', async () => {
currentOwner = ownerState([]);
renderHost();
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 35fc5aa800..6c3762a6be 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
@@ -1,6 +1,7 @@
// @vitest-environment jsdom
import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ProviderView } from '@cindy/model-providers';
import type { ProviderGroupConfig } from '../../../../shared/providerGroup';
import type { ProviderOwnUsageView, ProviderShareOwnerState } from '../../../../shared/providerShare';
@@ -27,6 +28,16 @@ vi.mock('@/features/device-link/useDeviceLinkDeviceList', () => ({
{ deviceId: 'studio', name: 'Studio', isSelf: false },
],
}));
+const localCatalog = vi.hoisted(() => ({
+ providers: [] as Array<{ id: string; source: string; auth: { method: string; native?: string } }>,
+}));
+const remoteCatalog = vi.hoisted(() => ({
+ providers: [] as Array<{ id: string; source: string; auth: { method: string; native?: string } }>,
+ loading: false,
+ error: null as string | null,
+}));
+vi.mock('@/hooks/useProviders', () => ({ useProviders: () => localCatalog }));
+vi.mock('@/hooks/useDeviceProviders', () => ({ useDeviceProviders: () => remoteCatalog }));
vi.mock('@/contexts/AuthContext', async (importOriginal) => ({
...(await importOriginal<typeof import('@/contexts/AuthContext')>()),
useOptionalAuthUser: () => ({ name: 'Magi', avatar: null }),
@@ -130,6 +141,10 @@ beforeEach(() => {
resetProviderShareStoreForTests();
localGroupsTesting.reset();
localGroups = {};
+ localCatalog.providers = [{ id: 'xd', source: 'builtin', auth: { method: 'apiKey' } }];
+ remoteCatalog.providers = [];
+ remoteCatalog.loading = false;
+ remoteCatalog.error = null;
confirmSpy.mockClear();
command.mockReset();
command.mockImplementation(async (cmd: { action: string }) => {
@@ -144,8 +159,20 @@ beforeEach(() => {
providerShare: { command, onOwnedChanged: () => () => undefined, onReceivedChanged: () => () => undefined },
// 页面上方的供应商组一块(由 ProviderGroupSection 自己的测试覆盖):这里只给一个空组。
providerGroup: {
- command: async (cmd: { action: string; providerId: string }) =>
- cmd.action === 'list' ? localGroups : { providerId: cmd.providerId, config: null, members: [] },
+ command: async (cmd: {
+ action: string;
+ providerId?: string;
+ request?: { action: string; command?: { action: string } };
+ }) => {
+ if (cmd.action === 'list') return localGroups;
+ if (cmd.action === 'remote-manage') {
+ const action = cmd.request?.command?.action;
+ if (action === 'owned') return owned();
+ if (action === 'own-usage') return ownUsage();
+ if (action === 'approve' || action === 'reject') return { ok: true };
+ }
+ return { providerId: cmd.providerId, config: null, members: [] };
+ },
onChanged: () => () => undefined,
},
},
@@ -154,10 +181,23 @@ beforeEach(() => {
afterEach(() => cleanup());
-function renderPage(gate: 'on' | 'remote-off' | 'invocation-off' = 'on') {
+function renderPage(
+ gate: 'on' | 'remote-off' | 'invocation-off' = 'on',
+ options: { deviceId?: string; remoteProvider?: ProviderView } = {},
+) {
const onBack = vi.fn();
- render(<ProviderShareManagePage providerId="xd" providerName="Cindy AI" providerIcon={null} gate={gate} onBack={onBack} />);
- return { onBack };
+ const view = render(
+ <ProviderShareManagePage
+ providerId="xd"
+ providerName="Cindy AI"
+ providerIcon={null}
+ gate={gate}
+ deviceId={options.deviceId}
+ remoteProvider={options.remoteProvider}
+ onBack={onBack}
+ />,
+ );
+ return { onBack, ...view };
}
describe('ProviderShareManagePage', () => {
@@ -338,7 +378,7 @@ describe('ProviderShareManagePage', () => {
});
// 转分享(provider-sharing.md §4.3):成员想经自己的供应商组把这里的供应商转给别人用,主人逐人处理。
- it('lists reshare requests under pending, and lets the owner withdraw or grant decided ones', async () => {
+ it.each([undefined, 'studio'])('handles reshare decisions on the provider’s computer (%s)', async (deviceId) => {
command.mockImplementation(async (cmd: { action: string }) => {
if (cmd.action === 'owned') {
const state = owned();
@@ -354,13 +394,35 @@ describe('ProviderShareManagePage', () => {
if (cmd.action === 'reshare-decide') return { ok: true };
throw new Error(`unexpected ${cmd.action}`);
});
- renderPage();
+ remoteCatalog.providers = [{ id: 'xd', source: 'builtin', auth: { method: 'apiKey' } }];
+ const remoteCommand = vi.spyOn(window.electronAPI.providerGroup, 'command');
+ if (deviceId) {
+ remoteCommand.mockImplementation(async (cmd) => {
+ if (cmd.action === 'remote-manage' && cmd.request.action === 'manage-share') {
+ if (cmd.request.command.action === 'reshare-decide') return { ok: true };
+ return command(cmd.request.command);
+ }
+ return { providerId: 'xd', config: null, members: [] };
+ });
+ }
+ const expectDecision = async (id: string, decision: 'approve' | 'reject') => {
+ const decidedCommand = { action: 'reshare-decide', id, decision };
+ if (deviceId) {
+ await waitFor(() => expect(remoteCommand).toHaveBeenCalledWith({
+ action: 'remote-manage', deviceId, request: { action: 'manage-share', command: decidedCommand },
+ }));
+ expect(command).not.toHaveBeenCalledWith(decidedCommand);
+ } else {
+ await waitFor(() => expect(command).toHaveBeenCalledWith(decidedCommand));
+ }
+ };
+ renderPage('on', { deviceId });
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']);
+ expect(getProviderSharePendingReshares().map((item) => item.reshare.id)).toEqual(deviceId ? [] : ['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' }));
+ await expectDecision('rs-pending', 'approve');
// 处理过的人列在这个成员下方:已同意的可撤回,拒绝的可改为同意。
const decided = screen.getAllByTestId('provider-share-reshare-item');
@@ -369,9 +431,9 @@ describe('ProviderShareManagePage', () => {
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' }));
+ await expectDecision('rs-approved', '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' }));
+ await expectDecision('rs-rejected', 'approve');
});
it('disables link creation and explains why when sharing is gated', async () => {
@@ -381,4 +443,97 @@ describe('ProviderShareManagePage', () => {
expect(create.disabled).toBe(true);
expect(screen.getByRole('status').textContent).toBe('providerShare.manage.gateInvocation');
});
+
+ it('shows the Claude subscription email notice on the management page', async () => {
+ localCatalog.providers = [{ id: 'xd', source: 'builtin', auth: { method: 'oauth', native: 'claude' } }];
+ renderPage();
+ await screen.findAllByTestId('provider-share-pending-row');
+ expect(screen.getByTestId('provider-share-claude-email-callout').textContent).toContain(
+ 'providerShare.approve.calloutClaudeEmail',
+ );
+ expect((screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement).disabled).toBe(false);
+ });
+
+ it('does not show the Claude subscription email notice for a non-Claude provider', async () => {
+ localCatalog.providers = [{ id: 'xd', source: 'builtin', auth: { method: 'apiKey' } }];
+ renderPage();
+ await screen.findAllByTestId('provider-share-pending-row');
+ expect(screen.queryByTestId('provider-share-claude-email-callout')).toBeNull();
+ expect((screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement).disabled).toBe(false);
+ });
+
+ it.each(['empty', 'unrelated'])('blocks a local management approval when its provider directory is %s', async (catalog) => {
+ localCatalog.providers = catalog === 'empty' ? [] : [{ id: 'openai', source: 'builtin', auth: { method: 'oauth' } }];
+ renderPage();
+ await screen.findAllByTestId('provider-share-pending-row');
+ const approve = screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement;
+ expect(approve.disabled).toBe(true);
+ fireEvent.click(approve);
+ expect(command).not.toHaveBeenCalledWith({ action: 'approve', requestId: 'req-1' });
+ const reject = screen.getByRole('button', { name: 'providerShare.approve.reject' }) as HTMLButtonElement;
+ expect(reject.disabled).toBe(false);
+ fireEvent.click(reject);
+ await waitFor(() => expect(command).toHaveBeenCalledWith({ action: 'reject', requestId: 'req-1' }));
+ });
+
+ it.each(['empty', 'unrelated', 'loading', 'failed'])(
+ 'blocks a remote management approval when its provider directory is %s, even with an earlier provider snapshot',
+ async (catalog) => {
+ remoteCatalog.providers = catalog === 'empty' ? [] : [{
+ id: catalog === 'unrelated' ? 'openai' : 'xd', source: 'builtin', auth: { method: 'oauth', native: 'claude' },
+ }];
+ remoteCatalog.loading = catalog === 'loading';
+ remoteCatalog.error = catalog === 'failed' ? 'directory unavailable' : null;
+ const remoteCommand = vi.spyOn(window.electronAPI.providerGroup, 'command');
+ renderPage('on', {
+ deviceId: 'studio',
+ remoteProvider: {
+ id: 'xd', name: 'Cindy AI', source: 'builtin', agents: ['claude-code'],
+ auth: { method: 'oauth', native: 'claude' }, routing: {}, models: {}, connected: true,
+ },
+ });
+ await screen.findAllByTestId('provider-share-pending-row');
+ const approve = screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement;
+ expect(approve.disabled).toBe(true);
+ fireEvent.click(approve);
+ expect(remoteCommand).not.toHaveBeenCalledWith({
+ action: 'remote-manage',
+ deviceId: 'studio',
+ request: { action: 'manage-share', command: { action: 'approve', requestId: 'req-1' } },
+ });
+ const reject = screen.getByRole('button', { name: 'providerShare.approve.reject' }) as HTMLButtonElement;
+ expect(reject.disabled).toBe(false);
+ fireEvent.click(reject);
+ await waitFor(() => expect(remoteCommand).toHaveBeenCalledWith({
+ action: 'remote-manage',
+ deviceId: 'studio',
+ request: { action: 'manage-share', command: { action: 'reject', requestId: 'req-1' } },
+ }));
+ },
+ );
+
+ it('blocks approval on a remote management page until the provider directory is ready', async () => {
+ remoteCatalog.loading = true;
+ const view = renderPage('on', { deviceId: 'studio' });
+ await screen.findAllByTestId('provider-share-pending-row');
+ expect((screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement).disabled).toBe(true);
+ expect((screen.getByRole('button', { name: 'providerShare.approve.reject' }) as HTMLButtonElement).disabled).toBe(false);
+
+ remoteCatalog.loading = false;
+ remoteCatalog.providers = [{ id: 'xd', source: 'builtin', auth: { method: 'oauth', native: 'claude' } }];
+ view.rerender(
+ <ProviderShareManagePage
+ providerId="xd"
+ providerName="Cindy AI"
+ providerIcon={null}
+ gate="on"
+ deviceId="studio"
+ onBack={view.onBack}
+ />,
+ );
+ await waitFor(() =>
+ expect((screen.getByRole('button', { name: 'providerShare.approve.approve' }) as HTMLButtonElement).disabled).toBe(false),
+ );
+ expect(screen.getByTestId('provider-share-claude-email-callout')).toBeTruthy();
+ });
});
diff --git a/apps/desktop/src/renderer/features/provider-share/__tests__/providerShareFormat.test.ts b/apps/desktop/src/renderer/features/provider-share/__tests__/providerShareFormat.test.ts
index 8274af8a78..5df1d5f746 100644
--- a/apps/desktop/src/renderer/features/provider-share/__tests__/providerShareFormat.test.ts
+++ b/apps/desktop/src/renderer/features/provider-share/__tests__/providerShareFormat.test.ts
@@ -10,6 +10,7 @@ import {
formatShareTokens,
pendingRequestCountByProvider,
pendingRequestsFromOwned,
+ pendingRequestsFromOwnerState,
providerShareAgentDeviceId,
providerShareGate,
providerShareJoinErrorKind,
@@ -157,6 +158,31 @@ describe('providerShareFormat', () => {
expect(counts.get('openai')).toBe(1);
});
+ it('marks requests another computer prompts for and adds the ones this computer prompts for elsewhere', () => {
+ const request = (requestId: string, createdAt: string) => ({
+ requestId, displayName: requestId, avatarUrl: null, region: 'global' as const, pairingCode: '1111', createdAt, expiresAt: '2026-10-08T10:00:00Z',
+ });
+ const pending = pendingRequestsFromOwnerState({
+ ready: true,
+ shares: [{
+ shareId: 's1', providerId: 'xd', providerLabel: 'Cindy AI', createdAt: '2026-10-01T00:00:00Z', members: [],
+ requests: [request('local', '2026-10-07T10:00:00Z'), request('quiet', '2026-10-07T10:03:00Z')],
+ }],
+ quietRequestIds: ['quiet'],
+ watchedRequests: [
+ { request: request('watched', '2026-10-07T10:01:00Z'), share: { shareId: 'g1', providerId: 'xd', providerLabel: 'Cindy AI' }, hostDeviceId: 'group-host' },
+ // 没有来源电脑的条目不是另一台电脑上的分享,不收。
+ { request: request('stray', '2026-10-07T10:02:00Z'), share: { shareId: 'g1', providerId: 'xd', providerLabel: 'Cindy AI' } },
+ ],
+ });
+ expect(pending.map((item) => [item.request.requestId, item.hostDeviceId ?? null, item.quiet ?? false])).toEqual([
+ ['local', null, false],
+ ['watched', 'group-host', false],
+ ['quiet', null, true],
+ ]);
+ expect(pendingRequestsFromOwnerState({ ready: false, shares: [], watchedRequests: pending })).toEqual([]);
+ });
+
it('reports shares whose availability changed or that disappeared', () => {
const before = [received({ shareId: 'a' }), received({ shareId: 'b' }), received({ shareId: 'c' })];
const after = [
diff --git a/apps/desktop/src/renderer/features/provider-share/providerShareFormat.ts b/apps/desktop/src/renderer/features/provider-share/providerShareFormat.ts
index 419f0e6c1b..5b46c10781 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 ProviderShareOwnerState,
type ProviderShareReshareView,
} from '../../../shared/providerShare';
@@ -122,6 +123,14 @@ export function pendingRequestCountByProvider(
export interface ProviderSharePendingRequest {
request: ProviderShareRequestItem;
share: { shareId: string; providerId: string; providerLabel: string };
+ /** 分享在同账号另一台电脑上:本机生成了链接,由本机弹窗,处理转交那台电脑。本机的分享不带。 */
+ hostDeviceId?: string;
+ /** 链接由同账号另一台电脑生成:由那台弹窗,本机只计入提示点与管理页。 */
+ quiet?: boolean;
+}
+
+function byRequestTime(a: ProviderSharePendingRequest, b: ProviderSharePendingRequest): number {
+ return Date.parse(a.request.createdAt) - Date.parse(b.request.createdAt);
}
/** owned 快照 → 待审批申请列表(按申请时间先后)。 */
@@ -137,7 +146,20 @@ export function pendingRequestsFromOwned(
});
}
}
- return items.sort((a, b) => Date.parse(a.request.createdAt) - Date.parse(b.request.createdAt));
+ return items.sort(byRequestTime);
+}
+
+/** 整份 owned 状态 → 本机的待审批申请(标出由别处弹窗的),加上本机负责弹窗的其他电脑上的申请。 */
+export function pendingRequestsFromOwnerState(state: ProviderShareOwnerState): ProviderSharePendingRequest[] {
+ if (!state.ready) return [];
+ const quiet = new Set(state.quietRequestIds ?? []);
+ const local = pendingRequestsFromOwned(state.shares).map((item) =>
+ quiet.has(item.request.requestId) ? { ...item, quiet: true } : item);
+ const localIds = new Set(local.map((item) => item.request.requestId));
+ const watched = (state.watchedRequests ?? [])
+ .filter((item) => item.hostDeviceId && !localIds.has(item.request.requestId))
+ .map((item) => ({ request: item.request, share: item.share, hostDeviceId: item.hostDeviceId }));
+ return [...local, ...watched].sort(byRequestTime);
}
/** 待处理的转分享请求(provider-sharing.md §4.3):成员想把分享来的供应商经自己的供应商组转给这个人用。 */
diff --git a/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts b/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts
index f31dc2c08b..007061c304 100644
--- a/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts
+++ b/apps/desktop/src/renderer/features/provider-share/providerShareStore.ts
@@ -5,7 +5,8 @@
* - 已收到的分享(受邀者):首个订阅者触发一次 `received`,之后靠 RECEIVED_CHANGED 推送。
* 分享的状态、在线或所在电脑变化时刷新对应 `share:<id>` 的模型目录缓存,消失的分享作废缓存。
* - 待审批申请(分享者):由全局审批宿主播种(`owned` 一次)、REQUESTED 推送追加、审批后移除;
- * 管理页每次读取 `owned` 也会发布到这里。设置页入口的提示点读这份。
+ * 本机管理页每次读取 `owned` 也会发布到这里。设置页入口的提示点读这份。其中带 hostDeviceId 的是
+ * 本机为同账号另一台电脑上的分享生成链接后、由本机负责弹窗的申请(provider-sharing.md §4.1)。
* - 待处理的转分享请求(分享者):同一份 `owned` 快照里成员带的 reshares;RESHARE_REQUESTED 推送时重读。
*
* 注意:`owned` 会让 main 进入快速拉取(每 5 秒),所以这里**不**在每次 OWNED_CHANGED 都重读,
@@ -27,7 +28,7 @@ import type {
} from '../../../shared/providerShare';
import {
diffReceivedShares,
- pendingRequestsFromOwned,
+ pendingRequestsFromOwnerState,
pendingResharesFromOwned,
providerShareAgentDeviceId,
type ProviderSharePendingRequest,
@@ -232,7 +233,7 @@ function setPendingReshares(next: readonly ProviderSharePendingReshare[]): void
/** 一份 owned 快照是本机待审批申请(含转分享请求)的权威来源:整体替换。 */
export function publishProviderShareOwnerState(state: ProviderShareOwnerState): void {
setPendingReshares(state.ready ? pendingResharesFromOwned(state.shares) : []);
- setPending(state.ready ? pendingRequestsFromOwned(state.shares) : []);
+ setPending(pendingRequestsFromOwnerState(state));
}
export function getProviderSharePendingReshares(): readonly ProviderSharePendingReshare[] {
@@ -253,7 +254,12 @@ export function useProviderSharePendingReshares(): readonly ProviderSharePending
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 }]);
+ setPending([...pendingRequests, {
+ request: event.request,
+ share: event.share,
+ ...(event.hostDeviceId ? { hostDeviceId: event.hostDeviceId } : {}),
+ ...(event.quiet ? { quiet: true } : {}),
+ }]);
}
export function removeProviderSharePendingRequest(requestId: string): void {
diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.json
index 089fc21918..e85ce806c4 100644
--- a/apps/desktop/src/renderer/i18n/locales/en/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json
@@ -450,6 +450,10 @@
}
},
"providerGroup": {
+ "management": {
+ "note": "Managing the provider group on {{device}}. Changes are saved on that computer; keep it online.",
+ "unsupported": "The Cindy version on the computer with this group does not support remote management yet. Update Cindy on that computer first."
+ },
"page": {
"title": "{{provider}} · Remote & Sharing",
"shareTitle": "Sharing"
@@ -601,6 +605,7 @@
"confirm": "Add to Group",
"cancel": "Cancel",
"linkDescription": "Paste a {{provider}} share link from someone else. After they approve, come back to “Already Available” and select it.",
+ "remoteLinkDescription": "Enter the share link in the provider settings on the computer with this group. After the owner approves, come back to “Already Available” and select it.",
"pasteLink": "Paste Share Link"
},
"toast": {
@@ -810,6 +815,7 @@
"DEVICE_LINK_BUSY": "The remote computer is busy. Please try again shortly.",
"INVALID_PARAMS": "Invalid input. Please check and try again.",
"PRECONDITION_FAILED": "This action is unavailable in the current state. Please try again.",
+ "PROVIDER_GROUP_CHANGED": "The provider group changed elsewhere, so this action was not applied. Review the latest settings and try again.",
"MODEL_CONTEXT_USAGE_UNKNOWN": "Model not switched: Cindy can’t verify how much context this task uses. Keep the current model or start a new task.",
"MODEL_WINDOW_CURRENT_CONTEXT_UNKNOWN": "Model not switched: Cindy can’t verify the current model’s context window. Check the window setting for a custom model. If it can’t be changed, keep the current model or start a new task.",
"MODEL_WINDOW_TARGET_CONTEXT_UNKNOWN": "Model not switched: Cindy can’t verify the target model’s context window. Check the window setting for a custom model. If it can’t be changed, choose another model or start a new task.",
@@ -3348,7 +3354,7 @@
"rowLabelGroup": "{{provider}} · {{device}} · Provider Group",
"groupBadge_one": "Provider Group · {{count}} computer",
"groupBadge_other": "Provider Group · {{count}} computers",
- "groupNote": "{{device}} made this provider a provider group. When you start a task with it, {{device}} assigns the task to one of the computers below by its group strategy, and moves it to another one if that computer runs into a problem. To change the group, go to Settings → Providers on {{device}}.",
+ "groupNote": "{{device}} made this provider a provider group. When you start a task with it, {{device}} assigns the task to one of the computers below by its group strategy, and moves it to another one if that computer runs into a problem. While {{device}} is online, use Remote & Sharing here to manage the group and its shares.",
"groupMembersTitle": "Computers in the Group",
"groupMembersFailed": "Couldn’t get the status of the computers in the group right now."
},
diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.json
index 161e267cdb..8298eef2d5 100644
--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json
@@ -448,6 +448,10 @@
}
},
"providerGroup": {
+ "management": {
+ "note": "{{device}} のプロバイダーグループを管理しています。変更はそのパソコンに保存されます。オンラインの状態にしておいてください。",
+ "unsupported": "グループを作成したパソコンの Cindy は、まだリモート管理に対応していません。先にそのパソコンの Cindy を更新してください。"
+ },
"page": {
"title": "{{provider}} · リモートと共有",
"shareTitle": "共有"
@@ -593,6 +597,7 @@
"confirm": "グループに追加",
"cancel": "キャンセル",
"linkDescription": "ほかの人から共有された {{provider}} のリンクを貼り付けます。相手が承認したら、「すでに使えるもの」に戻って選択してください。",
+ "remoteLinkDescription": "グループがあるパソコンのプロバイダー設定で共有リンクを入力してください。相手が承認したら、「すでに使えるもの」に戻って選択してください。",
"pasteLink": "共有リンクを貼り付け"
},
"toast": {
@@ -800,6 +805,7 @@
"DEVICE_LINK_BUSY": "接続先のコンピュータが混み合っています。しばらくしてから再試行してください。",
"INVALID_PARAMS": "パラメータが無効です。確認して再試行してください。",
"PRECONDITION_FAILED": "現在の状態ではこの操作を実行できません。しばらくしてから再試行してください。",
+ "PROVIDER_GROUP_CHANGED": "プロバイダーグループが別の場所で変更されたため、この操作は適用されませんでした。最新の設定を確認してから、もう一度操作してください。",
"MODEL_CONTEXT_USAGE_UNKNOWN": "モデルは切り替わっていません。現在のタスクで使用中のコンテキスト量を確認できません。現在のモデルを維持するか、新しいタスクを作成してください。",
"MODEL_WINDOW_CURRENT_CONTEXT_UNKNOWN": "モデルは切り替わっていません。現在のモデルのコンテキストウィンドウを確認できません。カスタムモデルのウィンドウ設定を確認してください。変更できない場合は、現在のモデルを維持するか、新しいタスクを作成してください。",
"MODEL_WINDOW_TARGET_CONTEXT_UNKNOWN": "モデルは切り替わっていません。対象モデルのコンテキストウィンドウを確認できません。カスタムモデルのウィンドウ設定を確認してください。変更できない場合は、別のモデルを選ぶか、新しいタスクを作成してください。",
@@ -3319,7 +3325,7 @@
"modelsEmpty": "このプロバイダーには、そのパソコンで利用できるモデルがまだありません。",
"rowLabelGroup": "{{provider}} · {{device}} · プロバイダーグループ",
"groupBadge_other": "プロバイダーグループ · {{count}} 台のパソコン",
- "groupNote": "{{device}} はこのプロバイダーをプロバイダーグループにしています。モデル一覧で選んでタスクを新規作成すると、{{device}} がグループの割り当て方式に従って下のいずれかのパソコンにタスクを割り当て、そのパソコンで問題が起きたら別のパソコンに切り替えて続けます。グループを変更するには、{{device}} の「設定 → モデルプロバイダー」を開いてください。",
+ "groupNote": "{{device}} はこのプロバイダーをプロバイダーグループにしています。モデル一覧で選んでタスクを新規作成すると、{{device}} がグループの割り当て方式に従って下のいずれかのパソコンにタスクを割り当て、そのパソコンで問題が起きたら別のパソコンに切り替えて続けます。{{device}} がオンラインなら、ここから「リモートと共有」を開いてグループと共有を管理できます。",
"groupMembersTitle": "グループ内のパソコン",
"groupMembersFailed": "グループ内のパソコンの状態を今は取得できません。"
},
diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.json
index 2d95708ed3..45928a221d 100644
--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json
@@ -448,6 +448,10 @@
}
},
"providerGroup": {
+ "management": {
+ "note": "{{device}}의 제공자 그룹을 관리하고 있습니다. 변경 사항은 해당 컴퓨터에 저장되므로 온라인 상태를 유지해 주세요.",
+ "unsupported": "그룹이 있는 컴퓨터의 Cindy 버전은 아직 원격 관리를 지원하지 않습니다. 먼저 해당 컴퓨터의 Cindy를 업데이트해 주세요."
+ },
"page": {
"title": "{{provider}} · 원격 및 공유",
"shareTitle": "공유"
@@ -593,6 +597,7 @@
"confirm": "그룹에 추가",
"cancel": "취소",
"linkDescription": "다른 사람이 공유한 {{provider}} 링크를 붙여 넣습니다. 상대방이 승인하면 이미 사용 가능 탭으로 돌아와 선택하세요.",
+ "remoteLinkDescription": "그룹이 있는 컴퓨터의 제공자 설정에서 공유 링크를 입력하세요. 상대방이 승인하면 이미 사용 가능 탭으로 돌아와 선택하세요.",
"pasteLink": "공유 링크 붙여넣기"
},
"toast": {
@@ -800,6 +805,7 @@
"DEVICE_LINK_BUSY": "원격 컴퓨터가 사용 중입니다. 잠시 후 다시 시도해 주세요.",
"INVALID_PARAMS": "매개변수가 잘못되었습니다. 확인 후 다시 시도하세요.",
"PRECONDITION_FAILED": "현재 상태에서는 이 작업을 수행할 수 없습니다. 잠시 후 다시 시도하세요.",
+ "PROVIDER_GROUP_CHANGED": "다른 곳에서 제공자 그룹이 변경되어 이 작업이 적용되지 않았습니다. 최신 설정을 확인한 후 다시 시도하세요.",
"MODEL_CONTEXT_USAGE_UNKNOWN": "모델이 전환되지 않았습니다. 현재 작업에서 사용한 컨텍스트 양을 확인할 수 없습니다. 현재 모델을 유지하거나 새 작업을 만드세요.",
"MODEL_WINDOW_CURRENT_CONTEXT_UNKNOWN": "모델이 전환되지 않았습니다. 현재 모델의 컨텍스트 윈도우를 확인할 수 없습니다. 사용자 지정 모델의 윈도우 설정을 확인하세요. 변경할 수 없다면 현재 모델을 유지하거나 새 작업을 만드세요.",
"MODEL_WINDOW_TARGET_CONTEXT_UNKNOWN": "모델이 전환되지 않았습니다. 대상 모델의 컨텍스트 윈도우를 확인할 수 없습니다. 사용자 지정 모델의 윈도우 설정을 확인하세요. 변경할 수 없다면 다른 모델을 선택하거나 새 작업을 만드세요.",
@@ -3319,7 +3325,7 @@
"modelsEmpty": "이 제공자는 그 컴퓨터에서 아직 사용 가능한 모델을 공개하지 않았습니다.",
"rowLabelGroup": "{{provider}} · {{device}} · 제공자 그룹",
"groupBadge_other": "제공자 그룹 · 컴퓨터 {{count}}대",
- "groupNote": "{{device}}에서 이 제공자를 제공자 그룹으로 만들었습니다. 모델 목록에서 선택해 새 작업을 만들면 {{device}}가 그룹 배정 방식에 따라 아래 컴퓨터 중 한 대에 작업을 배정하고, 그 컴퓨터에 문제가 생기면 다른 컴퓨터로 바꿔 계속합니다. 그룹을 바꾸려면 {{device}}의 「설정 → 모델 제공자」로 가세요.",
+ "groupNote": "{{device}}에서 이 제공자를 제공자 그룹으로 만들었습니다. 모델 목록에서 선택해 새 작업을 만들면 {{device}}가 그룹 배정 방식에 따라 아래 컴퓨터 중 한 대에 작업을 배정하고, 그 컴퓨터에 문제가 생기면 다른 컴퓨터로 바꿔 계속합니다. {{device}}가 온라인이면 여기에서 「원격 및 공유」를 열어 그룹과 공유를 관리할 수 있습니다.",
"groupMembersTitle": "그룹의 컴퓨터",
"groupMembersFailed": "지금은 그룹의 컴퓨터 상태를 가져올 수 없습니다."
},
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 85aa41eeed..66afee23cd 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json
@@ -448,6 +448,10 @@
}
},
"providerGroup": {
+ "management": {
+ "note": "正在管理 {{device}} 上的供应商组。修改会保存到那台电脑,请保持它在线。",
+ "unsupported": "建组电脑的 Cindy 版本暂不支持远程管理。请先更新那台电脑上的 Cindy。"
+ },
"page": {
"title": "{{provider}} · 远程与分享",
"shareTitle": "分享"
@@ -593,6 +597,7 @@
"confirm": "加入供应商组",
"cancel": "取消",
"linkDescription": "粘贴别人分享的 {{provider}} 链接,对方同意后,回到「已经能用的」里勾选加入。",
+ "remoteLinkDescription": "请在组所在电脑的「模型供应商」设置中输入分享链接。对方同意后,再回到「已经能用的」勾选加入。",
"pasteLink": "粘贴分享链接"
},
"toast": {
@@ -800,6 +805,7 @@
"DEVICE_LINK_BUSY": "远端繁忙,请稍后重试。",
"INVALID_PARAMS": "参数无效,请检查后重试。",
"PRECONDITION_FAILED": "当前状态下无法执行此操作,请稍后重试。",
+ "PROVIDER_GROUP_CHANGED": "供应商组已在别处修改,本次操作未执行。请查看最新设置后重新操作",
"MODEL_CONTEXT_USAGE_UNKNOWN": "模型未切换:无法确认当前任务已使用的上下文。请保留当前模型,或新建任务后再选择",
"MODEL_WINDOW_CURRENT_CONTEXT_UNKNOWN": "模型未切换:无法确认当前模型的上下文窗口。请检查自定义模型的窗口设置;若无法修改,请保留当前模型或新建任务",
"MODEL_WINDOW_TARGET_CONTEXT_UNKNOWN": "模型未切换:无法确认目标模型的上下文窗口。请检查自定义模型的窗口设置;若无法修改,请选择其他模型或新建任务",
@@ -3319,7 +3325,7 @@
"modelsEmpty": "这个供应商在那台电脑上还没有开放可用的模型。",
"rowLabelGroup": "{{provider}} · {{device}} · 供应商组",
"groupBadge_other": "供应商组 · {{count}} 台电脑",
- "groupNote": "{{device}} 把这个供应商建成了供应商组。在模型列表里选它新建任务时,{{device}} 会按组策略把任务分给下面的一台电脑运行,那台出问题时自动换一台继续。要修改组,请到 {{device}} 的「设置 → 模型供应商」。",
+ "groupNote": "{{device}} 把这个供应商建成了供应商组。在模型列表里选它新建任务时,{{device}} 会按组策略把任务分给下面的一台电脑运行,那台出问题时自动换一台继续。{{device}} 在线时,你可以从这里的「远程与分享」管理这个组和分享。",
"groupMembersTitle": "组内电脑",
"groupMembersFailed": "暂时读不到组内电脑的状态。"
},
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 35cdc53f4f..27142cb703 100644
--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json
@@ -448,6 +448,10 @@
}
},
"providerGroup": {
+ "management": {
+ "note": "正在管理 {{device}} 上的供應商組。修改會儲存到那台電腦,請保持它在線。",
+ "unsupported": "建立組的電腦上的 Cindy 版本暫不支援遠端管理。請先更新那台電腦上的 Cindy。"
+ },
"page": {
"title": "{{provider}} · 遠端與分享",
"shareTitle": "分享"
@@ -593,6 +597,7 @@
"confirm": "加入供應商組",
"cancel": "取消",
"linkDescription": "貼上別人分享的 {{provider}} 連結,對方同意後,回到「已經能用的」裡勾選加入。",
+ "remoteLinkDescription": "請在供應商組所在電腦的「模型供應商」設定中輸入分享連結。對方同意後,再回到「已經能用的」勾選加入。",
"pasteLink": "貼上分享連結"
},
"toast": {
@@ -800,6 +805,7 @@
"DEVICE_LINK_BUSY": "遠端忙碌中,請稍後再試。",
"INVALID_PARAMS": "引數無效,請檢查後重試。",
"PRECONDITION_FAILED": "目前狀態下無法執行此操作,請稍後再試。",
+ "PROVIDER_GROUP_CHANGED": "供應商組已在別處修改,本次操作未執行。請查看最新設定後重新操作",
"MODEL_CONTEXT_USAGE_UNKNOWN": "模型未切換:無法確認目前任務已使用的上下文。請保留目前模型,或新增任務後再選擇",
"MODEL_WINDOW_CURRENT_CONTEXT_UNKNOWN": "模型未切換:無法確認目前模型的上下文視窗。請檢查自訂模型的視窗設定;若無法修改,請保留目前模型或新增任務",
"MODEL_WINDOW_TARGET_CONTEXT_UNKNOWN": "模型未切換:無法確認目標模型的上下文視窗。請檢查自訂模型的視窗設定;若無法修改,請選擇其他模型或新增任務",
@@ -3319,7 +3325,7 @@
"modelsEmpty": "這個供應商在那台電腦上還沒有開放可用的模型。",
"rowLabelGroup": "{{provider}} · {{device}} · 供應商組",
"groupBadge_other": "供應商組 · {{count}} 台電腦",
- "groupNote": "{{device}} 把這個供應商建成了供應商組。在模型列表裡選它新建任務時,{{device}} 會依組策略把任務分給下面的一台電腦執行,那台出問題時自動換一台繼續。要修改組,請到 {{device}} 的「設定 → 模型供應商」。",
+ "groupNote": "{{device}} 把這個供應商建成了供應商組。在模型列表裡選它新建任務時,{{device}} 會依組策略把任務分給下面的一台電腦執行,那台出問題時自動換一台繼續。{{device}} 在線時,你可以從這裡的「遠端與分享」管理這個組和分享。",
"groupMembersTitle": "組內電腦",
"groupMembersFailed": "暫時讀不到組內電腦的狀態。"
},
diff --git a/apps/desktop/src/renderer/lib/__tests__/remoteProviderGroups.test.ts b/apps/desktop/src/renderer/lib/__tests__/remoteProviderGroups.test.ts
index f735635f06..43cf1bc1d6 100644
--- a/apps/desktop/src/renderer/lib/__tests__/remoteProviderGroups.test.ts
+++ b/apps/desktop/src/renderer/lib/__tests__/remoteProviderGroups.test.ts
@@ -92,6 +92,16 @@ describe('collectRemoteProviderGroups', () => {
expect(result.hidden.size).toBe(0);
expect(result.groups.size).toBe(0);
});
+
+ it('can retain a closed group for settings management without changing the default remote list', () => {
+ const result = collectRemoteProviderGroups([
+ { deviceId: 'mini', providers: [
+ provider('anthropic', { remoteInvocationEnabled: false, group: group([{ kind: 'device', agentDeviceId: 'studio', providerId: 'anthropic' }]) }),
+ ] },
+ ], {}, { includeDisabledGroups: true });
+ expect(result.groups.has(remoteProviderEntryKey('mini', 'anthropic'))).toBe(true);
+ expect(result.hidden.has(remoteProviderEntryKey('studio', 'anthropic'))).toBe(true);
+ });
});
describe('providerGroupMemberOfRoute', () => {
diff --git a/apps/desktop/src/renderer/lib/remoteProviderGroups.ts b/apps/desktop/src/renderer/lib/remoteProviderGroups.ts
index 4d4cd12d44..8214fb4a39 100644
--- a/apps/desktop/src/renderer/lib/remoteProviderGroups.ts
+++ b/apps/desktop/src/renderer/lib/remoteProviderGroups.ts
@@ -38,6 +38,11 @@ export interface RemoteProviderGroups {
memberOf: ReadonlyMap<string, RemoteProviderGroupEntry>;
}
+export interface CollectRemoteProviderGroupsOptions {
+ /** 设置页需要保留关闭远程调用的组,以便仍能进入组管理;模型列表默认不保留。 */
+ includeDisabledGroups?: boolean;
+}
+
/**
* @param catalogs 列表里此刻在线的其他电脑的目录(带组摘要)。
* @param localGroups 任务所在电脑自己建的组(按供应商 id;本机任务时是本机的组):它们的组员同样收起,组那一项
@@ -46,6 +51,7 @@ export interface RemoteProviderGroups {
export function collectRemoteProviderGroups(
catalogs: Iterable<{ deviceId: string; providers: readonly ProviderView[] }>,
localGroups: Readonly<Record<string, ProviderGroupConfig>> = {},
+ options: CollectRemoteProviderGroupsOptions = {},
): RemoteProviderGroups {
const groups = new Map<string, ProviderGroupConfig>();
const memberOf = new Map<string, RemoteProviderGroupEntry>();
@@ -59,9 +65,9 @@ export function collectRemoteProviderGroups(
};
for (const { deviceId, providers } of catalogs) {
for (const provider of providers) {
- if (provider.remoteInvocationEnabled !== true) continue;
const config = remoteProviderGroupOf(provider);
if (!config) continue;
+ if (provider.remoteInvocationEnabled !== true && !options.includeDisabledGroups) continue;
groups.set(remoteProviderEntryKey(deviceId, provider.id), config);
addMembers({ deviceId, providerId: provider.id }, config);
}
diff --git a/apps/desktop/src/shared/ipc-errors.ts b/apps/desktop/src/shared/ipc-errors.ts
index 30cec7b408..862a339cb8 100644
--- a/apps/desktop/src/shared/ipc-errors.ts
+++ b/apps/desktop/src/shared/ipc-errors.ts
@@ -76,6 +76,7 @@ export type IpcErrorCode =
| 'INTERNAL'
| 'ALREADY_EXISTS'
| 'PRECONDITION_FAILED'
+ | 'PROVIDER_GROUP_CHANGED' // 编辑期间组设置已变化,拒绝覆盖,需重新读取
| 'HTML_PREVIEW_TOO_LARGE'
| 'HTML_PREVIEW_UNSUPPORTED'
// 本地模型切换窗口保护的可行动失败原因。device-link 继续降级为
@@ -335,6 +336,7 @@ const IPC_ERROR_CODES: ReadonlySet<IpcErrorCode> = new Set<IpcErrorCode>([
'ALREADY_EXISTS',
'IDENTITY_CONFLICT',
'PRECONDITION_FAILED',
+ 'PROVIDER_GROUP_CHANGED',
'HTML_PREVIEW_TOO_LARGE',
'HTML_PREVIEW_UNSUPPORTED',
'MODEL_CONTEXT_USAGE_UNKNOWN',
diff --git a/apps/desktop/src/shared/providerGroup.ts b/apps/desktop/src/shared/providerGroup.ts
index 730a006c15..c65f63f027 100644
--- a/apps/desktop/src/shared/providerGroup.ts
+++ b/apps/desktop/src/shared/providerGroup.ts
@@ -6,6 +6,7 @@
* 选一台组内电脑运行 Agent。产品规则见 docs/product-rules/provider-groups.md。
*/
import { isProviderShareAgentDeviceId, PROVIDER_SHARE_AGENT_DEVICE_PREFIX } from './providerShare.js';
+import type { ProviderManagementRequest, ProviderManagementResult } from './providerManagement';
export const PROVIDER_GROUP_IPC = {
/** Renderer → Main:全部操作走同一个命令通道。 */
@@ -173,11 +174,14 @@ export interface ProviderGroupCandidate {
blocked?: ProviderGroupCandidateBlock;
}
-export type ProviderGroupCommand =
+export type ProviderGroupLocalCommand =
| { action: 'get'; providerId: string }
| { action: 'candidates'; providerId: string }
| { action: 'save'; providerId: string; config: ProviderGroupConfig }
| { action: 'delete'; providerId: string }
+ /** 设置页按编辑时的完整配置保存;null 表示当时尚未建组。独立动作让旧端明确拒绝。 */
+ | { action: 'save-if-current'; providerId: string; config: ProviderGroupConfig; expectedConfig: ProviderGroupConfig | null }
+ | { action: 'delete-if-current'; providerId: string; expectedConfig: ProviderGroupConfig | null }
/** 同账号另一台电脑上这个供应商的组与组内电脑状态(只读)。 */
| { action: 'remote-view'; providerId: string; deviceId: string }
/** 本机全部组的设置(不读远端)。 */
@@ -185,6 +189,9 @@ export type ProviderGroupCommand =
/** 这个任务此刻归哪个组(模型列表把它显示在组那一项下)。 */
| { action: 'session-group'; sessionId: string };
+export type ProviderGroupCommand = ProviderGroupLocalCommand
+ | { action: 'remote-manage'; deviceId: string; request: ProviderManagementRequest };
+
/**
* 任务此刻归的组:`groupDeviceId` 为组所在电脑,null = 这台电脑自己建的组;`providerId` 是组那一项在组所在电脑上的
* 供应商 id。没归组(或位置与绑定对不上)为 null。
@@ -192,11 +199,12 @@ export type ProviderGroupCommand =
export type ProviderGroupSessionGroup = { groupDeviceId: string | null; providerId: string } | null;
export type ProviderGroupCommandResult<C extends ProviderGroupCommand> =
- C extends { action: 'list' } ? Record<string, ProviderGroupConfig>
+ C extends { action: 'remote-manage'; request: infer R extends ProviderManagementRequest } ? ProviderManagementResult<R>
+ : C extends { action: 'list' } ? Record<string, ProviderGroupConfig>
: C extends { action: 'get' } ? ProviderGroupView
: C extends { action: 'candidates' } ? ProviderGroupCandidate[]
- : C extends { action: 'save' } ? ProviderGroupView
- : C extends { action: 'delete' } ? ProviderGroupView
+ : C extends { action: 'save' | 'save-if-current' } ? ProviderGroupView
+ : C extends { action: 'delete' | 'delete-if-current' } ? ProviderGroupView
: C extends { action: 'remote-view' } ? ProviderGroupView
: C extends { action: 'session-group' } ? ProviderGroupSessionGroup
: never;
diff --git a/apps/desktop/src/shared/providerManagement.ts b/apps/desktop/src/shared/providerManagement.ts
new file mode 100644
index 0000000000..bef533f243
--- /dev/null
+++ b/apps/desktop/src/shared/providerManagement.ts
@@ -0,0 +1,39 @@
+/** 同账号供应商管理。沿用 provider-group:remote,由组所在电脑校验并执行。 */
+import type {
+ ProviderGroupCommandResult,
+ ProviderGroupLocalCommand,
+} from './providerGroup';
+import type { ProviderShareCommand, ProviderShareCommandResult } from './providerShare';
+
+export type ProviderGroupManagementCommand = Extract<
+ ProviderGroupLocalCommand,
+ { action: 'get' | 'candidates' | 'save-if-current' | 'delete-if-current' }
+>;
+
+export type ProviderShareManagementCommand = Extract<
+ ProviderShareCommand,
+ { action: 'owned' | 'own-usage' | 'create-link' | 'approve' | 'reject' | 'set-member' | 'reshare-decide' }
+>;
+
+export type ProviderManagementRequest =
+ | { action: 'manage-group'; command: ProviderGroupManagementCommand }
+ | { action: 'manage-share'; command: ProviderShareManagementCommand };
+
+export type ProviderManagementResult<R extends ProviderManagementRequest> =
+ R extends { action: 'manage-group'; command: infer C extends ProviderGroupManagementCommand }
+ ? ProviderGroupCommandResult<C>
+ : R extends { action: 'manage-share'; command: infer C extends ProviderShareManagementCommand }
+ ? ProviderShareCommandResult[C['action']]
+ : never;
+
+/** respondedAt 用于把分享链接的有效时间换算到控制端,避免两台电脑时钟不同。 */
+export interface ProviderManagementReply {
+ result: unknown;
+ respondedAt: number;
+}
+
+export function isProviderManagementRequest(raw: unknown): raw is ProviderManagementRequest {
+ if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return false;
+ const value = raw as Record<string, unknown>;
+ return value.action === 'manage-group' || value.action === 'manage-share';
+}
diff --git a/apps/desktop/src/shared/providerShare.ts b/apps/desktop/src/shared/providerShare.ts
index 572c89cd94..631b6d1db4 100644
--- a/apps/desktop/src/shared/providerShare.ts
+++ b/apps/desktop/src/shared/providerShare.ts
@@ -128,16 +128,26 @@ export interface ProviderShareOwnerState {
/** 分享服务可用(已登录、设备互联已连上本区域服务)。 */
ready: boolean;
shares: ProviderShareOwnedView[];
+ /** 本机分享里、链接由同账号另一台电脑生成的申请:由那台弹审批窗,本机只在管理页与提示点显示。 */
+ quietRequestIds?: string[];
+ /** 本机为同账号另一台电脑上的分享生成链接后收到的申请:由本机弹审批窗,处理转交那台电脑。 */
+ watchedRequests?: ProviderShareRequestedEvent[];
}
export interface ProviderShareLinkCreated {
link: string;
expiresAt: string;
+ /** Non-secret per-link identifier; absent when the host or server predates exact approval routing. */
+ linkId?: string;
}
export interface ProviderShareRequestedEvent {
request: ProviderShareRequestItem;
share: { shareId: string; providerId: string; providerLabel: string };
+ /** 分享在同账号另一台电脑上(本机生成了链接,由本机弹窗);本机的分享不带。 */
+ hostDeviceId?: string;
+ /** true = 链接由同账号另一台电脑生成,由那台弹窗,本机不弹。 */
+ quiet?: boolean;
}
export interface ProviderShareSettledEvent {
diff --git a/docs/dev-rules/credentials-and-local-storage.md b/docs/dev-rules/credentials-and-local-storage.md
index 4de9600c10..e3cc5cc9cc 100644
--- a/docs/dev-rules/credentials-and-local-storage.md
+++ b/docs/dev-rules/credentials-and-local-storage.md
@@ -203,6 +203,9 @@ Desktop 的运行时 refresh 遇到瞬时失败后,主动调用与定时重试
| 跨 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-share-approval-windows.json`,只记供应商 id、生成端关注的供应商所在电脑 id、非秘密链接标识 `linkId`(随机邀请口令的 SHA-256 摘要)与七分钟截止时刻,不含链接口令、申请、配对码或身份。复用设置文件跨进程锁与原子替换;生成链接返回前完成保存,静默与关注均按链接区分。本机新链接仅清除旧版按供应商静默的窗口,不影响其它链接的精确归属。旧记录仍可读,无标识的旧关注只接无标识申请。完整应用重启的第一轮快照前恢复;远端读取使用新运行时的同账号只读管理通道,不恢复旧回调或重放写操作。过期记录读时忽略、下次写入清理;账号切换隔离,损坏文件保留且拒绝覆写。见 `device-link/providerShareApprovalWindows.ts`、`providerShareHost.ts` 与 `__tests__/providerShareApprovalWindows.test.ts` |
+| 供应商组:本机组绑定待清理记录 | 复用 `userData/owners/<账号>/provider-group-prefs.json` 的可选 `bindingCleanups`,只记供应商 id、保留的组员键(整组删除为 null)、时间与不透明代次,不含消息、凭证或用户身份。与组修改共用文件锁和原子替换;组修改、清理回放与新绑定写入另共用同账号目录的 `provider-group-mutation.lock`(先取该锁,再取各文件锁),防止迟到清理误删新分配。账号切换或重启后仍使旧绑定失效;重新加入不撤销清理,多次移出的保留键取交集。新写绑定前先将旧绑定删除与解除记录原子提交,再按代次确认;写盘失败或确认中断保留意图重试,迟到确认不删除新一代记录。旧文件缺字段视为空,旧版写组设置保留未知根字段。见 `provider-group/store.ts`、`bindings.ts`、`managementScope.ts` 与 `__tests__/stores.test.ts` |
+| 供应商组:本机组的绑定解除记录 | 复用 `userData/owners/<账号>/provider-group-bindings.json` 的可选 `released`,按任务 id 只记供应商 id 与解除时间,不含消息、凭证或用户身份。删组或移出组员时,与对应绑定删除共用文件锁和原子替换;账号切换前已提交的两部分一同保留。旧文件缺字段视为空,旧版写绑定保留未知根字段,升级后解除记录优先于旧版恢复的绑定;显式重新分配给同一个组时原子清除记录。其他解除路径仍读写 `provider-group-released.json`,读方合并两处记录;损坏绑定文件保留并拒绝覆写。见 `provider-group/bindings.ts` 与 `__tests__/stores.test.ts` |
| 供应商组:转分享待清空记录 | 复用 `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,不含凭证或用量数值 |
@@ -211,11 +214,11 @@ Desktop 的运行时 refresh 遇到瞬时失败后,主动调用与定时重试
| macOS 菜单栏 helper(开发构建) | `userData/menubar/`,开发时由 `swiftc` 编译的 helper 及其 wordmark 图片和源码哈希;打包版改用 `resources/tools/menubar/`,不在 userData 落盘 |
| 供应商分享:受邀者会话登记 | `userData/remote-agent/guest-sessions.json`(控制端摘要 → 本机侧任务与原生会话 id),只用来限制受邀者只能恢复自己的会话,并在分享删除时精确清理影子工作区、附件与会话记录 |
| 供应商分享:跨区域标记 | `userData/remote-agent/provider-share-regions.json`,账号摘要 → 对方区域;**不含凭证**。跨区连接凭证只在内存里,用新身份名片重新换取;没有标记的账号从不联系对方区域 |
+| 供应商分享:受邀者对分享的本机偏好 | `userData/owners/<账号>/provider-share-guest-prefs.json`,分享 id → 分享所属区域与「信任 {分享者}」(凭证操作不再确认);只存显式打开的项,在同路径 `.lock` 跨进程安全锁内重读、修改和原子替换,拿不到锁不保存。持有权切换使排队和在途写入失效;已进入文件系统的替换在新持有者保存前完成,不能覆盖其撤销。不含昵称、对话或凭证。退出分享或分享从已确认区域的权威名单里消失时立即在内存撤销,并取消对应的在途启用;清理落盘失败也不恢复信任。实现与回归见 `providerShareGuestPrefs.ts` 及其同名单测 |
| 语音输入声纹(生物特征) | `userData/owners/<账号>/voice-speaker-profile.json`,「识别我的声音」录入的声纹向量与录入时间,经 `safeStorage` 加密后整体落盘(钥匙串不可用时拒绝写入,不降级明文);记录生成它的模型哈希,换模型后视为未录入。只在本机,不同步、不上传、不进日志(日志只记分数与次数);用户删除即删文件。录入用的朗读音频只在内存中处理,不落盘 |
| 语音输入声纹识别模型 | `userData/voice-models/<哈希前缀>-<文件名>.onnx`,按内容哈希从区域 CDN 下载并在可见前校验 SHA-256;不含个人数据,本机所有账号共用。新版本模型下载完成后删除旧版本文件 |
| Mobile 语音输入声纹(生物特征) | SecureStore(iOS 钥匙串 / Android Keystore)键 `xdt.voiceSpeakerProfile.v1.<账号 key 的 SHA-256 前 32 位>`,内容同 Desktop:声纹向量、录入时间与模型哈希;开关与灵敏度 override 在 AsyncStorage `cindy.mobile.voice-speaker-filter.v1.<账号 key>`。只在本机,不同步、不上传、不进日志;退出登录时随该账号的其他本机数据一起删除(模型文件保留)。删除前写 AsyncStorage `cindy.mobile.voice-speaker-filter.cleanup.v1.<账号 key>` 重试标记,不含声纹;失败时保留标记,启动、回到前台及该账号下次读写前重试,全部删除成功后才移除。标记落盘也失败时保留进程内重试,无法保证进程终止后的恢复;不因声纹删除失败阻止退出凭证清除。朗读音频只在内存中处理 |
| Mobile 语音输入声纹识别模型 | `cacheDirectory/voice-models/`,与 Desktop 同一组按内容哈希下载、校验 SHA-256 后才可见的文件;放缓存目录以免进入 iCloud / Android 备份。系统清理缓存后,下次语音输入发现缺失会在后台重新下载,本次不过滤 |
-| 供应商分享:受邀者对分享的本机偏好 | `userData/owners/<账号>/provider-share-guest-prefs.json`,分享 id → 分享所属区域与「信任 {分享者}」(凭证操作不再确认);只存显式打开的项,在同路径 `.lock` 跨进程安全锁内重读、修改和原子替换,拿不到锁不保存。持有权切换使排队和在途写入失效;已进入文件系统的替换在新持有者保存前完成,不能覆盖其撤销。不含昵称、对话或凭证。退出分享或分享从已确认区域的权威名单里消失时清掉 |
| 用户明确导出的文件 | 用户选择或任务明确指定的目标路径 |
- 内置 Skill 的官方身份只授予当前 manifest 已提交且指纹匹配的 bundle:`.active` 必须是
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index f5a984a9f7..575f2f3571 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -1122,7 +1122,10 @@ B 上的 Worker 是一条普通任务,`sessions.orca_remote_lead`(migration 01
- **本地数据**:C 上经另一台电脑的组分配的任务绑定存 `provider-group-remote-bindings.json`(按账号,与本机组的
`provider-group-bindings.json` 分开,降级后旧版本读不到它,不会误认成本机的同名组)。因组内电脑被移出或组被删除而
解除过绑定的任务按组记在 `provider-group-released.json`(按账号,2026-10-10),老任务纳入组时据此跳过(provider-groups.md
- §6、§9.4);旧版本不读也不改写它,降级再升级后记录仍在。组所在电脑的冷却按账号存 `provider-group-cooling.json`
+ §6、§9.4);旧版本不读也不改写它,降级再升级后记录仍在。本机删组或移出组员时,解除记录改为与绑定删除一起
+ 原子写入 `provider-group-bindings.json` 的可选 `released` 字段,避免账号切换或中断造成半完成;读方合并两处记录,
+ 显式重新分配给同一个组时清除该组记录。旧文件缺字段视为空,旧版本写绑定仍保留未知根字段;旧版本运行期间不识别
+ 这些新增的内联记录,升级后解除记录优先于旧版恢复的同组绑定。损坏绑定文件保留并拒绝覆写。组所在电脑的冷却按账号存 `provider-group-cooling.json`
(`{ cooling: { [providerId]: { [memberKey]: until } } }`,只存未到期的,2026-10-11),重启后照样避开;旧版本不读它。
不改数据库与服务端。
- 实现:`apps/desktop/src/main/provider-group/`(`remoteHandler.ts`、`remoteClient.ts`、`externalLoad.ts`、`leaseReporter.ts`、
@@ -1415,6 +1418,53 @@ G 与 O 之间不变。受邀者能调用的 channel 不变(仍是 `maker:remote
`provider-group/__tests__/usageReporter.test.ts`、`remoteHandler.test.ts`、`usage/__tests__/providerPartyUsageStore.test.ts`、
`maker-ipc/__tests__/sessionProviderPartyUsage.test.ts`。
+## 供应商组:同账号任意电脑管理(2026-10-14)
+
+产品规则见 [`provider-groups.md`](../product-rules/provider-groups.md) §9.8、§10 与
+[`provider-sharing.md`](../product-rules/provider-sharing.md) §4.1 第 4 步、§7.1。同账号电脑 C 管理组所在电脑 O 上的组与分享,
+组设置与分享仍保存在 O 上。
+
+- **`provider-group:remote` 新增 `action: 'manage-group'` / `'manage-share'`**(同一 channel、同一同账号 allowlist,
+ 受邀者与共享任务访客照旧 `CHANNEL_NOT_ALLOWED`):请求 `{ action, command }`,`command` 与本机命令同构,结构与校验在
+ `apps/desktop/src/shared/providerManagement.ts`。`manage-group` 只收 `get` / `candidates` / `save-if-current` / `delete-if-current`;
+ `manage-share` 只收 `owned` / `own-usage` / `create-link` / `approve` / `reject` / `set-member` / `reshare-decide`,其余回
+ `[PERMISSION_DENIED]`。回包 `{ result, respondedAt }`,`respondedAt` 只用于把链接有效期换算到 C 的时钟。
+ - O 在执行前后核对账号未切换;`approve` / `reject` / `set-member` 先刷新快照,申请或成员不在 O 的分享里回 `[NOT_FOUND]`;
+ `owned` 的回包只含 `{ ready, shares }`,不带 O 自己的弹窗安排。不再转发给第三台电脑。
+ - `reshare-decide` 只修改 O 当前账号的本机转分享记录,写锁内和返回前继续核对账号边界;撤回由 O 停止对应中转任务。
+ 旧 O 不认识该动作时明确拒绝,C 不重试、不改为在本机执行;完整转分享管理需要 O 更新。
+ 远程修改组后由 O 刷新转分享名单,逐人同意明细仍只附在 O 本机设置页的组视图里。
+ - C 不重放写请求;生成的链接在 C 的 Main 登记后才能复制。
+ - 添加组所在电脑已可用的供应商仍经 `candidates` 查询;受邀者预览和申请不在管理通道内。远程管理页的分享链接入口
+ 禁用并引导在 O 的模型供应商设置中输入,获批后回到可用列表添加,避免申请与跨区启用记录误落到 C。
+ - 组保存与删除必须携带编辑时的 `expectedConfig`(完整组配置,`null` = 当时尚未建组)。O 在已有跨进程文件写锁内
+ 重读并比较,不一致回 `[PROVIDER_GROUP_CHANGED]`,不写入、不清理任务绑定。C 重新读取详情、提示本次操作未执行,
+ 不自动重试写入。建组电脑自己的设置页使用同一条件写入,存储格式不变。
+ 独立动作名保证旧 O 明确拒绝,不能忽略新增条件后无条件写入;新 O 拒绝旧 C 的 `save` / `delete`,回
+ `[UNSUPPORTED_CAPABILITY]`。完整编辑需两端更新;只读查询、分享者操作与组的分配使用不受影响。
+- **审批弹窗跟着生成链接的电脑**:服务端 `POST /links` 与 owner 列表的每条申请追加 `linkId`(一次性随机邀请口令的
+ SHA-256 小写十六进制摘要,不是邀请口令)。O 执行 `manage-share` 的 `create-link` 后,7 分钟窗口内这条链接的新申请在 O 上只推
+ `REQUESTED { quiet: true }`(进管理页与提示点,不弹窗、不发系统通知)。O 本机生成链接只清除旧版按供应商静默的窗口,
+ 保留其它链接的精确归属;C 的关注也按 O + 供应商 + linkId 匹配,不能接管本机或第三台电脑生成的链接。C 在同一窗口内经
+ `manage-share owned` 向 O 读取分享申请,不能从 C 的 REST 分享列表找 O 的申请(服务端按当前设备隔离列表)。
+ 新申请经 `REQUESTED { hostDeviceId }` 在 C 上弹窗,同意 / 拒绝经 `manage-share` 转交 O。
+ 本机与每台关注电脑各自只保留一个在途读取;一台离线或迟迟不回包时,其他电脑与本机照常继续拉取,不重建 link 或 relay。
+ 失败或 `ready=false` 不当作空名单清理待审批申请,成功快照只清理对应电脑的申请;账号切换或运行时重建后的旧回包作废。
+ 同账号重连保留窗口期内的关注与去重状态,即使 C 本机没有分享也继续拉取。
+ 归属按账号保存,完整进程重启时在第一轮快照之前恢复;旧版无 linkId 的关注只接无标识的旧申请。
+ 这两个字段只在本机 Main → Renderer 之间,不跨设备;本机 `owned` 结果另带 `quietRequestIds` / `watchedRequests` 供审批宿主重载时使用。
+- **兼容**:旧 O 回 `CHANNEL_NOT_ALLOWED` 或 `[INVALID_PARAMS] unknown provider group action`,C 显示「建组电脑需要更新」,
+ 不影响组的分配与使用。旧 C 不发这两个动作,仍只能只读查看。O 只在执行过 `manage-share` 的 `create-link` 后才静默,
+ 旧 C 管不到 O,弹窗行为与之前相同。linkId 是 additive 字段,旧客户端忽略;新客户端本机生成及读取仍接受缺字段的旧服务端。
+ 跨电脑生成必须收到合法 linkId,O 在返回/登记链接前检查,C 在保存关注/登记复制前再次检查;缺字段回
+ `[UNSUPPORTED_CAPABILITY]` 提示更新,非法字段拒绝,不回退到按供应商关注,不重放写请求。服务端先部署到供应商所属区域
+ 的全部副本,再发布客户端;完整精确归属要求 O、C 都更新。服务端仅返回已有摘要,无数据库 migration、鉴权或 relay 帧变化。
+ 本机绑定的可选解除记录见上方 P2a「本地数据」。
+- 实现:`apps/desktop/src/main/provider-group/management.ts`(O)、`managementClient.ts`(C)、`remoteRegistration.ts`,
+ `apps/desktop/src/main/device-link/providerShareHost.ts`(静默与关注)、`providerShareRuntime.ts`;回归见
+ `provider-group/__tests__/{managementClient,ipc,stores}.test.ts`、`device-link/__tests__/providerShareRuntime.test.ts`、
+ `renderer/features/provider-share/__tests__/ProviderShareGlobalHost.test.tsx`、`providerShareFormat.test.ts`。
+
## 事实来源
| 内容 | 权威来源 |
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index 16472eea57..e9adbe00ef 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -82,6 +82,8 @@
→ 对方同意,同意后直接加入组。自己账号的电脑不需要链接(服务端也拒绝申请自己账号的分享,`PROVIDER_SHARE_SELF`)。
首版:「分享链接」一页打开现有的输入分享链接与申请流程,对方同意后回到「已经能用的」勾选加入;
申请前按组核对供应商、同意后直接加入组放到 P2。
+ 首版远程管理时只开放添加组所在电脑已能用的供应商;分享链接入口禁用并引导在组所在电脑的模型供应商设置中输入,
+ 对方同意后回到可用列表加入。申请与跨区启用记录不能误落到查看电脑(供应商分享 §8)。
- **必须是同一个供应商**,不一致时不发送申请,提示「这个链接分享的是 {对方供应商},不是 {本供应商},
不能加入这个供应商组」;可勾选的列表只列同一个供应商。「同一个」按下面的口径判断,不直接比较供应商 ID:
- **官方供应商与订阅账号**(Anthropic、OpenAI、xAI 及其登录预设):同一品牌即可。内置的默认连接 ID 固定
@@ -485,7 +487,9 @@
(`groupSize`,2026-10-10)。2026-10-12 增加按需读取的匿名状态(`groupStatus`):只含固定状态枚举,
不含组员标识、真实名称、来源关系、任务数、并发上限、订阅配额或用量。组摘要里分享来的组员也不带名字
(旧快照可能是那位分享者的电脑名)。
-8. **分享来的电脑不借组转给别人**(2026-10-15):分享的人的任务只分给主人逐人同意过这个人的分享来的电脑,那台电脑
+8. **同账号管理在组所在电脑上执行。**(2026-10-14,§10)`manage-group` / `manage-share` 只接受同账号电脑,
+ 只含组设置与分享者操作;组所在电脑自己校验申请与成员属于它的分享,执行后不再转发给其他电脑,账号在途切换即作废。
+9. **分享来的电脑不借组转给别人**(2026-10-15):分享的人的任务只分给主人逐人同意过这个人的分享来的电脑,那台电脑
打开被转来的任务时再核对一次(供应商分享 §4.3、§9 第 8 条);原分享被删除或已退出后那台移出组(§3)。
## 10. 界面
@@ -519,6 +523,19 @@
还没有单独的「按组内电脑」切换;
3. **分享**:生成分享链接、待处理、已分享的人(按人用量已移到「用量」块,这里只管分享本身)。
未开启「允许被远程调用」时,这一块置灰并说明先开启哪一级(供应商分享 §3)。
+- **同账号任意电脑管理**(2026-10-14 用户裁决:组属于账号,不该只能在建组电脑上管):登录同一账号的任意电脑,
+ 都能从设置页左栏组那一项的详情点「远程与分享」,进入与建组电脑同一个页面,管理组内电脑、并发上限与权重、组策略、
+ 添加电脑,生成分享链接、处理申请、暂停或删除分享的人,查看用量。当前电脑不需要在组里。
+ - 组设置与分享仍保存在建组电脑上:每个操作经同账号通道交给建组电脑校验并执行,各台电脑看到同一份结果;
+ 建组电脑需要在线,页面顶部写明正在管理哪台电脑上的组。建组电脑版本过旧时提示先更新那台电脑上的 Cindy。
+ - 多台电脑同时编辑时,保存与删除须核对编辑时的组设置;已被修改就保留已保存的结果,拒绝旧快照覆盖。
+ 页面重读最新设置并说明本次操作未执行,由用户看过后重新操作,不自动重试写入。建组电脑本机的设置页同样适用。
+ 实现与回归:`provider-group/store.ts`、`ipc.ts`,`provider-group/__tests__/{stores,ipc}.test.ts` 与
+ `renderer/features/provider-group/__tests__/ProviderGroupSection.test.tsx`。
+ - 页面里「本机」那一行指建组电脑,用电脑名称呼;用量、配额都读建组电脑,不误显示当前电脑的数据。
+ - 在这里生成的分享链接,申请由当前电脑弹审批窗(供应商分享 §4.1 第 4 步)。
+ - 只开放组设置与分享者操作,受邀者与共享任务访客拿不到;不经建组电脑再转发给第三台。供应商本身的凭证与开关
+ 仍到那台电脑上配置。手机本期不提供组管理。
- **自己的组显示版本与分享兼容提示**(2026-10-12 用户裁决):建组电脑的设置页、同账号另一台电脑查看组的只读详情,
默认两行展示:名称行附上简短版本号,下一行显示运行状态,不为版本另占第三行。本机使用当前应用版本,
同账号电脑使用设备目录最近上报的版本;离线时版本不代表已重新确认。分享来源或旧端未提供版本时不常驻「版本未知」,
@@ -600,9 +617,9 @@
- 任务归哪个组记在任务所在的电脑上。远程控制另一台电脑上的任务、以及手机,打开模型列表时问任务所在的电脑
(2026-10-11 用户确认,此前被控电脑上的任务一律按没归组处理);那台是旧版本问不到时按没归组的处理。挂着换电脑的意图时
下一条消息就不在原处了,不按组显示。组就建在被控电脑上时,组那一项是被控电脑自己那一栏里的这个供应商;
- - 设置页里组那一项行内写「供应商组 · {N} 台电脑」,详情只读列出组内电脑与状态(问组所在电脑,每 15 秒重读),
- 说明组设置要到组所在电脑上改。
- 状态是组所在电脑看到的;其中「我的其他电脑」组所在电脑看着能用、这台电脑却连不上时(换电脑时由这台直连过去,§4),
+ - 设置页里组那一项行内写「供应商组 · {N} 台电脑」,详情列出组内电脑与状态(问组所在电脑,每 15 秒重读),
+ 并提供「远程与分享」入口进入同账号管理(见下方「同账号任意电脑管理」)。
+ 状态是组所在电脑看到的;其中同账号电脑或分享来的电脑,组所在电脑看着能用、这台电脑却连不上时(换电脑时由这台直连过去,§4),
状态写「从这台电脑连不上」、圆点不显示可用,运行数照列(2026-10-11);这台读那台的目录每次最多等 3 秒,到点还没结果时
照组所在电脑的状态显示,不拖住整个组的状态。实现见
`apps/desktop/src/main/provider-group/ipc.ts` 的 `markMembersUnreachableHere`。
@@ -622,7 +639,8 @@
`provider-group:remote` 与目录里的组摘要;分享的人经组所在电脑中转(P2b)新增 `relay`、`guestRelay` 与 `forget`;
分享的人的「需要换一台」(P2c):任务所在电脑打开任务时声明支持(可选字段 `acceptsGroupSwitch`),组所在电脑只对
声明了的电脑在事件流里发出凭证状态(`providerGroupSwitch`),重新打开时带回(`groupSwitchToken`)。手机与远程控制问任务所在的电脑
- 「这个任务归哪个组」用同一通道的只读动作 `session-group`(§10)。其余沿用现有协议,不改服务端。兼容做法见 §14,登记见
+ 「这个任务归哪个组」用同一通道的只读动作 `session-group`(§10)。同账号任意电脑管理组与分享用同一通道的
+ `manage-group` / `manage-share`(§10)。其余沿用现有协议,不改服务端。兼容做法见 §14,登记见
`docs/dev-rules/protocol-compatibility.md`「供应商组」。
- [跨电脑复制任务](task-device-migration.md) 与已建任务换 Agent 所在电脑:§6.1 的自动换电脑与手动「换一台继续」
都复用现有交接,不新增交接机制。
diff --git a/docs/product-rules/provider-sharing.md b/docs/product-rules/provider-sharing.md
index 9be451b843..3a71e83bf7 100644
--- a/docs/product-rules/provider-sharing.md
+++ b/docs/product-rules/provider-sharing.md
@@ -89,6 +89,16 @@
的昵称和头像(见 §6)、申请的供应商与同一个配对码,选择「同意分享」或「拒绝」。
分享的是 Claude 订阅登录时,弹窗另写一句:受邀者使用时,Agent 能看到分享者登录 Claude 用的邮箱
(Claude Code 自己会把它交给模型,Cindy 目前挡不住;2026-10-10 裁决先告知分享者)。
+ - **弹窗跟着生成链接的电脑**(2026-10-14 用户裁决):同账号另一台电脑可以从「远程与分享」为供应商组生成链接
+ ([供应商组](provider-groups.md) §10 同账号管理)。这时审批弹窗与系统通知出现在**生成链接的那台电脑**上,
+ 供应商所在电脑与其他电脑都不弹,只在管理页「待处理」和入口提示点里显示;同意、拒绝转交供应商所在电脑执行。
+ 理由:链接只能用一次、5 分钟内有效,申请基本在生成后几分钟内到达,那时人就在生成链接的电脑前、能当面核对配对码;
+ 不在每台电脑上都弹,也不弹在可能无人值守的建组电脑上。
+ - 判定窗口为生成链接后 7 分钟(5 分钟有效期加拉取余量),两台电脑用同一时长,**按具体链接区分**:
+ 窗口内供应商所在电脑只对这条链接的申请静默,生成链接的电脑只弹这条链接的申请。后来在本机或第三台电脑
+ 生成的链接各自归属,不清除或接管其它链接的窗口;窗口过后才发现的申请照旧由供应商所在电脑弹。
+ 窗口按当前账号保存,完整应用重启后恢复。错过弹窗(生成链接的电脑已关闭等)时,在任意一台电脑的
+ 「远程与分享」页都能处理。精确关联需要服务端和两台电脑支持链接标识;旧服务端仍可本机生成,跨电脑生成提示更新。
5. **建立**:同意后分享立即生效,受邀者收到通知,模型列表里出现该供应商。
### 4.2 链接与申请的状态
@@ -105,8 +115,8 @@
- **一个链接只能用一次**:只有第一个提交的申请有效;同意、拒绝、撤回、过期都会让链接作废,
不会放回去再用。
- 5 分钟只限制「打开链接到发送申请」;申请发出后等待分享者处理,24 小时内有效。
-- 分享者不在线时,申请由服务端暂存,分享者那台电脑上线后再弹出;受邀者看到「已发送申请,等待
- 对方同意」,可以撤回。
+- 分享者不在线时,申请由服务端暂存,分享者那台电脑上线后再弹出(链接由同账号另一台电脑生成时按 §4.1 第 4 步);
+ 受邀者看到「已发送申请,等待对方同意」,可以撤回。
- 分享者打开自己的链接:提示「这是你自己的供应商,你的其他电脑可以直接使用」,不进入申请流程。
- 同一受邀者已拥有该供应商的分享时再次申请:提示已在使用,不重复建立。
@@ -266,6 +276,10 @@ Desktop「设置 → 模型供应商」的左栏(2026-10-08 用户裁决):
有待审批申请时按钮右上角带提示点,Tip 与无障碍名称写明有几个申请待处理。入口始终可点:供应商组不依赖
「允许被远程调用」;分享未开启时由管理页说明需先开启哪一级(§3)。
+同账号另一台电脑上的供应商组,在设置页左栏组那一项的详情里有同一个入口,进入同一页管理那台电脑上的组与分享
+([供应商组](provider-groups.md) §10)。这个入口的提示点只数这台电脑生成的链接带来、由这台电脑弹窗的申请(§4.1 第 4 步);
+那台电脑上的全部待处理申请在页面「待处理」里。
+
### 7.2 管理页内容
管理页按供应商划分,标题为「分享 {供应商}」,从设置页进入、可返回:
diff --git a/docs/provider-sharing-contract.md b/docs/provider-sharing-contract.md
index 25db55e7e6..d2d48eb94d 100644
--- a/docs/provider-sharing-contract.md
+++ b/docs/provider-sharing-contract.md
@@ -52,7 +52,7 @@ export function parseProviderShareScope(value: unknown, withSource?: boolean): P
| 方法 | 请求体 | 响应 |
|---|---|---|
| `GET /` | — | `{ shares: OwnerShare[] }`(本账号、本设备的 active 分享) |
-| `POST /links` | `{ providerId, providerLabel, deviceName, identityCard }` | `{ shareId, invitation, expiresAt }` |
+| `POST /links` | `{ providerId, providerLabel, deviceName, identityCard }` | `{ shareId, invitation, linkId, expiresAt }` |
| `POST /requests/:requestId/approve` | `{}` | `{ shareId, memberId }` |
| `POST /requests/:requestId/reject` | `{}` | `{ requestId, status: 'rejected' }` |
| `POST /members/:memberId/pause` | `{}` | `{ memberId, status: 'paused' }` |
@@ -64,10 +64,18 @@ interface Person { displayName: string; avatarUrl: string | null; region: 'cn' |
interface OwnerShare {
shareId: string; providerId: string; providerLabel: string; hostDeviceId: string; createdAt: string;
members: Array<Person & { memberId: string; status: 'active' | 'paused'; joinedAt: string }>;
- requests: Array<Person & { requestId: string; pairingCode: string; createdAt: string; expiresAt: string }>;
+ requests: Array<Person & { requestId: string; linkId: string; pairingCode: string; createdAt: string; expiresAt: string }>;
}
```
+`linkId` 是一次性随机邀请口令的 SHA-256 小写十六进制摘要,只标识具体链接,不暴露口令,不能用于加入分享。
+服务端从 `POST /links` 返回它,并附在 owner 列表的每条待处理申请上。同一供应商的多个链接复用 shareId,
+审批弹窗归属必须按 linkId 区分,不能仅按 shareId、host 或 provider 匹配。
+
+这是 additive 字段:旧客户端忽略;新客户端读取及本机生成链接接受缺字段的旧服务器。跨电脑生成需要合法 linkId,
+缺失时提示更新、不向用户返回或登记可复制链接,不降级成按供应商监听。先将服务端更新到该区域所有副本,再发布
+客户端;完整去重需要生成端和供应商所在电脑同时支持。只返回已有 linkDigest,无 migration、鉴权或环境变量变化。
+
- `POST /links`:同一(分享者、设备、`providerId`)已有 active 分享则复用,否则新建;同时用名片刷新分享者快照与 `providerLabel`、`deviceName`。`identityCard.purpose = 'share-link'`,`nonce = sha256hex(hostDeviceId + ':' + providerId)`。
- 批准:申请必须 `pending` 且未过期;成员按(分享、guestKey)幂等:已有 `removed / left` 行时恢复为 `active`(新 memberId 不必变),链接置 `consumed`。
- 拒绝、撤回、过期:链接置为对应终态,不可再用。
diff --git a/packages/device-link/src/__tests__/providerShare.test.ts b/packages/device-link/src/__tests__/providerShare.test.ts
index 273e8b7df4..94919e16a1 100644
--- a/packages/device-link/src/__tests__/providerShare.test.ts
+++ b/packages/device-link/src/__tests__/providerShare.test.ts
@@ -114,6 +114,30 @@ describe('provider share api', () => {
await api({ requestId: 'r1', status: 'pending', pairingCode: '0042', expiresAt: new Date().toISOString() }, calls).sendRequest(TOKEN, 'card');
expect(calls[0]).toEqual({ path: '/api/device-link/provider-shares/requests', body: { invitation: TOKEN, identityCard: 'card' } });
});
+
+ it.each([undefined, 'a'.repeat(64)])('accepts old and new link responses and preserves linkId %s', async (linkId) => {
+ const expiresAt = new Date().toISOString();
+ const result = await api({ shareId: 's1', invitation: TOKEN, expiresAt, linkId }).createLink({
+ providerId: 'anthropic', providerLabel: 'Anthropic', deviceName: 'Computer', identityCard: 'card',
+ });
+ expect(result.linkId).toBe(linkId);
+ const request = { requestId: 'r1', linkId, displayName: 'Guest', avatarUrl: null, region: 'global',
+ pairingCode: '0042', createdAt: expiresAt, expiresAt };
+ const shares = await api({ shares: [{ shareId: 's1', providerId: 'anthropic', providerLabel: 'Anthropic',
+ hostDeviceId: 'desktop', createdAt: expiresAt, members: [], requests: [request] }] }).listOwned();
+ expect(shares[0].requests[0].linkId).toBe(linkId);
+ });
+
+ it.each(['invalid', 'A'.repeat(64), 'a'.repeat(63), null])('rejects malformed linkId %s on links and owner requests', async (linkId) => {
+ const expiresAt = new Date().toISOString();
+ await expect(api({ shareId: 's1', invitation: TOKEN, expiresAt, linkId }).createLink({
+ providerId: 'anthropic', providerLabel: 'Anthropic', deviceName: 'Computer', identityCard: 'card',
+ })).rejects.toThrow('Invalid provider share link id');
+ await expect(api({ shares: [{ shareId: 's1', providerId: 'anthropic', providerLabel: 'Anthropic',
+ hostDeviceId: 'desktop', createdAt: expiresAt, members: [], requests: [{ requestId: 'r1', linkId,
+ displayName: 'Guest', avatarUrl: null, region: 'global', pairingCode: '0042', createdAt: expiresAt, expiresAt }] }] })
+ .listOwned()).rejects.toThrow('Invalid provider share link id');
+ });
});
describe('provider share received catalogs', () => {
diff --git a/packages/device-link/src/providerShareApi.ts b/packages/device-link/src/providerShareApi.ts
index 5ff3946064..e8849164f3 100644
--- a/packages/device-link/src/providerShareApi.ts
+++ b/packages/device-link/src/providerShareApi.ts
@@ -22,6 +22,8 @@ export interface ProviderShareMember extends ProviderSharePerson {
export interface ProviderShareRequestItem extends ProviderSharePerson {
requestId: string;
+ /** SHA-256 of this request's invitation; absent on older servers. Not an invitation or credential. */
+ linkId?: string;
pairingCode: string;
createdAt: string;
expiresAt: string;
@@ -139,6 +141,14 @@ export function isProviderShareInvitation(value: unknown): value is string {
return typeof value === 'string' && INVITATION.test(value);
}
+function linkId(value: unknown): { linkId?: string } {
+ if (value === undefined) return {};
+ if (typeof value !== 'string' || !/^[a-f0-9]{64}$/.test(value)) {
+ throw new Error('Invalid provider share link id');
+ }
+ return { linkId: value };
+}
+
function parseOwned(value: unknown): ProviderShareOwned {
const item = row(value);
return {
@@ -161,6 +171,7 @@ function parseOwned(value: unknown): ProviderShareOwned {
return {
...person(request),
requestId: providerShareIdentifier(request.requestId),
+ ...linkId(request.linkId),
pairingCode: pairing(request.pairingCode),
createdAt: timestamp(request.createdAt),
expiresAt: timestamp(request.expiresAt),
@@ -236,7 +247,7 @@ export function createProviderShareApi(options: ProviderShareApiOptions) {
identityCard: text(input.identityCard, 8192),
});
if (!isProviderShareInvitation(value.invitation)) throw new Error('Invalid provider share invitation');
- return { shareId: providerShareIdentifier(value.shareId), invitation: value.invitation, expiresAt: timestamp(value.expiresAt) };
+ return { shareId: providerShareIdentifier(value.shareId), invitation: value.invitation, expiresAt: timestamp(value.expiresAt), ...linkId(value.linkId) };
},
async approve(requestId: string) {
const value = await request(`/requests${segment(requestId)}/approve`, 'POST', {});
diff --git a/packages/maker-core/src/agents/pi/__tests__/cindySubagentRunner.test.ts b/packages/maker-core/src/agents/pi/__tests__/cindySubagentRunner.test.ts
index b3eaba1273..58a4bd6e54 100644
--- a/packages/maker-core/src/agents/pi/__tests__/cindySubagentRunner.test.ts
+++ b/packages/maker-core/src/agents/pi/__tests__/cindySubagentRunner.test.ts
@@ -1669,7 +1669,7 @@ describe('Cindy durable PI Subagent runner', () => {
* exercises it in full.
*/
it.skipIf(process.platform === 'win32')('bounds control dedupe and abandoned receipts without replaying the legacy mailbox', async () => {
- const fixture = await makeFixture({ hang: true });
+ const fixture = await makeFixture({ hang: true, timeoutMs: CONTROL_BACKLOG_TEST_TIMEOUT_MS });
const running = await waitFor(async () => {
const [run] = await listPiSubagentRuns(fixture.root);
return run?.state === 'running' ? run : null;