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): 支持受邀者直连执行电脑与短期授权

yanf03a2065b11d
diff --git a/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts b/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts
index 357bd92413..be3541d9fa 100644
--- a/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts
+++ b/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts
@@ -1548,6 +1548,62 @@ describe('getter / IPC', () => {
expect(getClientEndpoint('websiteUrl')).toBe('https://site.example.com');
});
+ // unit: partial local-server tests must preserve real SSO realm separation;
+ // full-local startup previously pinned both realms to one authentication server.
+ it('开发版只覆盖回环设备互联地址,两个区域的认证与模型端点保持独立', () => {
+ const cn = { ...TEST_CLIENT_ENDPOINTS, authApiBaseUrl: 'https://auth.cn.example.com' };
+ const global = { ...TEST_CLIENT_ENDPOINTS, authApiBaseUrl: 'https://auth.global.example.com' };
+ resetClientEndpointsForTest(global, { buildRegion: 'global', realmEndpoints: { cn, global } });
+ vi.stubEnv('XDT_DEVICE_LINK_CN_LOCAL_URL', 'http://127.0.0.1:33355');
+ vi.stubEnv('XDT_DEVICE_LINK_GLOBAL_LOCAL_URL', 'http://127.0.0.1:33356');
+ try {
+ for (const region of ['cn', 'global'] as const) {
+ activateClientEndpointRealm(region);
+ const local = region === 'cn' ? 'http://127.0.0.1:33355' : 'http://127.0.0.1:33356';
+ expect(getClientEndpoint('deviceLinkApiBaseUrl')).toBe(local);
+ expect(getClientEndpointForRealm(region, 'deviceLinkApiBaseUrl')).toBe(local);
+ const expected = region === 'cn' ? cn : global;
+ expect(getClientEndpoint('authApiBaseUrl')).toBe(expected.authApiBaseUrl);
+ expect(getClientEndpointForRealm(region, 'authApiBaseUrl')).toBe(expected.authApiBaseUrl);
+ expect(getClientEndpoint('modelAccessApiBaseUrl')).toBe(expected.modelAccessApiBaseUrl);
+ }
+ Object.defineProperty(app, 'isPackaged', { configurable: true, value: true });
+ expect(getClientEndpoint('deviceLinkApiBaseUrl')).toBe(global.deviceLinkApiBaseUrl);
+ expect(getClientEndpointForRealm('cn', 'deviceLinkApiBaseUrl')).toBe(cn.deviceLinkApiBaseUrl);
+ } finally {
+ Object.defineProperty(app, 'isPackaged', { configurable: true, value: false });
+ vi.unstubAllEnvs();
+ }
+ });
+
+ it.each(['http://192.0.2.1:33355', 'http://user:[email protected]:33355', 'file:///tmp/test', 'http://127.0.0.1:33355/other'])('拒绝开发版设备互联覆盖的非回环或含凭据/路径输入 %s', (value) => {
+ resetClientEndpointsForTest(TEST_CLIENT_ENDPOINTS);
+ vi.stubEnv('XDT_DEVICE_LINK_CN_LOCAL_URL', value);
+ vi.stubEnv('XDT_DEVICE_LINK_GLOBAL_LOCAL_URL', value);
+ try {
+ expect(() => getClientEndpoint('deviceLinkApiBaseUrl')).toThrow(/loopback/);
+ expect(getClientEndpoint('authApiBaseUrl')).toBe(TEST_CLIENT_ENDPOINTS.authApiBaseUrl);
+ } finally {
+ vi.unstubAllEnvs();
+ }
+ });
+
+ it('仅设置旧 CN 测试地址时不会把 Global 账号的请求发往 CN 服务', () => {
+ const cn = { ...TEST_CLIENT_ENDPOINTS, deviceLinkApiBaseUrl: 'https://device.cn.example.com' };
+ const global = { ...TEST_CLIENT_ENDPOINTS, deviceLinkApiBaseUrl: 'https://device.global.example.com' };
+ resetClientEndpointsForTest(global, { buildRegion: 'global', realmEndpoints: { cn, global } });
+ vi.stubEnv('XDT_DEVICE_LINK_LOCAL_URL', 'http://127.0.0.1:33355');
+ try {
+ activateClientEndpointRealm('global');
+ expect(getClientEndpoint('deviceLinkApiBaseUrl')).toBe(global.deviceLinkApiBaseUrl);
+ expect(getClientEndpointForRealm('global', 'deviceLinkApiBaseUrl')).toBe(global.deviceLinkApiBaseUrl);
+ activateClientEndpointRealm('cn');
+ expect(getClientEndpoint('deviceLinkApiBaseUrl')).toBe('http://127.0.0.1:33355');
+ } finally {
+ vi.unstubAllEnvs();
+ }
+ });
+
it('组织会话切换所有 token 消费端点,但安装身份与更新链保持构建区域', () => {
const cn = {
...TEST_CLIENT_ENDPOINTS,
diff --git a/apps/desktop/src/main/__tests__/fork.test.ts b/apps/desktop/src/main/__tests__/fork.test.ts
index 4fa4ebf857..3ba6a49c35 100644
--- a/apps/desktop/src/main/__tests__/fork.test.ts
+++ b/apps/desktop/src/main/__tests__/fork.test.ts
@@ -12,6 +12,7 @@
*/
import { promises as fs } from 'node:fs';
+import { randomUUID } from 'node:crypto';
import os from 'node:os';
import path from 'node:path';
import Database from 'better-sqlite3';
@@ -19,6 +20,9 @@ import { drizzle } from 'drizzle-orm/better-sqlite3';
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { CodexResumePreparationBlockedError } from '@cindy/maker-core';
+import { providerShareHostPeer } from '@cindy/device-link';
+import { createRemoteAgentHost } from '../remote-agent/host/runHost';
+import { RemoteAgentPoller, RemoteAgentRunClient } from '../remote-agent/controller/runClient';
import { CODEX_RESUME_NOT_READY_WIRE_MESSAGE } from '@cindy/maker-shared/agent-input-projection';
import { projectSessionContextWindow } from '../../shared/sessionContextWindow';
import { computeForkSourceMessagesDigest } from '../localDb/forkRecoverySnapshot.js';
@@ -74,7 +78,18 @@ vi.mock('../localDb/ipc/sessionCreatedBroadcast.js', () => ({
const forkSdkSessionMock = vi.fn();
const remoteInvokeMock = vi.fn();
-vi.mock('../device-link/index.js', () => ({ remoteBackgroundInvoke: (...args: unknown[]) => remoteInvokeMock(...args) }));
+vi.mock('../device-link/index.js', () => ({
+ remoteBackgroundInvoke: (...args: unknown[]) => remoteInvokeMock(...args),
+ openRemoteLink: async () => undefined,
+ getRemoteLinkCloseEpoch: () => 0,
+}));
+vi.mock('../device-link/providerShareCrossRegion.js', () => ({
+ isCrossRegionProviderShareTarget: () => false,
+ renewCrossRegionProviderShareLink: async () => undefined,
+}));
+vi.mock('../device-link/providerShareGuest.js', () => ({
+ parseProviderShareAgentDeviceId: (device: string) => device.startsWith('share:') ? device.slice(6) : null,
+}));
vi.mock('../maker-host/index.js', () => ({
getMaker: () => ({
forkSdkSession: forkSdkSessionMock,
@@ -1323,6 +1338,178 @@ describe('forkSessionAtMessage', () => {
expect(forkSdkSessionMock).not.toHaveBeenCalled();
});
+ // Direct-share regression: orchestration previously sent M's native ID to O.
+ // Existing remote fork cases use physical device IDs, not the persisted share alias.
+ // Unit: only M owns the native source; authorize both source and child before fork.
+ it.each(['ready', 'fork-failed', 'wrong-executor', 'wrong-child', 'member-denied'] as const)(
+ 'pins shared native fork to M and preserves the source authorization: %s', async mode => {
+ const owner = 'share:history-share';
+ const executor = providerShareHostPeer('history-share', 'executor-m');
+ const sourceGeneration = '11111111-1111-4111-8111-111111111111';
+ const childGeneration = '22222222-2222-4222-8222-222222222222';
+ selectQueue.push([makeSourceRow({ agentDeviceId: owner, sdkSessionId: 'native-on-m' })]);
+ selectQueue.push([makeMessageRow({ clientId: 'target-user', createdAt: 3000 })]);
+ selectQueue.push([makeMessageRow({ role: 'assistant', agentMeta: JSON.stringify({ uuid: 'old-anchor' }) })]);
+ selectQueue.push([makeSourceRow({ agentDeviceId: owner, sdkSessionId: 'native-child-on-m' })]);
+ const authorizedTasks = new Set<string>();
+ remoteInvokeMock.mockImplementation(async (device, _channel, [request]) => {
+ if (device === owner && request.op === 'direct-locate') {
+ return mode === 'member-denied'
+ ? { ok: false, error: { code: 'REMOTE_AGENT_UNAVAILABLE', message: 'member denied' } }
+ : { ok: true, result: { deviceId: 'executor-m' } };
+ }
+ if (device === owner && request.op === 'allocate') {
+ expect(request.preferredExecutorDeviceId).toBe('executor-m');
+ authorizedTasks.add(request.sessionId);
+ return { ok: true, result: { deviceId: mode === 'wrong-executor' || (mode === 'wrong-child' && request.sessionId !== 'src-session')
+ ? 'executor-other' : 'executor-m',
+ generation: request.sessionId === 'src-session' ? sourceGeneration : childGeneration } };
+ }
+ if (device === owner && request.op === 'direct-release') {
+ expect(request.sessionId).not.toBe('src-session');
+ expect(request.generation).toBe(childGeneration);
+ authorizedTasks.delete(request.sessionId);
+ return { ok: true, result: {} };
+ }
+ if (request.op === 'caps') return { ok: true, result: {
+ version: 1, agents: [{ kind: 'claude-code', available: true }], maxRuns: 16,
+ uploadChunkBytes: 1024, maxPayloadBytes: 2048, nativeFork: true, directGuestExecution: true,
+ } };
+ if (request.op === 'fork') {
+ if (device !== executor) return { ok: false, error: { code: 'REMOTE_AGENT_INVALID', message: 'O does not own this native source' } };
+ expect(authorizedTasks.has(request.sourceSessionId)).toBe(true);
+ expect(authorizedTasks.has(request.newSessionId)).toBe(true);
+ expect(request.sourceSdkSessionId).toBe('native-on-m');
+ return mode === 'fork-failed'
+ ? { ok: false, error: { code: 'REMOTE_AGENT_FORK_FAILED', message: 'native fork failed' } }
+ : { ok: true, result: { newSdkSessionId: 'native-child-on-m', uuidMap: [] } };
+ }
+ throw new Error(`unexpected history request ${device}/${request.op}`);
+ });
+ if (mode === 'ready') {
+ await forkSessionAtMessage('src-session', 'target-user');
+ const args = txCalls[0].args as { newSession: Record<string, unknown> };
+ expect(args.newSession).toMatchObject({ agentDeviceId: owner, sdkSessionId: 'native-child-on-m' });
+ expect(authorizedTasks.has(String(args.newSession.id))).toBe(true);
+ } else {
+ await expect(forkSessionAtMessage('src-session', 'target-user')).rejects.toThrow();
+ expect(txCalls).toHaveLength(0);
+ if (mode === 'fork-failed' || mode === 'wrong-child') expect([...authorizedTasks]).toEqual(['src-session']);
+ }
+ expect(forkSdkSessionMock).not.toHaveBeenCalled();
+ const forks = remoteInvokeMock.mock.calls.filter(([, , [request]]) => request.op === 'fork');
+ expect(forks).toHaveLength(mode === 'ready' || mode === 'fork-failed' ? 1 : 0);
+ expect(forks.every(([device]) => device === executor)).toBe(true);
+ expect(remoteInvokeMock.mock.calls.filter(([device]) => device === owner)
+ .some(([, , [request]]) => 'sourceSdkSessionId' in request)).toBe(false);
+ },
+ );
+
+ it.each(['legacy-null', 'REMOTE_AGENT_INVALID', 'REMOTE_AGENT_PEER_TOO_OLD', 'malformed'])(
+ 'falls back to O only for an explicit legacy history response: %s', async mode => {
+ const owner = 'share:legacy-share';
+ selectQueue.push([makeSourceRow({ agentDeviceId: owner })]);
+ selectQueue.push([makeMessageRow({ clientId: 'target-user', createdAt: 3000 })]);
+ selectQueue.push([makeMessageRow({ role: 'assistant', agentMeta: JSON.stringify({ uuid: 'old-anchor' }) })]);
+ selectQueue.push([makeSourceRow({ agentDeviceId: owner })]);
+ remoteInvokeMock.mockImplementation(async (device, _channel, [request]) => {
+ expect(device).toBe(owner);
+ if (request.op === 'direct-locate') return mode === 'legacy-null' || mode === 'malformed'
+ ? { ok: true, result: mode === 'legacy-null' ? null : {} }
+ // Desktop dispatch carries domain errors inside the IPC_ERROR message.
+ : { ok: false, error: { code: 'IPC_ERROR', message: `[${mode}] unsupported operation` } };
+ if (request.op === 'caps') return { ok: true, result: { version: 1, agents: [],
+ maxRuns: 16, uploadChunkBytes: 1024, maxPayloadBytes: 2048, nativeFork: true } };
+ expect(request.op).toBe('fork');
+ return { ok: true, result: { newSdkSessionId: 'legacy-child', uuidMap: [] } };
+ });
+ if (mode === 'malformed') {
+ await expect(forkSessionAtMessage('src-session', 'target-user')).rejects.toThrow('invalid shared task location');
+ expect(remoteInvokeMock).toHaveBeenCalledTimes(1);
+ expect(txCalls).toHaveLength(0);
+ } else {
+ await forkSessionAtMessage('src-session', 'target-user');
+ expect((txCalls[0].args as { newSession: Record<string, unknown> }).newSession)
+ .toMatchObject({ agentDeviceId: owner, sdkSessionId: 'legacy-child' });
+ }
+ },
+ );
+
+ // Same regression through both actual hosts and their guest-native ownership index.
+ // Only the native harness boundary is stubbed; O has never received this source.
+ it('forks M-owned native history through orchestration while O and another guest reject it', async () => {
+ const ownerRoute = 'share:history-share';
+ const target = providerShareHostPeer('history-share', 'executor-m');
+ const authorizedTasks = new Set(['src-session']);
+ const nativeFork = vi.fn(async () => ({ newSdkSessionId: 'native-child-on-m', uuidMap: new Map<string, string>() }));
+ // Shadow workspaces include 24 ancestor levels; keep the fixture below Windows MAX_PATH.
+ const fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-f-'));
+ tempDirs.push(fixtureRoot);
+ const createHost = (name: string) => createRemoteAgentHost({
+ isAgentAvailable: () => true,
+ startHosted: async input => {
+ let finish!: () => void;
+ const closed = new Promise<void>(resolve => { finish = resolve; });
+ return { id: 'native-source-on-m', agentKind: input.kind, model: input.options.model,
+ async send() {}, async steer() {}, async abort() {}, async close() { finish(); },
+ events: () => ({ async *[Symbol.asyncIterator]() { await closed; } }),
+ getUsageSnapshot: () => ({ tokenUsage: 0, contextTokens: 0, contextWindow: 0, costUsd: 0 }),
+ setInteractionResolver() {},
+ };
+ },
+ forkHosted: nativeFork,
+ controllerTrust: () => 'guest', isControllerAuthorized: () => true,
+ providerAccess: { resolve: async (_kind, _model, _provider, _controller, task) => authorizedTasks.has(task!) ? 'provider' : null,
+ isAllowed: (_provider, _controller, _model, task) => authorizedTasks.has(task!) },
+ bindGuestProviderRoute: async () => ({ providerId: 'provider', routeToken: 'fixture', modelIds: ['claude-sonnet-4-6'], release() {} }),
+ captureOwner: () => 'owner', isOwnerCurrent: () => true,
+ runsRoot: path.join(fixtureRoot, name),
+ });
+ const executor = createHost('m');
+ const owner = createHost('o');
+ const poller = new RemoteAgentPoller(async ([request]) => executor.handle('guest-a', request));
+ const client = new RemoteAgentRunClient(randomUUID(), poller, {
+ onEvent() {}, onState() {}, onWs() {}, onClosed() {}, onRequest: async () => ({ type: 'callback', value: undefined }),
+ }, randomUUID);
+ try {
+ await client.open('claude-code', { sessionId: 'src-session', virtualWorkspace: true,
+ options: { model: 'claude-sonnet-4-6' }, workspace: { workingDir: '/fixture', platform: 'linux', shell: 'sh' },
+ projectFiles: [], ancestorFiles: [], personal: { files: [] }, mcpServers: [],
+ });
+ await client.close('close', 'navigation');
+ selectQueue.push([makeSourceRow({ agentDeviceId: ownerRoute, sdkSessionId: 'native-source-on-m' })]);
+ selectQueue.push([makeMessageRow({ clientId: 'target-user', createdAt: 3000 })]);
+ selectQueue.push([makeMessageRow({ role: 'assistant', agentMeta: JSON.stringify({ uuid: 'old-anchor' }) })]);
+ selectQueue.push([makeSourceRow({ agentDeviceId: ownerRoute, sdkSessionId: 'native-child-on-m' })]);
+ remoteInvokeMock.mockImplementation(async (device, _channel, [request]) => {
+ if (device === ownerRoute && request.op === 'direct-locate') return { ok: true, result: { deviceId: 'executor-m' } };
+ if (device === ownerRoute && request.op === 'allocate') {
+ authorizedTasks.add(request.sessionId);
+ return { ok: true, result: { deviceId: 'executor-m', generation: randomUUID() } };
+ }
+ const host = device === target ? executor : owner;
+ const result = await host.handle('guest-a', JSON.parse(JSON.stringify(request)));
+ return { ok: true, result: request.op === 'caps' ? { ...result as object, directGuestExecution: true } : result };
+ });
+ await forkSessionAtMessage('src-session', 'target-user');
+ const request = remoteInvokeMock.mock.calls.find(([, , [request]]) => request.op === 'fork')![2][0];
+ expect(nativeFork).toHaveBeenCalledTimes(1);
+ expect((txCalls[0].args as { newSession: Record<string, unknown> }).newSession)
+ .toMatchObject({ agentDeviceId: ownerRoute, sdkSessionId: 'native-child-on-m' });
+ await expect(owner.handle('guest-a', request)).rejects.toThrow('REMOTE_AGENT_INVALID');
+ await expect(executor.handle('guest-b', request)).rejects.toThrow('REMOTE_AGENT_INVALID');
+ expect(nativeFork).toHaveBeenCalledTimes(1);
+ } finally {
+ await client.close('close', 'navigation');
+ // dispose() schedules file removal without awaiting it. Drain the real
+ // guest cleanup first so afterEach does not race its Windows rmdir calls.
+ await executor.purgeControllers(() => true);
+ await owner.purgeControllers(() => true);
+ await executor.dispose();
+ await owner.dispose();
+ }
+ });
+
// Review #6563: native history stays on the recorded device across switches.
// Cover remote->remote, local->remote and remote->local through orchestration.
it.each([
diff --git a/apps/desktop/src/main/__tests__/lifecycle.test.ts b/apps/desktop/src/main/__tests__/lifecycle.test.ts
index 9404d6051f..4809b61af1 100644
--- a/apps/desktop/src/main/__tests__/lifecycle.test.ts
+++ b/apps/desktop/src/main/__tests__/lifecycle.test.ts
@@ -656,7 +656,7 @@ describe('installQuitHandler render-process-gone', () => {
}
});
- it('resource usage renderer crash does NOT shut the app down', async () => {
+ it('recoverable auxiliary renderer crashes do NOT shut the app down', async () => {
resourceUsageWebContentsIds.add(44);
const { handler, app, restore } = await installAndGrabHandler();
try {
@@ -667,6 +667,19 @@ describe('installQuitHandler render-process-gone', () => {
expect.stringContaining('resource usage render-process-gone'),
);
expect(mocks.logger.error).not.toHaveBeenCalled();
+ // Unit regression for the real Windows direct-renderer crash: local
+ // cleanup ran, but the app-wide event still disposed DB/device-link.
+ // Other auxiliary tests never registered the transport factory's owner.
+ const { markCaptureWindowWebContents } = await import('../remote-desktop/captureWindowRegistry');
+ const capture = { id: 46, getType: () => 'window' };
+ markCaptureWindowWebContents(capture as unknown as Electron.WebContents);
+ handler(undefined, capture, { reason: 'crashed', exitCode: 5 });
+ await Promise.resolve();
+ expect(app.exit).not.toHaveBeenCalled();
+ expect(mocks.spawn).not.toHaveBeenCalled();
+ expect(mocks.logger.warn).toHaveBeenCalledWith(
+ expect.stringContaining('capture transport render-process-gone'),
+ );
} finally {
restore();
}
diff --git a/apps/desktop/src/main/cindy-media/__tests__/generatedImageDelivery.test.ts b/apps/desktop/src/main/cindy-media/__tests__/generatedImageDelivery.test.ts
index 9b504846d7..97fafc5366 100644
--- a/apps/desktop/src/main/cindy-media/__tests__/generatedImageDelivery.test.ts
+++ b/apps/desktop/src/main/cindy-media/__tests__/generatedImageDelivery.test.ts
@@ -10,6 +10,7 @@ import path from 'node:path';
import Database from 'better-sqlite3';
import { drizzle } from 'drizzle-orm/better-sqlite3';
import type { AgentEvent, GeneratedImageEventData } from '@cindy/maker-core';
+import { providerShareHostPeer } from '@cindy/device-link';
import type { DbClient } from '../../localDb/client/DbClient';
import * as schema from '../../localDb/schema';
import { clearCurrentDbClient, setCurrentDbClient } from '../../localDb/client/current';
@@ -21,7 +22,7 @@ import {
prepareGeneratedImageTransport,
readGeneratedImageEpoch,
} from '../generatedImageStorage';
-import { generatedImageId } from '../generatedImageJournal';
+import { generatedImageId, initialGeneratedImageRecord } from '../generatedImageJournal';
import { resolveSafe } from '../blobStore';
import * as ledger from '../ledger';
@@ -161,6 +162,304 @@ function result() {
}
describe('native image delivery', () => {
+ // Legacy journals used share:<id> exclusively for O. A later clear/direct assignment
+ // must not reinterpret that historical source, including release-only cleanup receipts.
+ it.each(['cleanup', 'recover', 'reconcile'] as const)(
+ 'keeps a legacy O alias on O after a later M assignment via %s',
+ async (entry) => {
+ raw.exec("UPDATE sessions SET agent_device_id = 'share:shared'");
+ await prepareTransport('remote:owner-task', event({ data: png.toString('base64') }));
+ const storage = captureGeneratedImageStorage();
+ if (entry === 'reconcile') {
+ raw.exec("UPDATE sessions SET status = 'deleted'");
+ const scope = 'cleanup:task:share:shared';
+ await storage.journal.updateCleanup(scope, () => ({
+ version: 1,
+ scope,
+ sessionId: 'task',
+ agentDeviceId: 'share:shared',
+ clearedAt: null,
+ deleted: true,
+ }));
+ } else {
+ await storage.journal.update('task:task', id, () => ({
+ ...initialGeneratedImageRecord('task:task', image),
+ agentDeviceId: 'share:shared',
+ clearedAt: null,
+ }));
+ if (entry === 'cleanup') raw.exec('UPDATE sessions SET cleared_at = 100');
+ }
+ const owner = providerShareHostPeer('shared', 'owner');
+ const member = providerShareHostPeer('shared', 'member');
+ let currentOwner = owner;
+ let releaseOffline = entry === 'recover';
+ const invoke = vi.fn(async (device: string, _channel: string, args: unknown[]) => {
+ const request = args[0] as Parameters<typeof handleGeneratedImageArtifacts>[1];
+ if (
+ releaseOffline &&
+ device === owner &&
+ request.op === 'images' &&
+ request.action === 'release'
+ )
+ throw new Error('owner offline');
+ return {
+ ok: true,
+ result:
+ request.op === 'images'
+ ? await handleGeneratedImageArtifacts(
+ device === owner ? 'owner-task' : 'empty-member-task',
+ request,
+ )
+ : { imageRecovery: true },
+ };
+ });
+ const host = createGeneratedImageDelivery({
+ invoke,
+ publish: vi.fn(),
+ authorizeSharedTaskHistory: async () => member,
+ resolveSharedOwnerTarget: async () => currentOwner,
+ });
+ if (entry === 'reconcile') await host.reconcile();
+ else await host[entry]('task');
+ if (entry === 'recover') {
+ expect((await storage.journal.read('task:task', id))?.sourceReleased).not.toBe(true);
+ currentOwner = providerShareHostPeer('shared', 'replacement-owner');
+ invoke.mockClear();
+ await host.recover('task', id);
+ expect(invoke).not.toHaveBeenCalled();
+ expect((await storage.journal.read('task:task', id))?.sourceReleased).not.toBe(true);
+ currentOwner = owner;
+ releaseOffline = false;
+ await host.recover('task', id);
+ }
+ expect((await storage.journal.read('remote:owner-task', id))?.state).toBe('released');
+ const knownRequests = invoke.mock.calls.filter(
+ ([, , args]) => (args[0] as { imageId?: string }).imageId === id,
+ );
+ expect(knownRequests.length).toBeGreaterThan(0);
+ expect(knownRequests.every(([device]) => device === owner)).toBe(true);
+ if (entry !== 'reconcile')
+ expect(await storage.journal.read('task:task', id)).toMatchObject({
+ agentDeviceId: owner,
+ legacyOwnerRoute: 'share:shared',
+ sourceReleased: true,
+ });
+ },
+ );
+
+ it.each([false, true])(
+ 'locates an early M event before creating its journal (initially offline=%s)',
+ async (offline) => {
+ raw.exec("UPDATE sessions SET agent_device_id = 'share:shared'");
+ const transported = await prepareTransport(
+ 'remote:host-task',
+ event({ data: png.toString('base64') }),
+ );
+ const target = providerShareHostPeer('shared', 'member');
+ const original = controller();
+ let firstAuthorization = true;
+ const host = createGeneratedImageDelivery({
+ invoke: original.invoke,
+ publish: original.publish,
+ liveSharedTaskTarget: () => null,
+ authorizeSharedTaskHistory: async () => {
+ if (firstAuthorization)
+ expect(await captureGeneratedImageStorage().journal.read('task:task', id)).toBeNull();
+ if (offline) throw new Error('owner offline');
+ firstAuthorization = false;
+ return target;
+ },
+ });
+ if (offline) {
+ await expect(host.deliver('task', transported)).rejects.toThrow('owner offline');
+ expect(await captureGeneratedImageStorage().journal.read('task:task', id)).toBeNull();
+ expect(
+ (await captureGeneratedImageStorage().journal.read('remote:host-task', id))?.state,
+ ).not.toBe('released');
+ offline = false;
+ }
+ await host.deliver('task', transported);
+ expect(await captureGeneratedImageStorage().journal.read('task:task', id)).toMatchObject({
+ agentDeviceId: target,
+ sourceReleased: true,
+ });
+ expect(original.invoke.mock.calls.every(([device]) => device === target)).toBe(true);
+ },
+ );
+
+ // Direct sharing regression (unit): real delivery/journal/blob entry, with transport and
+ // task authorization at the boundary. Existing restart tests use one machine and cannot
+ // detect O's successful empty release ACK for an artifact that exists only on M.
+ it.each([true, false])(
+ 'keeps the direct image source across an O outage and restart (inline=%s)',
+ async (inline) => {
+ raw.exec("UPDATE sessions SET agent_device_id = 'share:shared'");
+ const target = providerShareHostPeer('shared', 'member');
+ const transported = await prepareTransport(
+ 'remote:member-task',
+ event({ data: png.toString('base64') }),
+ );
+ let online = false;
+ let live = true;
+ let leaseClock = Date.now();
+ let authorizedUntil = 0;
+ const authorizeSharedTaskHistory = vi.fn(async (sessionId: string, ownerRoute: string) => {
+ expect([sessionId, ownerRoute]).toEqual(['task', 'share:shared']);
+ if (!online) throw new Error('owner offline');
+ authorizedUntil = leaseClock + 60_000;
+ return target;
+ });
+ const invoke = vi.fn(async (device: string, _channel: string, args: unknown[]) => {
+ const request = args[0] as Parameters<typeof handleGeneratedImageArtifacts>[1];
+ // O legitimately acknowledges release of its empty journal; it must never be selected.
+ if (device === 'share:shared')
+ return {
+ ok: true,
+ result:
+ request.op === 'images'
+ ? await handleGeneratedImageArtifacts('empty-owner-task', request)
+ : { imageRecovery: true },
+ };
+ expect(device).toBe(target);
+ expect(authorizedUntil).toBeGreaterThan(leaseClock);
+ return {
+ ok: true,
+ result:
+ request.op === 'images'
+ ? await handleGeneratedImageArtifacts('member-task', request)
+ : { imageRecovery: true },
+ };
+ });
+ const controller = () =>
+ createGeneratedImageDelivery({
+ invoke,
+ publish: vi.fn(),
+ authorizeSharedTaskHistory,
+ liveSharedTaskTarget: () => (live ? target : null),
+ });
+ await controller().deliver(
+ 'task',
+ inline ? transported : event({ pathOrigin: 'remote-agent' }),
+ );
+ expect(await captureGeneratedImageStorage().journal.read('task:task', id)).toMatchObject({
+ agentDeviceId: target,
+ state: inline ? 'stored' : 'failed',
+ });
+ expect(
+ (await captureGeneratedImageStorage().journal.read('task:task', id))?.sourceReleased,
+ ).not.toBe(true);
+ expect(
+ (await captureGeneratedImageStorage().journal.read('remote:member-task', id))?.state,
+ ).not.toBe('released');
+ expect(invoke).not.toHaveBeenCalled();
+ live = false;
+ // Advance only the authorization clock: filesystem locks use actual file mtimes.
+ leaseClock += 31 * 60_000;
+ await controller().recover('task', id);
+ expect(
+ (await captureGeneratedImageStorage().journal.read('task:task', id))?.sourceReleased,
+ ).not.toBe(true);
+ online = true;
+ const unknown = { ...image, blockId: 'missing-after-restart' };
+ await prepareTransport(
+ 'remote:member-task',
+ event({ ...unknown, data: png.toString('base64') }),
+ );
+ await controller().recover('task');
+ expect(
+ (await captureGeneratedImageStorage().journal.read('task:task', id))?.sourceReleased,
+ ).toBe(true);
+ expect(
+ (await captureGeneratedImageStorage().journal.read('remote:member-task', id))?.state,
+ ).toBe('released');
+ expect(
+ await captureGeneratedImageStorage().journal.read('task:task', generatedImageId(unknown)),
+ ).toMatchObject({
+ agentDeviceId: target,
+ state: 'stored',
+ sourceReleased: true,
+ });
+ expect(invoke.mock.calls.every(([device]) => device === target)).toBe(true);
+ expect(
+ invoke.mock.calls.map(([, , args]) => (args[0] as { action?: string }).action),
+ ).toEqual(expect.arrayContaining(['list', 'read', 'release']));
+ expect(authorizeSharedTaskHistory).toHaveBeenCalled();
+ },
+ );
+
+ it('retains a direct release receipt when historical authorization names a different source', async () => {
+ raw.exec("UPDATE sessions SET agent_device_id = 'share:shared'");
+ const target = providerShareHostPeer('shared', 'member');
+ const invoke = vi.fn(async () => ({ ok: true, result: { ok: true } }));
+ const controller = () =>
+ createGeneratedImageDelivery({
+ invoke,
+ publish: vi.fn(),
+ liveSharedTaskTarget: () => target,
+ authorizeSharedTaskHistory: async () => providerShareHostPeer('shared', 'different-member'),
+ });
+ await controller().deliver('task', event({ data: png.toString('base64') }));
+ await controller().recover('task', id);
+ expect(
+ (await captureGeneratedImageStorage().journal.read('task:task', id))?.sourceReleased,
+ ).not.toBe(true);
+ await expect(controller().recover('task')).rejects.toThrow('REMOTE_SOURCE_REQUIRED');
+ expect(invoke).not.toHaveBeenCalled();
+ });
+
+ it('continues to recover legacy shared images through their authorized owner route', async () => {
+ raw.exec("UPDATE sessions SET agent_device_id = 'share:shared'");
+ await prepareTransport('remote:host-task', event({ data: png.toString('base64') }));
+ const original = controller();
+ const owner = providerShareHostPeer('shared', 'owner');
+ const authorizeSharedTaskHistory = vi.fn(async () => owner);
+ const legacy = createGeneratedImageDelivery({
+ invoke: original.invoke,
+ publish: original.publish,
+ authorizeSharedTaskHistory,
+ liveSharedTaskTarget: () => null,
+ });
+ await legacy.recover('task');
+ expect(result().ok).toBe(true);
+ expect(authorizeSharedTaskHistory).toHaveBeenCalledWith('task', 'share:shared');
+ expect(original.invoke.mock.calls.every(([device]) => device === owner)).toBe(true);
+ expect(
+ (await captureGeneratedImageStorage().journal.read('task:task', id))?.agentDeviceId,
+ ).toBe(owner);
+ expect(
+ (await captureGeneratedImageStorage().journal.read('task:task', id))?.sourceReleased,
+ ).toBe(true);
+ });
+
+ it('reconciles a direct cleanup receipt after an offline deletion without contacting O for images', async () => {
+ raw.exec("UPDATE sessions SET agent_device_id = 'share:shared', status = 'deleted'");
+ await prepareTransport('remote:host-task', event({ data: png.toString('base64') }));
+ const target = providerShareHostPeer('shared', 'member');
+ let online = false;
+ const original = controller();
+ const authorizeSharedTaskHistory = vi.fn(async (sessionId: string, ownerRoute: string) => {
+ expect([sessionId, ownerRoute]).toEqual(['task', 'share:shared']);
+ if (!online) throw new Error('owner offline');
+ return target;
+ });
+ const deps = { invoke: original.invoke, publish: original.publish, authorizeSharedTaskHistory };
+ await createGeneratedImageDelivery({ ...deps, liveSharedTaskTarget: () => target }).cleanup(
+ 'task',
+ );
+ expect(await captureGeneratedImageStorage().journal.listCleanups()).toEqual([
+ expect.objectContaining({ agentDeviceId: target, deleted: true }),
+ ]);
+ expect(original.invoke).not.toHaveBeenCalled();
+ online = true;
+ await createGeneratedImageDelivery(deps).reconcile();
+ expect(original.invoke.mock.calls.every(([device]) => device === target)).toBe(true);
+ expect((await captureGeneratedImageStorage().journal.read('remote:host-task', id))?.state).toBe(
+ 'released',
+ );
+ expect(original.publish).not.toHaveBeenCalled();
+ expect(raw.prepare('SELECT * FROM messages').all()).toHaveLength(0);
+ });
+
it('delivers bytes ahead of an unrelated remote path, persists one result and one attachment on duplicate completion', async () => {
const host = controller();
await Promise.all([
diff --git a/apps/desktop/src/main/cindy-media/generatedImageDelivery.ts b/apps/desktop/src/main/cindy-media/generatedImageDelivery.ts
index 3a84caed64..aaccd7bbe9 100644
--- a/apps/desktop/src/main/cindy-media/generatedImageDelivery.ts
+++ b/apps/desktop/src/main/cindy-media/generatedImageDelivery.ts
@@ -1,7 +1,11 @@
import { createHash } from 'node:crypto';
import { and, eq, isNotNull, or } from 'drizzle-orm';
import type { AgentEvent, GeneratedImageEventData } from '@cindy/maker-core';
-import { REMOTE_AGENT_CHANNEL, REMOTE_AGENT_READ_MAX_BYTES } from '@cindy/device-link';
+import {
+ parseProviderSharePeer,
+ REMOTE_AGENT_CHANNEL,
+ REMOTE_AGENT_READ_MAX_BYTES,
+} from '@cindy/device-link';
import { sessions, messages } from '../localDb/schema';
import { broadcastMessageRow, createMessage } from '../localDb/ipc/messages';
import { captureDataOwnerBroadcastScope } from '../device-link/broadcast-tap';
@@ -14,6 +18,7 @@ import {
generatedImageId,
initialGeneratedImageRecord,
type GeneratedImageCleanup,
+ type GeneratedImageRecord,
} from './generatedImageJournal';
import { commitChatImageUrls } from './chatAttachments';
import { MAX_GENERATED_IMAGE_BYTES } from './generatedMedia';
@@ -28,6 +33,9 @@ const taskFields = {
workingDir: sessions.workingDir,
};
+/** Additive journal metadata: old share aliases meant O, never a dynamic executor. */
+type LegacyImageOrigin = { legacyOwnerRoute?: string };
+
export interface GeneratedImageDeliveryDeps {
invoke(
deviceId: string,
@@ -36,6 +44,12 @@ export interface GeneratedImageDeliveryDeps {
options?: { preSend?: () => void },
): Promise<{ ok: boolean; result?: unknown }>;
publish(sessionId: string, event: AgentEvent, persistId: string, resolvedContent?: string): void;
+ /** Live routing is evidence of the image's source, not authorization for later access. */
+ liveSharedTaskTarget?(sessionId: string, ownerRoute: string): string | null;
+ /** Locate the durable task and acquire a fresh, task-scoped executor lease. */
+ authorizeSharedTaskHistory?(sessionId: string, ownerRoute: string): Promise<string>;
+ /** Resolve the share's original O identity; O enforces its existing guest/task access. */
+ resolveSharedOwnerTarget?(ownerRoute: string): Promise<string>;
readSource?(
sessionId: string,
image: GeneratedImageEventData,
@@ -47,6 +61,82 @@ export interface GeneratedImageDeliveryDeps {
export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
const inFlight = new Map<string, Promise<void>>();
+ async function authorizeSource(sessionId: string, source: string, assertCurrent: () => void) {
+ assertCurrent();
+ const peer = parseProviderSharePeer(source);
+ const ownerRoute = peer ? `share:${peer.shareId}` : source.startsWith('share:') ? source : null;
+ if (!ownerRoute) return source;
+ if (!deps.authorizeSharedTaskHistory) throw new Error('REMOTE_SOURCE_REQUIRED');
+ const target = await deps.authorizeSharedTaskHistory(sessionId, ownerRoute);
+ assertCurrent();
+ const authorizedPeer = parseProviderSharePeer(target);
+ // A remembered executor may not be replaced by O (or another member), even when
+ // that machine would successfully acknowledge releasing an absent artifact.
+ if (
+ (peer && (peer.role !== 'host' || target !== source)) ||
+ !authorizedPeer ||
+ authorizedPeer.role !== 'host' ||
+ `share:${authorizedPeer.shareId}` !== ownerRoute
+ )
+ throw new Error('REMOTE_SOURCE_REQUIRED');
+ return target;
+ }
+
+ async function currentSource(sessionId: string, source: string, assertCurrent: () => void) {
+ if (!source.startsWith('share:')) return source;
+ const live = deps.liveSharedTaskTarget?.(sessionId, source);
+ if (!live) return authorizeSource(sessionId, source, assertCurrent);
+ const peer = parseProviderSharePeer(live);
+ if (!peer || peer.role !== 'host' || `share:${peer.shareId}` !== source)
+ throw new Error('REMOTE_SOURCE_REQUIRED');
+ return live;
+ }
+
+ async function historicalSource(
+ sessionId: string,
+ value: { agentDeviceId?: string } & LegacyImageOrigin,
+ assertCurrent: () => void,
+ ): Promise<{ agentDeviceId: string } & LegacyImageOrigin> {
+ const source = value.agentDeviceId;
+ if (!source) throw new Error('REMOTE_SOURCE_REQUIRED');
+ const legacyOwnerRoute =
+ value.legacyOwnerRoute ?? (source.startsWith('share:') ? source : undefined);
+ if (!legacyOwnerRoute)
+ return { agentDeviceId: await authorizeSource(sessionId, source, assertCurrent) };
+ assertCurrent();
+ if (!deps.resolveSharedOwnerTarget) throw new Error('REMOTE_SOURCE_REQUIRED');
+ const target = await deps.resolveSharedOwnerTarget(legacyOwnerRoute);
+ assertCurrent();
+ const peer = parseProviderSharePeer(target);
+ if (
+ !peer ||
+ peer.role !== 'host' ||
+ `share:${peer.shareId}` !== legacyOwnerRoute ||
+ (source !== legacyOwnerRoute && source !== target)
+ )
+ throw new Error('REMOTE_SOURCE_REQUIRED');
+ return { agentDeviceId: target, legacyOwnerRoute };
+ }
+
+ async function authorizeRecordSource(
+ storage: ReturnType<typeof captureGeneratedImageStorage>,
+ sessionId: string,
+ record: GeneratedImageRecord & LegacyImageOrigin,
+ ) {
+ const origin = await historicalSource(sessionId, record, storage.assertCurrent);
+ if (
+ origin.agentDeviceId !== record.agentDeviceId ||
+ origin.legacyOwnerRoute !== record.legacyOwnerRoute
+ ) {
+ await storage.journal.update(record.scope, record.id, (current) => {
+ if (!current || current.agentDeviceId !== record.agentDeviceId)
+ throw new Error('REMOTE_SOURCE_REQUIRED');
+ return { ...current, ...origin };
+ });
+ }
+ return origin.agentDeviceId;
+ }
+
async function remote(deviceId: string, request: object, assertCurrent: () => void) {
assertCurrent();
const response = await deps.invoke(deviceId, REMOTE_AGENT_CHANNEL, [request], {
@@ -115,7 +205,11 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
}
}
- async function deliver(sessionId: string, event: AgentEvent): Promise<void> {
+ async function deliver(
+ sessionId: string,
+ event: AgentEvent,
+ sourceDeviceId?: string,
+ ): Promise<void> {
const image = event.data as GeneratedImageEventData;
if (
event.type !== 'image' ||
@@ -129,7 +223,7 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
const key = `${storage.snapshot.clientEpoch}:${sessionId}:${id}`;
const pending = inFlight.get(key);
if (pending) return pending;
- const operation = perform(storage, sessionId, id, image, event, Date.now());
+ const operation = perform(storage, sessionId, id, image, event, Date.now(), sourceDeviceId);
inFlight.set(key, operation);
try {
await operation;
@@ -145,6 +239,7 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
image: GeneratedImageEventData,
event: AgentEvent,
admittedAt: number,
+ sourceDeviceId?: string,
) {
const scope = `task:${sessionId}`;
const [session] = await storage.db
@@ -162,6 +257,17 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
await cleanup(sessionId);
return;
}
+ // Never create another ambiguous share alias. Early direct events can precede
+ // live-handle registration; locate them before the first receipt is written.
+ // If O is unavailable, M keeps the recoverable artifact and no source is guessed.
+ const existing = await storage.journal.read(scope, id);
+ const source = existing
+ ? existing.agentDeviceId
+ : (sourceDeviceId ??
+ (session.agentDeviceId
+ ? await currentSource(sessionId, session.agentDeviceId, storage.assertCurrent)
+ : null));
+ storage.assertCurrent();
let record = await storage.journal.update(
scope,
id,
@@ -171,7 +277,7 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
clearedAt: session.clearedAt,
remoteHostId: session.remoteHostId,
workingDir: session.workingDir,
- ...(session.agentDeviceId ? { agentDeviceId: session.agentDeviceId } : {}),
+ ...(source ? { agentDeviceId: source } : {}),
},
);
const toolUseId = `codex-image-${id}`;
@@ -216,8 +322,9 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
async function releaseSource(value: typeof record) {
if (!value.agentDeviceId || value.sourceReleased) return;
try {
+ const target = await authorizeRecordSource(storage, sessionId, value);
await remote(
- value.agentDeviceId,
+ target,
{
op: 'images',
sessionId,
@@ -361,11 +468,13 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
}
}
- if (!cached)
+ if (!cached) {
+ const target = await authorizeRecordSource(storage, sessionId, record);
source = {
...image,
- data: await download(record.agentDeviceId, sessionId, id, storage.assertCurrent),
+ data: await download(target, sessionId, id, storage.assertCurrent),
};
+ }
}
const staged = await storage.stage(
scope,
@@ -405,14 +514,21 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
}
// Release-only enumeration: never passes an unknown artifact to the message writer.
- async function cleanupUnknown(receipt: GeneratedImageCleanup) {
+ async function cleanupUnknown(receipt: GeneratedImageCleanup & LegacyImageOrigin) {
const storage = captureGeneratedImageStorage();
- const caps = await remote(receipt.agentDeviceId, { op: 'caps' }, storage.assertCurrent);
+ const origin = await historicalSource(receipt.sessionId, receipt, storage.assertCurrent);
+ const target = origin.agentDeviceId;
+ if (target !== receipt.agentDeviceId || origin.legacyOwnerRoute !== receipt.legacyOwnerRoute)
+ await storage.journal.updateCleanup(receipt.scope, (current) => ({
+ ...current!,
+ ...origin,
+ }));
+ const caps = await remote(target, { op: 'caps' }, storage.assertCurrent);
if (caps.imageRecovery !== true) return;
let offset = 0;
for (;;) {
const page = await remote(
- receipt.agentDeviceId,
+ target,
{ op: 'images', sessionId: receipt.sessionId, action: 'list', offset },
storage.assertCurrent,
);
@@ -440,7 +556,7 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
)
continue;
await remote(
- receipt.agentDeviceId,
+ target,
{ op: 'images', sessionId: receipt.sessionId, action: 'release', imageId: value.id },
storage.assertCurrent,
);
@@ -461,16 +577,27 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
.limit(1);
storage.assertCurrent();
if (session?.agentDeviceId && (session.status === 'deleted' || session.clearedAt !== null)) {
- const scope = `cleanup:${sessionId}:${session.agentDeviceId}`;
- const receipt = await storage.journal.updateCleanup(scope, (previous) => ({
- version: 1,
- scope,
- sessionId,
- agentDeviceId: session.agentDeviceId!,
- clearedAt: Math.max(previous?.clearedAt ?? 0, session.clearedAt ?? 0),
- deleted: previous?.deleted === true || session.status === 'deleted',
- }));
- await cleanupUnknown(receipt).catch(() => undefined);
+ const legacy = await storage.journal.readCleanup(
+ `cleanup:${sessionId}:${session.agentDeviceId}`,
+ );
+ if (legacy) await cleanupUnknown(legacy).catch(() => undefined);
+ try {
+ const source = await currentSource(sessionId, session.agentDeviceId, storage.assertCurrent);
+ // Keep old O and new M enumeration receipts independent across a task clear.
+ const scope = `cleanup:${sessionId}:${source}`;
+ const receipt = await storage.journal.updateCleanup(scope, (previous) => ({
+ ...previous,
+ version: 1,
+ scope,
+ sessionId,
+ agentDeviceId: source,
+ clearedAt: Math.max(previous?.clearedAt ?? 0, session.clearedAt ?? 0),
+ deleted: previous?.deleted === true || session.status === 'deleted',
+ }));
+ await cleanupUnknown(receipt);
+ } catch {
+ /* A later reconcile retries the cleared/deleted task without guessing its source. */
+ }
storage.assertCurrent();
}
for (const record of await storage.journal.list(`task:${sessionId}`)) {
@@ -479,8 +606,9 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
await storage.release(record.scope, record.id);
if (record.agentDeviceId && !record.sourceReleased) {
try {
+ const target = await authorizeRecordSource(storage, sessionId, record);
await remote(
- record.agentDeviceId,
+ target,
{
op: 'images',
sessionId,
@@ -529,12 +657,25 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
if (!session?.agentDeviceId || session.status === 'deleted') return;
// Each stable result ID is checked by perform/assertTask. An unrelated tombstone or
// rewound row must not permanently disable recovery for all future paid outputs.
- const caps = await remote(session.agentDeviceId, { op: 'caps' }, storage.assertCurrent);
+ const target = await authorizeSource(sessionId, session.agentDeviceId, storage.assertCurrent);
+ for (const record of (await storage.journal.list(scope)) as Array<
+ GeneratedImageRecord & LegacyImageOrigin
+ >) {
+ if (
+ record.clearedAt === session.clearedAt &&
+ !record.legacyOwnerRoute &&
+ record.agentDeviceId &&
+ parseProviderSharePeer(record.agentDeviceId) &&
+ record.agentDeviceId !== target
+ )
+ throw new Error('REMOTE_SOURCE_REQUIRED');
+ }
+ const caps = await remote(target, { op: 'caps' }, storage.assertCurrent);
if (caps.imageRecovery !== true) return;
let offset = 0;
for (;;) {
const page = await remote(
- session.agentDeviceId,
+ target,
{
op: 'images',
sessionId,
@@ -555,11 +696,15 @@ export function createGeneratedImageDelivery(deps: GeneratedImageDeliveryDeps) {
)
throw new Error('INVALID_IMAGE_DELIVERY');
if (session.clearedAt !== null && value.image.deliveryEpoch !== session.clearedAt) continue;
- await deliver(sessionId, {
- type: 'image',
- source: 'codex',
- data: { ...value.image, pathOrigin: 'remote-agent' },
- });
+ await deliver(
+ sessionId,
+ {
+ type: 'image',
+ source: 'codex',
+ data: { ...value.image, pathOrigin: 'remote-agent' },
+ },
+ target,
+ );
}
if (page.next === null) break;
if (typeof page.next !== 'number' || page.next <= offset)
diff --git a/apps/desktop/src/main/clientEndpointsService.ts b/apps/desktop/src/main/clientEndpointsService.ts
index 6672bf7caa..47caea51c5 100644
--- a/apps/desktop/src/main/clientEndpointsService.ts
+++ b/apps/desktop/src/main/clientEndpointsService.ts
@@ -1123,6 +1123,29 @@ export function isUsingCachedClientEndpoints(): boolean {
* 运行期端点读取入口(main 进程)。init 成功前调用 = 启动时序 bug,直接抛错
* 炸出来(随包兜底也必须先经过启动解析;--smoke-test 旁路不消费端点)。
*/
+function runtimeEndpoint(endpoints: ClientEndpointMap, key: ClientEndpointKey, region: ClientEndpointRegion): string {
+ const local = !app.isPackaged && key === 'deviceLinkApiBaseUrl'
+ ? (region === 'cn'
+ ? process.env.XDT_DEVICE_LINK_CN_LOCAL_URL ?? process.env.XDT_DEVICE_LINK_LOCAL_URL
+ : process.env.XDT_DEVICE_LINK_GLOBAL_LOCAL_URL)?.trim()
+ : undefined;
+ if (!local) return endpoints[key];
+ let url: URL;
+ try {
+ url = new URL(local);
+ } catch {
+ throw new Error('Device-link development override requires a loopback HTTP(S) URL with an explicit port');
+ }
+ if (
+ !['http:', 'https:'].includes(url.protocol) ||
+ !['127.0.0.1', '[::1]'].includes(url.hostname) ||
+ !url.port || url.username || url.password || url.pathname !== '/' || url.search || url.hash
+ ) {
+ throw new Error('Device-link development override requires a loopback HTTP(S) URL with an explicit port');
+ }
+ return url.origin;
+}
+
export function getClientEndpoint(key: ClientEndpointKey): string {
if (resolvedEndpoints === null) {
throw new Error(
@@ -1130,13 +1153,13 @@ export function getClientEndpoint(key: ClientEndpointKey): string {
);
}
if (BUILD_SCOPED_ENDPOINT_KEYS.has(key) || activeSessionRealm === null) {
- return resolvedEndpoints[key];
+ return runtimeEndpoint(resolvedEndpoints, key, resolvedRegion ?? BUILD_AUTH_REGION);
}
const sessionEndpoints = realmEndpointCache.get(activeSessionRealm);
if (!sessionEndpoints) {
throw new Error(`client endpoints for active realm '${activeSessionRealm}' not loaded`);
}
- return sessionEndpoints[key];
+ return runtimeEndpoint(sessionEndpoints, key, activeSessionRealm);
}
/** 安装包身份/更新链始终读取启动时清单,不随组织会话区域切换。 */
@@ -1197,7 +1220,7 @@ export function getClientEndpointForRealm(
if (!endpoints) {
throw new Error(`client endpoints for realm '${region}' not loaded`);
}
- return endpoints[key];
+ return runtimeEndpoint(endpoints, key, region);
}
export function activateClientEndpointRealm(region: ClientEndpointRegion): void {
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareCrossRegion.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareCrossRegion.test.ts
index f4d38ebe1f..b7ed018d63 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareCrossRegion.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareCrossRegion.test.ts
@@ -23,6 +23,9 @@ const state = vi.hoisted(() => ({
localReceivedReads: 0,
localReceivedGate: null as Promise<void> | null,
endpointsGate: null as Promise<void> | null,
+ endpointHook: null as null | (() => Promise<void>),
+ identityHook: null as null | ((purpose: string) => Promise<void>),
+ cardOwners: [] as string[],
userId: 'user-1',
identityCards: [] as string[],
invokes: [] as Array<{ target: string; channel: string }>,
@@ -43,7 +46,7 @@ vi.mock('../../authManager.js', () => ({
}));
vi.mock('../../clientEndpointsService.js', () => ({
getClientEndpoint: () => LOCAL,
- loadClientEndpointsForRealm: async () => { await state.endpointsGate; return {}; },
+ loadClientEndpointsForRealm: async () => { await state.endpointHook?.(); await state.endpointsGate; return {}; },
getClientEndpointForRealm: (region: string) => (region === 'global' ? PEER : LOCAL),
}));
vi.mock('../../maker-host/outbound-fetch.js', () => ({ createOutboundHttpAgent: async () => undefined }));
@@ -73,6 +76,8 @@ vi.mock('../providerShareApi.js', () => ({
},
fetchIdentityCard: async (purpose: string, nonce: string) => {
state.identityCards.push(purpose);
+ state.cardOwners.push(state.userId);
+ await state.identityHook?.(purpose);
return `card:${purpose}:${nonce}`;
},
rethrowProviderShareError: (error: unknown) => { throw error; },
@@ -89,6 +94,7 @@ vi.mock('@cindy/device-link', async (importOriginal) => ({
start() { this.record.started = true; }
stop() { this.record.stopped = true; }
async waitUntilOnline() {}
+ hasOfflineDirectPath() { return false; }
isLinkReady() { return false; }
async openLink() {}
async invoke(target: string, request: { channel: string }) {
@@ -139,6 +145,9 @@ beforeEach(() => {
state.localReceivedReads = 0;
state.localReceivedGate = null;
state.endpointsGate = null;
+ state.endpointHook = null;
+ state.identityHook = null;
+ state.cardOwners = [];
state.userId = 'user-1';
state.identityCards = [];
state.invokes = [];
@@ -759,3 +768,74 @@ describe('cross-region provider share', () => {
expect(state.clients).toHaveLength(0);
});
});
+
+// Unit regression for the 8c ALREADY_MEMBER recovery: public guest requests must
+// not issue/send another owner's card after an internal endpoint or identity await.
+// Existing cases switch during link resolution/HTTP, missing these inner boundaries.
+// Minimal input: one deferred boundary, owner replacement, then its late completion.
+// Only endpoint/card/server edges are fake; guest and cross-region control stay real.
+describe('cross-region identity request owner boundary', () => {
+ it.each([
+ { point: 'endpoint', switched: true },
+ { point: 'identity', switched: true },
+ { point: 'identity', switched: false },
+ ] as const)('keeps membership recovery scoped at $point (switched=$switched)', async ({ point, switched }) => {
+ const entered = deferred();
+ const resume = deferred();
+ let endpoints = 0;
+ state.endpointHook = async () => {
+ if (++endpoints === 3 && point === 'endpoint') { entered.resolve(); await resume.promise; }
+ };
+ state.identityHook = async purpose => {
+ if (purpose === 'share-session' && point === 'identity') { entered.resolve(); await resume.promise; }
+ };
+ state.responses.set('/preview', Object.assign(new Error('already a member'), { code: 'PROVIDER_SHARE_ALREADY_MEMBER' }));
+ state.responses.set('/session', { credential: CREDENTIAL, expiresAt: new Date(Date.now() + 86_400_000).toISOString(), shares: [share] });
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ const result = previewProviderShare({ invitation: TOKEN, server: PEER }).catch(error => error);
+ await entered.promise;
+ if (switched) {
+ state.userId = 'user-2';
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ }
+ resume.resolve();
+ expect(await result).toMatchObject({ code: 'PROVIDER_SHARE_ALREADY_MEMBER' });
+ expect(state.cardOwners).toEqual(point === 'endpoint' ? ['user-1'] : ['user-1', 'user-1']);
+ expect(state.calls.map(call => call.path.replace('/api/device-link/provider-shares/x', '')))
+ .toEqual(switched ? ['/preview'] : ['/preview', '/session']);
+ expect(state.clients).toHaveLength(switched ? 0 : 1);
+ expect(getCrossRegionReceived().map(item => item.shareId)).toEqual(switched ? [] : ['share-x']);
+ });
+
+ it.each([
+ { action: 'preview', point: 'endpoint' }, { action: 'preview', point: 'identity' },
+ { action: 'send', point: 'endpoint' }, { action: 'send', point: 'identity' },
+ ] as const)('rejects old-owner $action at its $point boundary', async ({ action, point }) => {
+ const entered = deferred();
+ const resume = deferred();
+ let endpoints = 0;
+ let cards = 0;
+ state.endpointHook = async () => {
+ if (++endpoints === (action === 'preview' ? 2 : 3) && point === 'endpoint') { entered.resolve(); await resume.promise; }
+ };
+ state.identityHook = async () => {
+ if (++cards === (action === 'preview' ? 1 : 2) && point === 'identity') { entered.resolve(); await resume.promise; }
+ };
+ state.responses.set('/preview', { ...share, state: 'unused', expiresAt: new Date(Date.now() + 60_000).toISOString() });
+ state.responses.set('/requests', { requestId: 'r1', status: 'pending', pairingCode: '0042', expiresAt: new Date().toISOString(), requestToken: TOKEN });
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ const input = { invitation: TOKEN, server: PEER };
+ const result = (action === 'preview' ? previewProviderShare(input) : sendProviderShareRequest(input)).catch(error => error);
+ await entered.promise;
+ state.userId = 'user-2';
+ startProviderShareGuest({ changed: vi.fn(), settled: vi.fn() }, { userDataDir: dir });
+ resume.resolve();
+ expect(await result).toMatchObject({ code: 'DEVICE_LINK_NOT_CONNECTED' });
+ const issued = (action === 'send' ? 1 : 0) + (point === 'identity' ? 1 : 0);
+ expect(state.cardOwners).toEqual(Array.from({ length: issued }, () => 'user-1'));
+ expect(state.calls.map(call => call.path.replace('/api/device-link/provider-shares/x', '')))
+ .toEqual(action === 'preview' ? [] : ['/preview']);
+ expect(__testing.readMarkers()).toEqual({});
+ expect(state.clients).toHaveLength(0);
+ });
+});
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts
index 4ed0f5dd90..7499866e23 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareManagement.test.ts
@@ -1,10 +1,20 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { ipcMain } from 'electron';
+import { REMOTE_AGENT_CHANNEL, type ProviderShareOwned } from '@cindy/device-link';
import type { ProviderShareManagementCommand } from '../../../shared/providerManagement';
import type { ProviderUsageHistoryView } from '../../../shared/providerShare';
const state = vi.hoisted(() => ({ owner: 'owner-a', boundaryPending: false }));
+vi.mock('electron', () => ({
+ app: { getPath: () => 'test-provider-share-user-data' },
+ ipcMain: { handle: vi.fn() },
+ BrowserWindow: { getAllWindows: () => [] },
+ Notification: class { show() {} },
+}));
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(),
@@ -12,7 +22,9 @@ const host = vi.hoisted(() => ({
const listProviders = vi.hoisted(() => vi.fn());
const identityCard = vi.hoisted(() => vi.fn());
const remember = vi.hoisted(() => vi.fn());
-const usageStores = vi.hoisted(() => ({ ownHistory: vi.fn(), memberHistory: vi.fn(), memberTokenSnapshot: vi.fn(), pricing: vi.fn() }));
+const usageStores = vi.hoisted(() => ({ ownHistory: vi.fn(), memberTokenSnapshot: vi.fn(), memberHistory: vi.fn(), pricing: vi.fn(),
+ enqueueDirectCleanup: vi.fn(), listPendingDirectCleanup: vi.fn(), acknowledgeDirectCleanup: vi.fn(),
+ actual: null as ReturnType<typeof import('../providerShareUsageStore').createProviderShareUsageStore> | null }));
const memberNotes = vi.hoisted(() => ({ read: vi.fn(), set: vi.fn() }));
vi.mock('../providerShareQuota.js', () => ({ readProviderShareQuota: vi.fn(), readProviderShareQuotaAccount: vi.fn() }));
const visibility = vi.hoisted(() => ({ read: vi.fn(), set: vi.fn() }));
@@ -47,7 +59,10 @@ vi.mock('../../usage/providerPartyUsageStore.js', () => ({
}));
vi.mock('../providerShareUsageStore.js', async (importOriginal) => ({
...await importOriginal<typeof import('../providerShareUsageStore.js')>(),
- getProviderShareUsageStore: () => ({ history: usageStores.memberHistory, memberTokenSnapshot: usageStores.memberTokenSnapshot }),
+ getProviderShareUsageStore: () => usageStores.actual ?? ({ history: usageStores.memberHistory, memberTokenSnapshot: usageStores.memberTokenSnapshot,
+ enqueueDirectCleanup: usageStores.enqueueDirectCleanup,
+ listPendingDirectCleanup: usageStores.listPendingDirectCleanup,
+ acknowledgeDirectCleanup: usageStores.acknowledgeDirectCleanup }),
providerUsageLocalDay: () => '2026-10-17',
}));
vi.mock('../settings-store.js', () => ({ readDeviceLinkSettings: () => ({ remoteControlEnabled: true }), readLastKnownDeviceNames: vi.fn() }));
@@ -56,19 +71,32 @@ vi.mock('../providerShareApi.js', () => ({
fetchIdentityCard: identityCard,
sha256Hex: (value: string) => value,
providerShareLinkFor: () => 'https://cindy.app/s#test-link',
+ providerShareOwnerKey: () => state.owner,
}));
vi.mock('../dispatch.js', () => ({
notifyProviderShareCatalogChanged: fastPolicy.publish,
getControllerDisplayName: vi.fn(), providerShareActiveControllers: vi.fn(),
- revalidateRemoteModelAccess: vi.fn(async () => undefined), revokeProviderShareControllers: vi.fn(), setProviderShareAccess: vi.fn(),
+ revalidateRemoteModelAccess: vi.fn(async () => undefined), revokeProviderShareControllers: vi.fn(async () => undefined), setProviderShareAccess: vi.fn(),
+}));
+vi.mock('../providerShareReshare.js', async (importOriginal) => ({
+ ...await importOriginal<typeof import('../providerShareReshare.js')>(),
+ pruneProviderShareReshares: vi.fn(async () => undefined),
}));
vi.mock('../providerShareHost.js', () => ({
startProviderShareHost: vi.fn(), stopProviderShareHost: vi.fn(),
refreshProviderShareHost: host.refresh, getProviderShareHostSnapshot: host.snapshot,
clearProviderShareRequestQuiet: vi.fn(),
- providerShareAccessRevision: vi.fn(), providerShareGuestAccess: vi.fn(), providerShareGuestDenial: vi.fn(), ensureProviderSharePeerKnown: vi.fn(),
+ providerShareAccessRevision: vi.fn(), providerShareGuestAccess: vi.fn(), ownedProviderShareGuestAccess: vi.fn(),
+ providerShareGuestDenial: vi.fn(), ensureProviderSharePeerKnown: vi.fn(),
quietProviderShareRequests: host.quiet, markProviderShareHostActive: host.active,
applyLocalRequestDecision: host.decision, applyLocalMemberChange: host.member,
+ providerShareMemberMatcher: (member: { shareId: string; memberId: string }) => (controller: string) => {
+ try {
+ const parts = JSON.parse(controller.replace(/~+$/, '')) as unknown;
+ return Array.isArray(parts) && parts[0] === 'provider-share' && parts[1] === member.shareId
+ && parts[2] === 'guest' && parts[3] === member.memberId;
+ } catch { return false; }
+ },
}));
const guest = vi.hoisted(() => ({ revision: 0, share: null as unknown }));
vi.mock('../providerShareGuest.js', () => ({ startProviderShareGuest: vi.fn(), stopProviderShareGuest: vi.fn(), findReceivedShare: () => guest.share, providerShareReceivedRevision: () => guest.revision }));
@@ -83,6 +111,9 @@ import {
stopProviderShareRuntime,
trimProviderUsageHistory,
} from '../providerShareRuntime';
+import { startProviderShareHost } from '../providerShareHost';
+import { createProviderShareUsageStore } from '../providerShareUsageStore';
+import { revokeProviderShareControllers } from '../dispatch';
const createLink: ProviderShareManagementCommand = { action: 'create-link', providerId: 'anthropic' };
const LINK_ID = 'a'.repeat(64);
@@ -109,6 +140,7 @@ beforeEach(() => {
vi.resetAllMocks();
state.owner = 'owner-a';
state.boundaryPending = false;
+ usageStores.actual = null;
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 });
@@ -128,11 +160,99 @@ beforeEach(() => {
usageStores.memberHistory.mockReturnValue([]);
usageStores.memberTokenSnapshot.mockReturnValue({ available: true, models: [],
windowStart: '2026-10-11', windowEnd: '2026-10-17', nextWindowAt: new Date(2026, 9, 18).getTime() });
+ usageStores.enqueueDirectCleanup.mockResolvedValue(undefined);
+ usageStores.listPendingDirectCleanup.mockReturnValue([]);
+ usageStores.acknowledgeDirectCleanup.mockResolvedValue(undefined);
startProviderShareRuntime(vi.fn());
});
afterEach(() => stopProviderShareRuntime());
+/* Deleting a member must use the live host callback and retain offline M until it ACKs. tier: unit. */
+describe('direct guest deletion delivery', () => {
+ // Unit tier: production runtime callbacks + real durable ledger; only transport
+ // and local host are controlled. O misses remove/reapprove while stopped.
+ it('blocks a reapproved member until local purge and the old M forget complete after restart', async () => {
+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'provider-share-rejoin-'));
+ try {
+ stopProviderShareRuntime();
+ const file = path.join(dir, 'usage.json');
+ let store = usageStores.actual = createProviderShareUsageStore(file);
+ const route = { ownerScope: 'owner-a', ownerDeviceId: 'host-device', shareId: 'share-1', memberId: 'm1',
+ memberJoinedAt: 'g1', guestDeviceId: 'G', sessionId: 'old-task', executorDeviceId: 'M',
+ executorProviderId: 'local', agentKind: 'codex', providerId: 'p', memberKey: 'M', model: 'gpt',
+ generation: '11111111-1111-4111-8111-111111111111', expiresAt: Date.now() + 30 * 60_000 };
+ const snapshot = (joinedAt: string, status: 'active' | 'paused' = 'active'): ProviderShareOwned[] => [{
+ shareId: route.shareId, providerId: 'p', providerLabel: 'P', hostDeviceId: 'host-device', createdAt: 'x', requests: [],
+ members: [{ memberId: 'm1', joinedAt, status, displayName: 'Guest', avatarUrl: null, region: 'global' }],
+ }];
+ startProviderShareRuntime(vi.fn());
+ let callbacks = vi.mocked(startProviderShareHost).mock.lastCall![0];
+ await callbacks.prepareSnapshot!(snapshot('g1'));
+ await store.registerDirectReceiptRoute(route);
+ await store.commitDirectReceiptRoute(route);
+ await callbacks.prepareSnapshot!(snapshot('g1', 'paused'));
+ await callbacks.prepareSnapshot!(snapshot('g1'));
+ expect(revokeProviderShareControllers).not.toHaveBeenCalled();
+ expect(store.findDirectTaskLocation(route)?.executorDeviceId).toBe('M');
+ stopProviderShareRuntime();
+ store = usageStores.actual = createProviderShareUsageStore(file);
+ let acknowledge!: (result: { ok: true; result: object }) => void;
+ const invoke = vi.fn(() => new Promise<{ ok: true; result: object }>((resolve) => { acknowledge = resolve; }));
+ startProviderShareRuntime(vi.fn(), { invoke });
+ callbacks = vi.mocked(startProviderShareHost).mock.lastCall![0];
+ await callbacks.prepareSnapshot!(snapshot('g2'));
+ await vi.waitFor(() => expect(invoke).toHaveBeenCalledTimes(1));
+ expect(store.findDirectTaskLocation(route)).toBeNull();
+ expect(callbacks.memberReady!({ shareId: route.shareId, memberId: 'm1', joinedAt: 'g2' })).toBe(false);
+ const renewed = { ...route, memberJoinedAt: 'g2', generation: '22222222-2222-4222-8222-222222222222' };
+ await expect(store.registerDirectReceiptRoute(renewed)).rejects.toThrow('cleanup is pending');
+ // A missing host handler returning successfully is not proof of local cleanup.
+ expect(store.listPendingMemberCleanup('owner-a', 'host-device')).toHaveLength(1);
+ await store.acknowledgeMemberCleanup(store.listPendingMemberCleanup('owner-a', 'host-device')[0]!);
+ expect(callbacks.memberReady!({ shareId: route.shareId, memberId: 'm1', joinedAt: 'g2' })).toBe(false);
+ expect(invoke).toHaveBeenCalledWith('M', REMOTE_AGENT_CHANNEL, [expect.objectContaining({
+ op: 'forget', directGuest: expect.objectContaining({ shareId: 'share-1', memberId: 'm1', guestDeviceId: 'G' }),
+ })], expect.any(Object));
+ acknowledge({ ok: true, result: {} });
+ await vi.waitFor(() => expect(callbacks.memberReady!({ shareId: route.shareId, memberId: 'm1', joinedAt: 'g2' })).toBe(true));
+ expect(store.findDirectTaskLocation(route)).toBeNull();
+ await store.registerDirectReceiptRoute(renewed);
+ } finally {
+ stopProviderShareRuntime();
+ usageStores.actual = null;
+ fs.rmSync(dir, { recursive: true, force: true });
+ }
+ });
+
+ it('sends a scoped, retryable forget to the recorded executor', async () => {
+ const target = { ownerScope: 'owner-a', shareId: 'share-1', memberId: 'm1',
+ guestDeviceId: 'guest-pc', executorDeviceId: 'executor-pc',
+ pendingId: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', cleanupEpoch: 1 };
+ usageStores.listPendingDirectCleanup.mockReturnValue([target]);
+ const invoke = vi.fn().mockResolvedValueOnce({ ok: false, error: { code: 'DEVICE_OFFLINE' } })
+ .mockResolvedValue({ ok: true, result: {} });
+ stopProviderShareRuntime();
+ startProviderShareRuntime(vi.fn(), { invoke });
+ await vi.waitFor(() => expect(invoke).toHaveBeenCalledTimes(1));
+ expect(usageStores.acknowledgeDirectCleanup).not.toHaveBeenCalled();
+
+ const callbacks = vi.mocked(startProviderShareHost).mock.lastCall![0];
+ callbacks.revoked({ shareId: target.shareId, memberId: target.memberId }, true);
+ await vi.waitFor(() => expect(usageStores.enqueueDirectCleanup).toHaveBeenCalledWith(
+ 'owner-a', expect.any(Function)));
+ const matcher = usageStores.enqueueDirectCleanup.mock.lastCall![1];
+ expect(matcher(target)).toBe(true);
+ expect(matcher({ ...target, memberId: 'another' })).toBe(false);
+ await vi.waitFor(() => expect(invoke).toHaveBeenCalledTimes(2));
+ expect(invoke).toHaveBeenLastCalledWith('executor-pc', REMOTE_AGENT_CHANNEL, [{
+ op: 'forget', directGuest: { shareId: 'share-1', memberId: 'm1', guestDeviceId: 'guest-pc',
+ forgetId: target.pendingId, cleanupEpoch: 1 },
+ }], expect.objectContaining({ preSend: expect.any(Function) }));
+ await vi.waitFor(() => expect(usageStores.acknowledgeDirectCleanup).toHaveBeenCalledWith(target));
+ });
+});
+
const historyRow = (index: number, model = 'model-' + index): ProviderUsageHistoryView['self']['days'][number] => ({
day: '2026-10-17',
kind: 'claude-code',
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 3d1ed7744e..347edcc7f6 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareRuntime.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareRuntime.test.ts
@@ -56,6 +56,7 @@ vi.mock('../providerShareApi.js', () => ({
fetchIdentityCard: vi.fn(),
sha256Hex: (value: string) => value,
providerShareOwnerKey: () => state.scope,
+ checkProviderShareDelegation: vi.fn(async () => ({ active: false })),
}));
vi.mock('../providerShareCrossRegion.js', async (importOriginal) => ({
...await importOriginal<typeof import('../providerShareCrossRegion.js')>(),
@@ -64,6 +65,13 @@ vi.mock('../providerShareCrossRegion.js', async (importOriginal) => ({
import { providerShareApi } from '../providerShareApi';
import { crossRegionLeave } from '../providerShareCrossRegion';
+import {
+ applyProviderShareDelegation, clearProviderShareDelegations,
+ delegatedProviderShareLeases, delegatedProviderShareModelAllowed,
+ delegatedProviderShareReceiptAuthority, delegatedProviderShareSessionAllowed,
+ delegatedProviderShareTaskAccess, invalidateProviderShareDelegation,
+ revokeDelegatedProviderShareGuest,
+} from '../providerShareDelegatedAccess';
import {
applyLocalMemberChange,
@@ -81,6 +89,7 @@ import {
startProviderShareHost,
stopProviderShareHost,
watchProviderShareRequests,
+ verifyProviderShareMemberGeneration,
} from '../providerShareHost';
import {
isProviderShareRefusal,
@@ -141,11 +150,231 @@ beforeEach(() => {
});
});
afterEach(() => {
+ clearProviderShareDelegations();
stopProviderShareHost();
stopProviderShareGuest();
});
+describe('delegated executor access', () => {
+ it('closes every old direct task immediately after owner deletion, then admits a fresh grant', async () => {
+ const peer = guest('m1');
+ const other = guest('m2');
+ const generation = '55555555-5555-4555-8555-555555555555';
+ const grant = { op: 'delegate' as const, action: 'grant' as const,
+ shareId: 'share-1', memberId: 'm1', guestDeviceId: 'laptop', providerId: 'anthropic',
+ model: 'model-one', generation, cleanupEpoch: 1 };
+ const check = async () => ({ active: true, ownerDeviceId: 'owner-pc', generation,
+ expiresAt: Date.now() + 30 * 60_000 });
+ await applyProviderShareDelegation('owner-pc', { ...grant, sessionId: 'old_one' }, check);
+ await applyProviderShareDelegation('owner-pc', { ...grant, sessionId: 'old_two' }, check);
+ await applyProviderShareDelegation('owner-pc', { ...grant, memberId: 'm2', sessionId: 'other' }, check);
+ revokeDelegatedProviderShareGuest('another-owner', peer, 1);
+ expect(delegatedProviderShareSessionAllowed(peer, 'old_one')).toBe(true);
+ await applyProviderShareDelegation('owner-pc', { ...grant, sessionId: 'new_one', cleanupEpoch: 2 }, check);
+ expect(revokeDelegatedProviderShareGuest('owner-pc', peer, 1, true)).toBe(false);
+ expect(delegatedProviderShareSessionAllowed(peer, 'new_one')).toBe(true);
+ expect(revokeDelegatedProviderShareGuest('owner-pc', peer, 2, true)).toBe(true);
+ expect(delegatedProviderShareSessionAllowed(peer, 'old_one')).toBe(false);
+ expect(delegatedProviderShareSessionAllowed(peer, 'old_two')).toBe(false);
+ expect(delegatedProviderShareSessionAllowed(peer, 'new_one')).toBe(false);
+ expect(delegatedProviderShareModelAllowed(peer, 'model-one', 'old_one')).toBe(false);
+ expect(delegatedProviderShareReceiptAuthority(peer, 'old_one')).toBeNull();
+ expect(delegatedProviderShareSessionAllowed(other, 'other')).toBe(true);
+ await applyProviderShareDelegation('owner-pc', { ...grant, sessionId: 'newer_one', cleanupEpoch: 3 }, check);
+ expect(delegatedProviderShareSessionAllowed(peer, 'newer_one')).toBe(true);
+ expect(delegatedProviderShareSessionAllowed(peer, 'old_one')).toBe(false);
+ });
+
+ // One share member can run two tasks on one M whose group entries point at
+ // different local providers. Each task must retain its own source and model (unit tier).
+ it('keeps concurrent task providers and models isolated on the same guest peer', async () => {
+ state.allowed.add('openai');
+ const peer = guest('m1');
+ const generation = '44444444-4444-4444-8444-444444444444';
+ const base = { op: 'delegate' as const, action: 'grant' as const,
+ shareId: 'share-1', memberId: 'm1', guestDeviceId: 'laptop', generation };
+ const check = async () => ({ active: true, ownerDeviceId: 'owner-pc', generation,
+ expiresAt: Date.now() + 30 * 60_000 });
+ await applyProviderShareDelegation('owner-pc', { ...base, providerId: 'anthropic',
+ sessionId: 'claude_task', model: 'claude-opus' }, check);
+ await applyProviderShareDelegation('owner-pc', { ...base, providerId: 'openai',
+ sessionId: 'gpt_task', model: 'gpt-5' }, check);
+ expect(delegatedProviderShareTaskAccess(peer, 'claude_task')?.providerId).toBe('anthropic');
+ expect(delegatedProviderShareTaskAccess(peer, 'gpt_task')?.providerId).toBe('openai');
+ expect(delegatedProviderShareTaskAccess(peer, 'unknown_task')).toBeNull();
+ expect(delegatedProviderShareModelAllowed(peer, 'claude-opus', 'gpt_task')).toBe(false);
+ expect(delegatedProviderShareModelAllowed(peer, 'gpt-5', 'claude_task')).toBe(false);
+ expect(delegatedProviderShareModelAllowed(peer, 'gpt-5', 'gpt_task')).toBe(true);
+ state.allowed.delete('anthropic');
+ expect(delegatedProviderShareTaskAccess(peer, 'claude_task')).toBeNull();
+ expect(delegatedProviderShareTaskAccess(peer, 'gpt_task')?.providerId).toBe('openai');
+ expect(providerShareGuestAccess(peer)?.providerId).toBe('openai');
+ });
+
+ // A turn can finish just after its 30-minute lease ends. The production M→O
+ // metering path needs its original generation, while guest admission must close (unit tier).
+ it('keeps only short-lived accounting authority after a task lease expires', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ try {
+ vi.setSystemTime(new Date('2026-10-27T12:00:00.000Z'));
+ const peer = guest('m1');
+ const generation = '11111111-1111-4111-8111-111111111111';
+ const grant = { op: 'delegate' as const, action: 'grant' as const,
+ shareId: 'share-1', memberId: 'm1', guestDeviceId: 'laptop', providerId: 'anthropic',
+ sessionId: 'long_task', model: 'model-one', generation };
+ await applyProviderShareDelegation('owner-pc', grant, async () => ({ active: true,
+ ownerDeviceId: 'owner-pc', generation, expiresAt: Date.now() + 30 * 60_000 }));
+ state.remoteControl = false;
+ expect(providerShareGuestAccess(peer)).toBeNull();
+ expect(delegatedProviderShareReceiptAuthority(peer, 'long_task'))
+ .toEqual({ ownerDeviceId: 'owner-pc', generation });
+ state.remoteControl = true;
+ state.allowed.clear();
+ expect(providerShareGuestAccess(peer)).toBeNull();
+ expect(delegatedProviderShareReceiptAuthority(peer, 'long_task'))
+ .toEqual({ ownerDeviceId: 'owner-pc', generation });
+ state.allowed.add('anthropic');
+ vi.setSystemTime(new Date(Date.now() + 30 * 60_000 + 1));
+ expect(providerShareGuestAccess(peer)).toBeNull();
+ expect(delegatedProviderShareLeases()).toEqual([]);
+ expect(delegatedProviderShareReceiptAuthority(peer, 'long_task'))
+ .toEqual({ ownerDeviceId: 'owner-pc', generation });
+ expect(delegatedProviderShareReceiptAuthority(peer, 'other_task')).toBeNull();
+ vi.setSystemTime(new Date(Date.now() + 5 * 60_000 + 1));
+ expect(delegatedProviderShareReceiptAuthority(peer, 'long_task')).toBeNull();
+ } finally { vi.useRealTimers(); }
+ });
+
+ it('clears an expired task accounting authority on account change', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ try {
+ vi.setSystemTime(new Date('2026-10-27T12:00:00.000Z'));
+ const peer = guest('m1');
+ const generation = '22222222-2222-4222-8222-222222222222';
+ await applyProviderShareDelegation('owner-pc', { op: 'delegate', action: 'grant',
+ shareId: 'share-1', memberId: 'm1', guestDeviceId: 'laptop', providerId: 'anthropic',
+ sessionId: 'long_task', model: 'model-one', generation }, async () => ({ active: true,
+ ownerDeviceId: 'owner-pc', generation, expiresAt: Date.now() + 30 * 60_000 }));
+ vi.setSystemTime(new Date(Date.now() + 30 * 60_000 + 1));
+ expect(delegatedProviderShareReceiptAuthority(peer, 'long_task')).not.toBeNull();
+ state.scope = 'cloud:another:1';
+ expect(delegatedProviderShareReceiptAuthority(peer, 'long_task')).toBeNull();
+ state.scope = 'cloud:owner:1';
+ expect(delegatedProviderShareReceiptAuthority(peer, 'long_task')).toBeNull();
+ } finally { vi.useRealTimers(); }
+ });
+
+ // Both O's explicit revoke and M's server recheck can race with a completed
+ // turn's done event. They close execution immediately but preserve its receipt (unit tier).
+ it('keeps accounting authority briefly when a delegated task is revoked or invalidated', async () => {
+ vi.useFakeTimers({ toFake: ['Date'] });
+ try {
+ vi.setSystemTime(new Date('2026-10-27T12:00:00.000Z'));
+ const peer = guest('m1');
+ const generation = '33333333-3333-4333-8333-333333333333';
+ const grant = { op: 'delegate' as const, action: 'grant' as const,
+ shareId: 'share-1', memberId: 'm1', guestDeviceId: 'laptop', providerId: 'anthropic',
+ model: 'model-one', generation };
+ const check = async () => ({ active: true, ownerDeviceId: 'owner-pc', generation,
+ expiresAt: Date.now() + 30 * 60_000 });
+ await applyProviderShareDelegation('owner-pc', { ...grant, sessionId: 'revoke_task' }, check);
+ await applyProviderShareDelegation('owner-pc', { ...grant, sessionId: 'invalid_task' }, check);
+ const invalidNonce = delegatedProviderShareLeases().find((entry) => entry.sessionId === 'invalid_task')!.lease.nonce;
+ state.remoteControl = false;
+ expect(await applyProviderShareDelegation('owner-pc', { ...grant, action: 'revoke', sessionId: 'revoke_task' }))
+ .toBe(true);
+ invalidateProviderShareDelegation(peer, 'invalid_task', invalidNonce);
+ state.remoteControl = true;
+ expect(providerShareGuestAccess(peer)).toBeNull();
+ expect(delegatedProviderShareLeases()).toEqual([]);
+ expect(delegatedProviderShareReceiptAuthority(peer, 'revoke_task'))
+ .toEqual({ ownerDeviceId: 'owner-pc', generation });
+ expect(delegatedProviderShareReceiptAuthority(peer, 'invalid_task'))
+ .toEqual({ ownerDeviceId: 'owner-pc', generation });
+ vi.setSystemTime(new Date(Date.now() + 5 * 60_000 + 1));
+ expect(delegatedProviderShareReceiptAuthority(peer, 'revoke_task')).toBeNull();
+ expect(delegatedProviderShareReceiptAuthority(peer, 'invalid_task')).toBeNull();
+ } finally { vi.useRealTimers(); }
+ });
+
+ // Permission boundary: two tasks on one guest device must not revoke each other or acquire owner permissions.
+ it('binds concurrent task leases to their approved models and stops on revocation or account change', async () => {
+ const peer = guest('m1');
+ // The delegated gate itself must fail closed when a caller forgets its
+ // host-level authorization check. O's owned-share path is handled there.
+ expect(delegatedProviderShareSessionAllowed(peer, 'task_one')).toBe(false);
+ expect(delegatedProviderShareModelAllowed(peer, 'model-one', 'task_one')).toBe(false);
+ const generation = '11111111-1111-4111-8111-111111111111';
+ const base = { op: 'delegate' as const, action: 'grant' as const, shareId: 'share-1',
+ memberId: 'm1', guestDeviceId: 'laptop', providerId: 'anthropic', generation };
+ const check = async () => ({ active: true, ownerDeviceId: 'owner-pc', expiresAt: Date.now() + 30 * 60_000,
+ generation });
+ await expect(applyProviderShareDelegation('owner-pc', { ...base, generation: '22222222-2222-4222-8222-222222222222',
+ sessionId: 'task_invalid', model: 'model-one' }, check)).rejects.toThrow('REMOTE_AGENT_INVALID');
+ await applyProviderShareDelegation('owner-pc', { ...base, sessionId: 'task_one', model: 'model-one' }, check);
+ await applyProviderShareDelegation('owner-pc', { ...base, sessionId: 'task_two', model: 'model-two' }, check);
+ expect(providerShareGuestAccess(peer)).toMatchObject({ providerId: 'anthropic', memberId: 'm1' });
+ expect(delegatedProviderShareSessionAllowed(peer, 'task_one')).toBe(true);
+ expect(delegatedProviderShareSessionAllowed(peer, 'unassigned')).toBe(false);
+ expect(delegatedProviderShareModelAllowed(peer, 'model-one', 'task_one')).toBe(true);
+ expect(delegatedProviderShareModelAllowed(peer, 'model-two', 'task_two')).toBe(true);
+ expect(delegatedProviderShareModelAllowed(peer, 'model-two', 'task_one')).toBe(false);
+ expect(delegatedProviderShareModelAllowed(peer, 'model-one', 'task_two')).toBe(false);
+ expect(delegatedProviderShareModelAllowed(peer, 'other', 'task_one')).toBe(false);
+ const renewal = '33333333-3333-4333-8333-333333333333';
+ await applyProviderShareDelegation('owner-pc', { ...base, generation: renewal,
+ sessionId: 'task_one', model: 'model-one' }, async () => ({ active: true,
+ ownerDeviceId: 'owner-pc', expiresAt: Date.now() + 30 * 60_000, generation: renewal }));
+ expect(await applyProviderShareDelegation('owner-pc', { ...base, action: 'revoke',
+ sessionId: 'task_one', model: 'model-one' })).toBe(false);
+ expect(delegatedProviderShareSessionAllowed(peer, 'task_one')).toBe(true);
+ expect(await applyProviderShareDelegation('owner-pc', { ...base, action: 'revoke', generation: renewal,
+ sessionId: 'task_one', model: 'model-one' })).toBe(true);
+ expect(delegatedProviderShareSessionAllowed(peer, 'task_one')).toBe(false);
+ expect(delegatedProviderShareSessionAllowed(peer, 'task_two')).toBe(true);
+ expect(providerShareGuestAccess(peer)).not.toBeNull();
+ state.remoteControl = false;
+ expect(providerShareGuestAccess(peer)).toBeNull();
+ state.remoteControl = true;
+ state.scope = 'cloud:another:1';
+ expect(providerShareGuestAccess(peer)).toBeNull();
+ });
+});
+
describe('provider share host snapshot', () => {
+ // Unit tier: server grant may race a deletion after O's last poll. Its new
+ // server epoch does not prove O cleaned the old guest data.
+ it('rejects a post-grant incarnation mismatch and fails closed when the fresh read is offline', async () => {
+ state.owned = [share([member('g1')])];
+ const callbacks = events();
+ startProviderShareHost(callbacks);
+ await refreshProviderShareHost('test');
+ const expected = { shareId: 'share-1', memberId: 'g1', joinedAt: member('g1').joinedAt };
+ await expect(verifyProviderShareMemberGeneration(expected)).resolves.toBeUndefined();
+ state.ownedError = true;
+ await expect(verifyProviderShareMemberGeneration(expected)).rejects.toThrow('offline');
+ state.ownedError = false;
+ state.owned = [share([{ ...member('g1'), joinedAt: '2026-10-28T01:00:00.000Z' }])];
+ await expect(verifyProviderShareMemberGeneration(expected)).rejects.toThrow('membership changed');
+ await refreshProviderShareHost('test');
+ expect(callbacks.revoked).toHaveBeenCalledWith({ shareId: 'share-1', memberId: 'g1' }, true);
+ });
+
+ // Production snapshot entry; a removed member can be reapproved with the same ID
+ // while O misses both transitions. Status-only comparison kept the old history (unit).
+ it('purges when the server reuses a member ID with a different joinedAt, even if both snapshots are active', async () => {
+ state.owned = [share([member('m1')])];
+ const ev = events();
+ startProviderShareHost(ev);
+ await refreshProviderShareHost('g1');
+ state.ownedError = true;
+ await refreshProviderShareHost('offline');
+ state.ownedError = false;
+ state.owned = [share([{ ...member('m1'), joinedAt: '2026-10-02T00:00:00.000Z' }])];
+ await refreshProviderShareHost('g2');
+ expect(ev.revoked).toHaveBeenCalledWith({ shareId: 'share-1', memberId: 'm1' }, true);
+ });
+
it('admits only active members while remote control and remote use stay on', async () => {
state.owned = [share([member('m1'), member('m2', 'paused')])];
const ev = events();
diff --git a/apps/desktop/src/main/device-link/__tests__/providerShareUsageStore.test.ts b/apps/desktop/src/main/device-link/__tests__/providerShareUsageStore.test.ts
index 7414e2b9d4..8983080db5 100644
--- a/apps/desktop/src/main/device-link/__tests__/providerShareUsageStore.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/providerShareUsageStore.test.ts
@@ -1,8 +1,9 @@
import fs from 'node:fs';
+import fsp from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { createProviderShareUsageStore, providerShareUsageRangeStart } from '../providerShareUsageStore';
@@ -10,12 +11,21 @@ const sample = (model: string, input: number, output: number, turns = 1) => ({
model, turns, inputTokens: input, outputTokens: output, cacheReadTokens: 0, cacheCreateTokens: 0, sdkCostUsd: 0,
});
+const directRoute = (now: number) => ({
+ ownerScope: 'global:owner-1', ownerDeviceId: 'owner-pc', shareId: 'share-1', memberId: 'guest-1',
+ guestDeviceId: 'guest-pc', sessionId: 'task-1', executorDeviceId: 'member-pc-1',
+ executorProviderId: 'local-openai', agentKind: 'codex', providerId: 'openai',
+ memberKey: 'device:member-1', model: 'gpt',
+ generation: '11111111-1111-4111-8111-111111111111', expiresAt: now + 30 * 60_000,
+});
+
describe('provider share usage store', () => {
let dir: string;
beforeEach(() => {
dir = fs.mkdtempSync(path.join(os.tmpdir(), 'provider-share-usage-'));
});
afterEach(() => {
+ vi.restoreAllMocks();
fs.rmSync(dir, { recursive: true, force: true });
});
@@ -46,8 +56,9 @@ describe('provider share usage store', () => {
fs.writeFileSync(file, '{broken');
const store = createProviderShareUsageStore(file);
expect(store.memberTokenSnapshot(new Set(['s']), 'p', 'alice').available).toBe(false);
- store.record('s', 'alice', { kind: 'codex', providerId: 'p', memberKey: 'local', samples: [sample('model', 1, 0)] });
- await store.flush();
+ expect(() => store.record('s', 'alice', { kind: 'codex', providerId: 'p', memberKey: 'local', samples: [sample('model', 1, 0)] })).toThrow('ledger');
+ await expect(store.flush()).rejects.toThrow('ledger');
+ expect(fs.readFileSync(file, 'utf8')).toBe('{broken');
expect(createProviderShareUsageStore(file).memberTokenSnapshot(new Set(['s']), 'p', 'alice').available).toBe(false);
});
@@ -65,6 +76,13 @@ describe('provider share usage store', () => {
let store = createProviderShareUsageStore(file, { now: () => now });
const snapshot = () => store.memberTokenSnapshot(new Set(['s']), 'p', 'alice');
expect(snapshot().available).toBe(false);
+ if (damage === 'corrupt-json') {
+ // A damaged whole ledger may contain cleanup fences: only a repaired
+ // valid image can recover; usage rollover cannot erase security state.
+ await expect(store.flush()).rejects.toThrow('ledger');
+ expect(fs.readFileSync(file, 'utf8')).toBe('{broken');
+ fs.writeFileSync(file, JSON.stringify({ version: 1, rows: [], incompleteThroughDay: '2026-10-22' }));
+ }
await store.flush();
now = new Date(2026, 9, 23, 12).getTime();
store = createProviderShareUsageStore(file, { now: () => now });
@@ -76,6 +94,357 @@ describe('provider share usage store', () => {
expect(snapshot()).toMatchObject({ available: true, models: [{ model: 'model', tokens: 15 }] });
},
);
+ // Unit tier / security review #2+#3: production load/reconcile/commit/flush.
+ // A single failed read previously cached emptiness, erased old M cleanup and
+ // admitted a reapproved member. Existing corrupt-file coverage expected that
+ // unsafe reset; these faults must preserve disk and allow the SAME store to retry.
+ it.each(['EACCES', 'EIO', 'EBUSY'])('keeps unread %s safety state closed and retries after recovery', async (code) => {
+ const file = path.join(dir, 'unread-ledger.json');
+ const route = { ...directRoute(Date.now()), memberJoinedAt: 'g1' };
+ const snapshot = (joinedAt: string) => [{ shareId: route.shareId, members: [{ memberId: route.memberId, joinedAt }] }];
+ const initial = createProviderShareUsageStore(file);
+ await initial.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('g1'));
+ await initial.registerDirectReceiptRoute(route);
+ await initial.commitDirectReceiptRoute(route);
+ const originalRead = fs.readFileSync.bind(fs);
+ const saved = originalRead(file, 'utf8');
+ let unreadable = true;
+ const read = vi.spyOn(fs, 'readFileSync').mockImplementation((...args: Parameters<typeof fs.readFileSync>) => {
+ if (unreadable && String(args[0]) === file) throw Object.assign(new Error('fixture read failure'), { code });
+ return originalRead(...args);
+ });
+ const restarted = createProviderShareUsageStore(file);
+ const renewed = { ...route, memberJoinedAt: 'g2', generation: '22222222-2222-4222-8222-222222222222' };
+ expect(() => restarted.listPendingDirectCleanup(route.ownerScope)).toThrow('ledger');
+ expect(() => restarted.memberGenerationReady(route, 'g2')).toThrow('ledger');
+ expect(() => restarted.findDirectTaskLocation(route)).toThrow('ledger');
+ await expect(restarted.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('g2'))).rejects.toThrow('ledger');
+ await expect(restarted.registerDirectReceiptRoute(renewed)).rejects.toThrow('ledger');
+ await expect(restarted.commitDirectReceiptRoute(renewed)).rejects.toThrow('ledger');
+ expect(() => restarted.record(route.shareId, route.memberId,
+ { kind: 'codex', providerId: 'openai', memberKey: 'local', samples: [sample('gpt', 1, 1)] })).toThrow('ledger');
+ await expect(restarted.flush()).rejects.toThrow('ledger');
+ expect(originalRead(file, 'utf8')).toBe(saved);
+ unreadable = false;
+ await restarted.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('g2'));
+ expect(restarted.memberGenerationReady(route, 'g2')).toBe(false);
+ expect(restarted.findDirectTaskLocation(route)).toBeNull();
+ const target = restarted.listPendingDirectCleanup(route.ownerScope)[0]!;
+ expect(target.executorDeviceId).toBe(route.executorDeviceId);
+ await expect(restarted.registerDirectReceiptRoute(renewed)).rejects.toThrow('cleanup is pending');
+ await restarted.acknowledgeMemberCleanup(restarted.listPendingMemberCleanup(route.ownerScope, route.ownerDeviceId)[0]!);
+ await restarted.acknowledgeDirectCleanup(target);
+ await restarted.registerDirectReceiptRoute(renewed);
+ await restarted.commitDirectReceiptRoute(renewed);
+ read.mockRestore();
+ });
+
+ it.each(['memberGenerations', 'directReceiptRoutes', 'directCleanupTargets', 'directTaskLocations', 'recentUsageIds'])
+ ('rejects malformed %s without publishing partial state or overwriting disk', async (field) => {
+ const file = path.join(dir, 'invalid-safety.json');
+ const route = { ...directRoute(Date.now()), memberJoinedAt: 'g1' };
+ const initial = createProviderShareUsageStore(file);
+ const snapshot = (joinedAt: string) => [{ shareId: route.shareId, members: [{ memberId: route.memberId, joinedAt }] }];
+ await initial.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('g1'));
+ await initial.registerDirectReceiptRoute(route);
+ await initial.commitDirectReceiptRoute(route);
+ const valid = JSON.parse(fs.readFileSync(file, 'utf8'));
+ const restarted = createProviderShareUsageStore(file);
+ for (const invalid of [null, {}, [...valid[field], null], [...valid[field], ...valid[field], { invalid: true }]]) {
+ const body = JSON.stringify({ ...valid, [field]: invalid });
+ fs.writeFileSync(file, body);
+ expect(() => restarted.memberGenerationReady(route, 'g2')).toThrow('ledger');
+ await expect(restarted.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('g2'))).rejects.toThrow('ledger');
+ await expect(restarted.flush()).rejects.toThrow('ledger');
+ expect(fs.readFileSync(file, 'utf8')).toBe(body);
+ }
+ fs.writeFileSync(file, JSON.stringify(valid));
+ await restarted.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('g2'));
+ expect(restarted.memberGenerationReady(route, 'g2')).toBe(false);
+ expect(restarted.listPendingDirectCleanup(route.ownerScope)).toHaveLength(1);
+ });
+
+ it('rejects contradictory duplicate cleanup fences instead of keeping the last entry', async () => {
+ const file = path.join(dir, 'duplicate-safety.json');
+ const route = directRoute(Date.now());
+ const target = { ...route, cleanupEpoch: 1, pendingId: '33333333-3333-4333-8333-333333333333' };
+ const body = JSON.stringify({ version: 1, rows: [], directCleanupTargets: [target, { ...target, pendingId: undefined }] });
+ fs.writeFileSync(file, body);
+ const store = createProviderShareUsageStore(file);
+ expect(() => store.listPendingDirectCleanup(route.ownerScope)).toThrow('Duplicate');
+ await expect(store.registerDirectReceiptRoute(route)).rejects.toThrow('Duplicate');
+ expect(fs.readFileSync(file, 'utf8')).toBe(body);
+ });
+
+ it('preserves oversized cleanup/receipt arrays and migrates every old executor before enforcing admission limits', async () => {
+ const file = path.join(dir, 'oversized-safety.json');
+ const now = Date.now();
+ const route = directRoute(now);
+ const pendingId = '33333333-3333-4333-8333-333333333333';
+ const routes = Array.from({ length: 20_001 }, (_, index) => ({ ...route, sessionId: `task-${index}`,
+ executorDeviceId: `M-${index}`, committedAt: now, expiresAt: now - 60 * 60_000 }));
+ const targets = Array.from({ length: 20_001 }, (_, index) => ({ ...route, executorDeviceId: `N-${index}`,
+ cleanupEpoch: 1, ...(index === 0 ? { pendingId } : {}) }));
+ fs.writeFileSync(file, JSON.stringify({ version: 1, rows: [], directReceiptRoutes: routes, directCleanupTargets: targets }));
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ expect(store.listPendingDirectCleanup(route.ownerScope)[0]).toMatchObject({ executorDeviceId: 'N-0', pendingId });
+ expect(store.findDirectTaskLocation({ ...route, sessionId: 'task-0' })?.executorDeviceId).toBe('M-0');
+ await store.flush();
+ const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
+ expect(saved.directCleanupTargets).toHaveLength(40_002);
+ expect(saved.directTaskLocations).toHaveLength(20_001);
+ expect(saved.directCleanupTargets[0]).toMatchObject({ executorDeviceId: 'N-0', pendingId });
+ await expect(store.registerDirectReceiptRoute({ ...route, sessionId: 'new-task' })).rejects.toThrow('ledger is full');
+ });
+
+ // Unit tier, production durable ledger: active g1 -> O restart -> active g2
+ // with the same memberId is absent from the original receipt/cleanup coverage.
+ it('fences a reapproved member across restart until local and every executor cleanup ACK', async () => {
+ const file = path.join(dir, 'membership.json');
+ const now = Date.now();
+ const route = { ...directRoute(now), memberJoinedAt: 'server-g1' };
+ const snapshot = (joinedAt: string) => [{ shareId: route.shareId, members: [{ memberId: route.memberId, joinedAt }] }];
+ let store = createProviderShareUsageStore(file, { now: () => now });
+ await store.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('server-g1'));
+ await store.registerDirectReceiptRoute(route);
+ await store.commitDirectReceiptRoute(route);
+ // Pause/resume has the same joinedAt and must preserve task affinity.
+ expect(await store.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('server-g1'))).toEqual([]);
+ expect(store.findDirectTaskLocation(route)?.executorDeviceId).toBe('member-pc-1');
+ store = createProviderShareUsageStore(file, { now: () => now });
+ const [pending] = await store.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('server-g2'));
+ expect(store.findDirectTaskLocation(route)).toBeNull();
+ expect(store.listActiveDirectReceiptRoutes(route.ownerScope)).toEqual([]);
+ const renewed = { ...route, memberJoinedAt: 'server-g2', generation: '22222222-2222-4222-8222-222222222222' };
+ await expect(store.registerDirectReceiptRoute(renewed)).rejects.toThrow('cleanup is pending');
+ await expect(store.commitDirectReceiptRoute(route)).rejects.toThrow();
+ await store.acknowledgeMemberCleanup(pending!);
+ expect(store.memberGenerationReady(route, 'server-g2')).toBe(false);
+ await expect(store.registerDirectReceiptRoute(renewed)).rejects.toThrow('cleanup is pending');
+ const target = store.listPendingDirectCleanup(route.ownerScope)[0]!;
+ expect(target).toMatchObject({ executorDeviceId: route.executorDeviceId, pendingId: expect.any(String) });
+ await store.acknowledgeDirectCleanup(target);
+ expect(store.memberGenerationReady(route, 'server-g2')).toBe(true);
+ expect(store.memberGenerationReady(route, 'server-g1')).toBe(false);
+ expect(store.findDirectTaskLocation(route)).toBeNull();
+ await store.registerDirectReceiptRoute(renewed);
+ await store.commitDirectReceiptRoute(renewed);
+ expect(store.findDirectTaskLocation(route)?.memberJoinedAt).toBe('server-g2');
+ const [g3] = await store.reconcileMemberGenerations(route.ownerScope, route.ownerDeviceId, snapshot('server-g3'));
+ await store.acknowledgeMemberCleanup(pending!);
+ expect(store.listPendingMemberCleanup(route.ownerScope, route.ownerDeviceId)).toEqual([g3]);
+ expect(createProviderShareUsageStore(file).findDirectTaskLocation(route)).toBeNull();
+ });
+
+ it('persists relay-only removal, cleanup scopes and owner isolation with fail-closed atomic writes', async () => {
+ const file = path.join(dir, 'relay-membership.json');
+ let store = createProviderShareUsageStore(file);
+ const snapshot = [{ shareId: 's', members: [{ memberId: 'm', joinedAt: 'g1' }] }];
+ const member = { ownerScope: 'a', ownerDeviceId: 'O', shareId: 's', memberId: 'm' };
+ await store.reconcileMemberGenerations('a', 'O', snapshot);
+ await store.reconcileMemberGenerations('b', 'O', snapshot);
+ const rename = vi.spyOn(fsp, 'rename').mockRejectedValueOnce(new Error('disk denied'));
+ await expect(store.reconcileMemberGenerations('a', 'O', [])).rejects.toThrow('disk denied');
+ expect(store.memberGenerationReady(member, 'g1')).toBe(false);
+ await store.reconcileMemberGenerations('a', 'O', []);
+ expect(store.memberGenerationReady({ ...member, ownerScope: 'b' }, 'g1')).toBe(true);
+ const [removed] = store.listPendingMemberCleanup('a', 'O');
+ await store.rememberMemberCleanupScopes(removed!, [{ controller: 'old-peer', relay: 'old-relay' }]);
+ store = createProviderShareUsageStore(file);
+ expect(store.listPendingMemberCleanup('a', 'O')[0]?.cleanupScopes).toEqual([{ controller: 'old-peer', relay: 'old-relay' }]);
+ // Even a reappearance with an equal joinedAt cannot undo an observed removal.
+ const [rejoined] = await store.reconcileMemberGenerations('a', 'O', snapshot);
+ await store.acknowledgeMemberCleanup(removed!);
+ expect(store.memberGenerationReady(member, 'g1')).toBe(false);
+ rename.mockRejectedValueOnce(new Error('ack denied'));
+ await expect(store.acknowledgeMemberCleanup(rejoined!)).rejects.toThrow('ack denied');
+ expect(store.memberGenerationReady(member, 'g1')).toBe(false);
+ await store.acknowledgeMemberCleanup(rejoined!);
+ expect(createProviderShareUsageStore(file).memberGenerationReady(member, 'g1')).toBe(true);
+ });
+
+ // Production ledger commit/find/cleanup entries, unit tier. The previous receipt-only tests
+ // could not protect native-session affinity: one committed task lost M after its 30m lease.
+ // These inputs also cover durable failure, migration, capacity and the six identity boundaries;
+ // none grants execution permission. Fake time avoids real lease waits.
+ it('keeps a committed task location beyond lease/grace expiry and fences stale relay or renewal updates', async () => {
+ const file = path.join(dir, 'locations.json');
+ let now = new Date(2026, 9, 27, 12).getTime();
+ const route = directRoute(now);
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ await store.registerDirectReceiptRoute(route);
+ expect(store.findDirectTaskLocation(route)).toBeNull();
+ await store.commitDirectReceiptRoute(route);
+ now += 31 * 60_000;
+ expect(store.listActiveDirectReceiptRoutes(route.ownerScope)).toEqual([]);
+ const restarted = createProviderShareUsageStore(file, { now: () => now });
+ expect(restarted.getDirectTaskLocation(route.ownerScope, route.ownerDeviceId, route.shareId,
+ route.memberId, route.guestDeviceId, route.sessionId))
+ .toMatchObject({ executorDeviceId: 'member-pc-1', executorProviderId: 'local-openai', agentKind: 'codex' });
+ const afterGrace = now + 90 * 24 * 60 * 60_000;
+ const longAfterExpiry = createProviderShareUsageStore(file, { now: () => afterGrace });
+ expect(longAfterExpiry.listActiveDirectReceiptRoutes(route.ownerScope)).toEqual([]);
+ expect(longAfterExpiry.findDirectTaskLocation(route)?.executorDeviceId).toBe('member-pc-1');
+ const renewed = { ...route, model: 'gpt-new', expiresAt: now + 30 * 60_000,
+ generation: '22222222-2222-4222-8222-222222222222' };
+ await store.registerDirectReceiptRoute(renewed);
+ expect(store.findDirectTaskLocation(route)?.model).toBe('gpt');
+ await store.commitDirectReceiptRoute(renewed);
+ await store.markDirectReceiptRouteRevoked(route);
+ expect(await store.markDirectTaskRelayed(route, route.generation)).toBe(false);
+ const location = store.findDirectTaskLocation(route)!;
+ expect(location).toMatchObject({ model: 'gpt-new', generation: renewed.generation });
+ expect(location).not.toHaveProperty('expiresAt');
+ location.executorDeviceId = 'mutated-copy';
+ expect(store.findDirectTaskLocation(route)?.executorDeviceId).toBe('member-pc-1');
+ expect(await store.markDirectTaskRelayed(renewed, renewed.generation)).toBe(true);
+ // A retried old commit must not restore a task that has explicitly moved to relay.
+ await store.commitDirectReceiptRoute(renewed);
+ expect(createProviderShareUsageStore(file, { now: () => now }).findDirectTaskLocation(route)).toBeNull();
+ });
+
+ it('does not publish provisional or failed commits, and atomically restores the previous model location', async () => {
+ const file = path.join(dir, 'atomic-location.json');
+ const now = new Date(2026, 9, 27, 12).getTime();
+ const route = directRoute(now);
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ // Registration never trusts caller-supplied committedAt.
+ await store.registerDirectReceiptRoute({ ...route, committedAt: now });
+ expect(store.findDirectTaskLocation(route)).toBeNull();
+ expect(createProviderShareUsageStore(file, { now: () => now }).findDirectTaskLocation(route)).toBeNull();
+ const rename = vi.spyOn(fsp, 'rename').mockImplementationOnce(async () => {
+ expect(store.findDirectTaskLocation(route)).toBeNull();
+ expect(store.listActiveDirectReceiptRoutes(route.ownerScope)[0]?.committedAt).toBeUndefined();
+ throw new Error('disk denied');
+ });
+ await expect(store.commitDirectReceiptRoute(route)).rejects.toThrow('disk denied');
+ expect(store.findDirectTaskLocation(route)).toBeNull();
+ expect(store.listActiveDirectReceiptRoutes(route.ownerScope)[0]?.committedAt).toBeUndefined();
+ expect(createProviderShareUsageStore(file, { now: () => now }).findDirectTaskLocation(route)).toBeNull();
+ await store.commitDirectReceiptRoute(route);
+ const renewed = { ...route, model: 'gpt-new', generation: '22222222-2222-4222-8222-222222222222' };
+ await store.registerDirectReceiptRoute(renewed);
+ rename.mockRejectedValueOnce(new Error('replacement denied'));
+ // Another queued write must never serialize the failed commit's tentative location.
+ const failed = expect(store.commitDirectReceiptRoute(renewed)).rejects.toThrow('replacement denied');
+ const revoked = store.markDirectReceiptRouteRevoked(route);
+ await Promise.all([failed, revoked]);
+ expect(store.findDirectTaskLocation(route)).toMatchObject({ generation: route.generation, model: 'gpt' });
+ expect(createProviderShareUsageStore(file, { now: () => now }).findDirectTaskLocation(route))
+ .toMatchObject({ generation: route.generation, model: 'gpt' });
+ expect(store.listActiveDirectReceiptRoutes(route.ownerScope)[0]?.committedAt).toBeUndefined();
+ });
+
+ it('clears member locations with durable cleanup and cannot recommit a deleted assignment', async () => {
+ const file = path.join(dir, 'deleted-location.json');
+ const now = new Date(2026, 9, 27, 12).getTime();
+ const route = directRoute(now);
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ const otherTask = { ...route, sessionId: 'task-2', executorDeviceId: 'member-pc-2' };
+ const otherMember = { ...route, memberId: 'guest-2' };
+ for (const entry of [route, otherTask, otherMember]) {
+ await store.registerDirectReceiptRoute(entry);
+ await store.commitDirectReceiptRoute(entry);
+ }
+ vi.spyOn(fsp, 'rename').mockRejectedValueOnce(new Error('cleanup denied'));
+ const match = (target: { memberId: string }) => target.memberId === route.memberId;
+ await expect(store.enqueueDirectCleanup(route.ownerScope, match)).rejects.toThrow('cleanup denied');
+ expect(store.findDirectTaskLocation(route)).toBeNull();
+ const pending = store.listPendingDirectCleanup(route.ownerScope);
+ expect(pending).toHaveLength(2);
+ // Failed replacement left the complete old image on disk, never half of the deletion.
+ const oldImage = createProviderShareUsageStore(file, { now: () => now });
+ expect(oldImage.findDirectTaskLocation(route)).not.toBeNull();
+ expect(oldImage.listPendingDirectCleanup(route.ownerScope)).toEqual([]);
+ await expect(store.commitDirectReceiptRoute(route)).rejects.toThrow('cannot be committed');
+ await store.enqueueDirectCleanup(route.ownerScope, match);
+ expect(store.listPendingDirectCleanup(route.ownerScope)).toEqual(pending);
+ const restarted = createProviderShareUsageStore(file, { now: () => now });
+ expect(restarted.findDirectTaskLocation(route)).toBeNull();
+ expect(restarted.findDirectTaskLocation(otherTask)).toBeNull();
+ expect(restarted.findDirectTaskLocation(otherMember)).not.toBeNull();
+ await restarted.acknowledgeDirectCleanup(pending[0]!);
+ await expect(restarted.commitDirectReceiptRoute(route)).rejects.toThrow('cannot be committed');
+ await restarted.enqueueDirectCleanup(route.ownerScope, (target) => target.shareId === route.shareId);
+ expect(createProviderShareUsageStore(file, { now: () => now }).findDirectTaskLocation(otherMember)).toBeNull();
+ });
+
+ it('migrates the latest committed legacy location even after grace without reviving cleaned or provisional tasks', async () => {
+ const file = path.join(dir, 'legacy-location.json');
+ let now = new Date(2026, 9, 27, 12).getTime();
+ const route = directRoute(now);
+ const newer = { ...route, committedAt: now + 1, model: 'gpt-new', executorDeviceId: 'member-pc-2',
+ generation: '22222222-2222-4222-8222-222222222222' };
+ const deleted = { ...route, sessionId: 'deleted', memberId: 'deleted-member', committedAt: now };
+ const cleaned = { ...route, sessionId: 'cleaned', memberId: 'cleaned-member', committedAt: now };
+ const revoked = { ...route, sessionId: 'revoked', committedAt: now, revokedAt: now };
+ fs.writeFileSync(file, JSON.stringify({ version: 1, rows: [], directReceiptRoutes: [
+ newer, { ...route, committedAt: now }, { ...route, sessionId: 'provisional' }, deleted, cleaned, revoked,
+ ], directCleanupTargets: [
+ { ...deleted, cleanupEpoch: 1, pendingId: route.generation }, { ...cleaned, cleanupEpoch: 1, cleaned: true },
+ ] }));
+ now += 90 * 24 * 60 * 60_000;
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ expect(store.findDirectTaskLocation(route)).toMatchObject({ model: 'gpt-new', executorDeviceId: 'member-pc-2' });
+ expect(store.findDirectTaskLocation({ ...route, sessionId: 'provisional' })).toBeNull();
+ expect(store.findDirectTaskLocation(deleted)).toBeNull();
+ expect(store.findDirectTaskLocation(cleaned)).toBeNull();
+ expect(store.findDirectTaskLocation(revoked)).toBeNull();
+ expect(store.listActiveDirectReceiptRoutes(route.ownerScope)).toEqual([]);
+ await store.flush();
+ expect(createProviderShareUsageStore(file, { now: () => now }).findDirectTaskLocation(route))
+ .toMatchObject({ executorDeviceId: 'member-pc-2' });
+ await store.enqueueDirectCleanup(route.ownerScope, (target) => target.memberId === route.memberId);
+ expect(store.listPendingDirectCleanup(route.ownerScope).map((target) => target.executorDeviceId))
+ .toEqual(expect.arrayContaining(['member-pc-1', 'member-pc-2']));
+ expect(createProviderShareUsageStore(file, { now: () => now }).findDirectTaskLocation(route)).toBeNull();
+ });
+
+ it('requires all owner/share/member/guest/session identity fields for location lookup and removal', async () => {
+ const file = path.join(dir, 'scoped-location.json');
+ const now = new Date(2026, 9, 27, 12).getTime();
+ const route = directRoute(now);
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ await store.registerDirectReceiptRoute(route);
+ await store.commitDirectReceiptRoute(route);
+ for (const field of ['ownerScope', 'ownerDeviceId', 'shareId', 'memberId', 'guestDeviceId', 'sessionId'] as const) {
+ const foreign = { ...route, [field]: `other-${route[field]}` };
+ expect(store.getDirectTaskLocation(foreign.ownerScope, foreign.ownerDeviceId, foreign.shareId,
+ foreign.memberId, foreign.guestDeviceId, foreign.sessionId)).toBeNull();
+ expect(await store.clearDirectTaskLocation(foreign, route.generation)).toBe(false);
+ }
+ expect(store.findDirectTaskLocation(route)).not.toBeNull();
+ vi.spyOn(fsp, 'rename').mockRejectedValueOnce(new Error('clear denied'));
+ await expect(store.clearDirectTaskLocation(route, route.generation)).rejects.toThrow('clear denied');
+ expect(store.findDirectTaskLocation(route)).not.toBeNull();
+ expect(createProviderShareUsageStore(file, { now: () => now }).findDirectTaskLocation(route)).not.toBeNull();
+ expect(await store.clearDirectTaskLocation(route, route.generation)).toBe(true);
+ expect(createProviderShareUsageStore(file, { now: () => now }).findDirectTaskLocation(route)).toBeNull();
+ });
+
+ it('rejects new locations at capacity without evicting old tasks and still permits renewal', async () => {
+ const file = path.join(dir, 'full-location.json');
+ const now = new Date(2026, 9, 27, 12).getTime();
+ const route = directRoute(now);
+ const overflow = { ...route, sessionId: 'overflow' };
+ fs.writeFileSync(file, JSON.stringify({ version: 1, rows: [],
+ directTaskLocations: Array.from({ length: 20_000 }, (_, index) => ({ ...route, sessionId: `task-${index}`, committedAt: now })),
+ directReceiptRoutes: [overflow], directCleanupTargets: [{ ...route, cleanupEpoch: 1 }],
+ }));
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ await expect(store.registerDirectReceiptRoute({ ...overflow, sessionId: 'new' })).rejects.toThrow('location ledger is full');
+ await expect(store.commitDirectReceiptRoute(overflow)).rejects.toThrow('location ledger is full');
+ expect(store.findDirectTaskLocation(overflow)).toBeNull();
+ expect(store.listActiveDirectReceiptRoutes(route.ownerScope)[0]?.committedAt).toBeUndefined();
+ const renewed = { ...route, sessionId: 'task-0', model: 'gpt-new',
+ generation: '22222222-2222-4222-8222-222222222222' };
+ await store.registerDirectReceiptRoute(renewed);
+ await store.commitDirectReceiptRoute(renewed);
+ const restarted = createProviderShareUsageStore(file, { now: () => now });
+ expect(restarted.findDirectTaskLocation(renewed)).toMatchObject({ model: 'gpt-new' });
+ expect(restarted.findDirectTaskLocation({ ...route, sessionId: 'task-19999' })).not.toBeNull();
+ expect(JSON.parse(fs.readFileSync(file, 'utf8')).directTaskLocations).toHaveLength(20_000);
+ });
it('aggregates per member and model, filters by range and only returns requested shares', async () => {
let now = new Date(2026, 9, 7, 12).getTime();
@@ -99,6 +468,142 @@ describe('provider share usage store', () => {
expect(reloaded.query(new Set(['share-1', 'share-2']), 'all')).toHaveLength(2);
});
+ it('records a retried executor usage receipt only once, including after a host restart', async () => {
+ const file = path.join(dir, 'usage.json');
+ const now = new Date(2026, 9, 27, 12).getTime();
+ const input = { kind: 'codex', providerId: 'openai', memberKey: 'device:member-1', samples: [sample('gpt', 7, 3)] };
+ const id = '12345678-1234-1234-1234-123456789abc';
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ expect(store.recordOnce(id, 'share', 'guest', input)).toBe(true);
+ expect(store.recordOnce(id, 'share', 'guest', input)).toBe(false);
+ await store.flush();
+ const reloaded = createProviderShareUsageStore(file, { now: () => now });
+ expect(reloaded.recordOnce(id, 'share', 'guest', input)).toBe(false);
+ expect(reloaded.query(new Set(['share']), 'all')[0]?.models[0]).toMatchObject({ turns: 1, inputTokens: 7 });
+ });
+
+ it('keeps every retry ID for the executor retry window even when the ledger reaches capacity', () => {
+ const file = path.join(dir, 'usage.json');
+ let now = new Date(2026, 9, 27, 12).getTime();
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ const input = { kind: 'codex', providerId: 'openai', memberKey: 'device:member-1',
+ samples: [sample('gpt', 1, 0)] };
+ const id = (index: number) => `12345678-1234-4234-8234-${index.toString(16).padStart(12, '0')}`;
+ for (let index = 0; index < 20_000; index++) expect(store.recordOnce(id(index), 'share', 'guest', input)).toBe(true);
+ expect(store.recordOnce(id(0), 'share', 'guest', input)).toBe(false);
+ expect(() => store.recordOnce(id(20_000), 'share', 'guest', input)).toThrow('REMOTE_AGENT_BUSY');
+ expect(store.query(new Set(['share']), 'all')[0]?.models[0]?.turns).toBe(20_000);
+ now += 33 * 60_000;
+ expect(store.recordOnce(id(20_000), 'share', 'guest', input)).toBe(true);
+ });
+
+ // Regression: O may restart, switch M, or let a lease expire while M retries a completed turn's receipt.
+ // This exercises the production ledger entry, its durable acknowledgement, and authenticated M binding (unit tier).
+ it('accepts historical direct receipts after restart or route switch, but only from their assigned executor', async () => {
+ const file = path.join(dir, 'usage.json');
+ let now = new Date(2026, 9, 27, 12).getTime();
+ const route = {
+ ownerScope: 'global:owner-1', ownerDeviceId: 'owner-pc', shareId: 'share-1', memberId: 'guest-1',
+ guestDeviceId: 'guest-pc', sessionId: 'task-1', executorDeviceId: 'member-pc-1',
+ executorProviderId: 'local-openai', agentKind: 'codex', providerId: 'openai',
+ memberKey: 'device:member-1', model: 'gpt',
+ generation: '11111111-1111-4111-8111-111111111111', expiresAt: now + 30 * 60_000,
+ };
+ const first = createProviderShareUsageStore(file, { now: () => now });
+ await first.registerDirectReceiptRoute(route);
+ const receipt = { shareId: route.shareId, memberId: route.memberId, guestDeviceId: route.guestDeviceId,
+ sessionId: route.sessionId, generation: route.generation, agentKind: 'codex',
+ usageId: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
+ samples: [sample('gpt', 7, 3)] };
+ await expect(first.recordDirectReceipt('global:owner-1', 'owner-pc', 'member-pc-1', receipt)).rejects.toThrow();
+ await first.commitDirectReceiptRoute(route);
+ const restarted = createProviderShareUsageStore(file, { now: () => now });
+ expect(restarted.listActiveDirectReceiptRoutes('global:owner-2')).toEqual([]);
+ expect(restarted.listActiveDirectReceiptRoutes('global:owner-1')).toMatchObject([
+ { executorDeviceId: 'member-pc-1', executorProviderId: 'local-openai', generation: route.generation },
+ ]);
+ await expect(restarted.recordDirectReceipt('global:owner-1', 'owner-pc', 'other-pc', receipt)).rejects.toThrow();
+ await expect(restarted.recordDirectReceipt('global:owner-2', 'owner-pc', 'member-pc-1', receipt)).rejects.toThrow();
+ await expect(restarted.recordDirectReceipt('global:owner-1', 'other-owner', 'member-pc-1', receipt)).rejects.toThrow();
+ const secondRoute = { ...route, executorDeviceId: 'member-pc-2', memberKey: 'device:member-2',
+ generation: '22222222-2222-4222-8222-222222222222' };
+ const renewedRoute = { ...route, memberKey: 'device:member-renewed',
+ generation: '33333333-3333-4333-8333-333333333333' };
+ await restarted.registerDirectReceiptRoute(secondRoute);
+ await restarted.commitDirectReceiptRoute(secondRoute);
+ await restarted.registerDirectReceiptRoute(renewedRoute);
+ await restarted.commitDirectReceiptRoute(renewedRoute);
+ await restarted.markDirectReceiptRouteRevoked(route);
+ expect(restarted.listActiveDirectReceiptRoutes('global:owner-1').map((entry) => entry.generation))
+ .toEqual(['22222222-2222-4222-8222-222222222222', '33333333-3333-4333-8333-333333333333']);
+ expect(createProviderShareUsageStore(file, { now: () => now })
+ .listActiveDirectReceiptRoutes('global:owner-1').map((entry) => entry.generation))
+ .toEqual(['22222222-2222-4222-8222-222222222222', '33333333-3333-4333-8333-333333333333']);
+ await expect(restarted.registerDirectReceiptRoute(route)).rejects.toThrow('revoked');
+ now = route.expiresAt + 60_000;
+ expect(restarted.listActiveDirectReceiptRoutes('global:owner-1')).toEqual([]);
+ expect(await restarted.recordDirectReceipt('global:owner-1', 'owner-pc', 'member-pc-1', receipt)).toBe(true);
+ const latest = { ...receipt, generation: '22222222-2222-4222-8222-222222222222',
+ usageId: 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', samples: [sample('gpt', 5, 2)] };
+ expect(await restarted.recordDirectReceipt('global:owner-1', 'owner-pc', 'member-pc-2', latest)).toBe(true);
+ await expect(restarted.recordDirectReceipt('global:owner-1', 'owner-pc', 'member-pc-2',
+ { ...latest, generation: route.generation })).rejects.toThrow();
+ const renewed = { ...receipt, generation: '33333333-3333-4333-8333-333333333333',
+ usageId: 'dddddddd-dddd-4ddd-8ddd-dddddddddddd', samples: [sample('gpt', 2, 1)] };
+ expect(await restarted.recordDirectReceipt('global:owner-1', 'owner-pc', 'member-pc-1', renewed)).toBe(true);
+ const afterAck = createProviderShareUsageStore(file, { now: () => now });
+ expect(await afterAck.recordDirectReceipt('global:owner-1', 'owner-pc', 'member-pc-1', receipt)).toBe(false);
+ expect(afterAck.query(new Set(['share-1']), 'all')[0]?.models.map((row) => [row.memberKey, row.inputTokens]))
+ .toEqual(expect.arrayContaining([['device:member-1', 7], ['device:member-2', 5], ['device:member-renewed', 2]]));
+ now = route.expiresAt + 31 * 60_000;
+ await expect(afterAck.recordDirectReceipt('global:owner-1', 'owner-pc', 'member-pc-1',
+ { ...receipt, usageId: 'cccccccc-cccc-4ccc-8ccc-cccccccccccc' })).rejects.toThrow();
+ });
+
+ // A member can leave long after the 30-minute direct lease and receipt grace
+ // expire. O must still know every M that may hold this G's guest-home (unit tier).
+ it('retains direct cleanup destinations until M acknowledges deletion, scoped to the owner', async () => {
+ const file = path.join(dir, 'cleanup.json');
+ let now = new Date(2026, 9, 27, 12).getTime();
+ const route = {
+ ownerScope: 'global:owner-a', ownerDeviceId: 'owner-pc', shareId: 'share-a', memberId: 'member-a',
+ guestDeviceId: 'guest-pc', sessionId: 'task-1', executorDeviceId: 'executor-a',
+ executorProviderId: 'openai', agentKind: 'codex', providerId: 'openai', memberKey: 'member-key',
+ model: 'gpt', generation: '11111111-1111-4111-8111-111111111111', expiresAt: now + 30 * 60_000,
+ };
+ const store = createProviderShareUsageStore(file, { now: () => now });
+ expect(await store.registerDirectReceiptRoute(route)).toBe(1);
+ expect(await store.registerDirectReceiptRoute({ ...route, sessionId: 'task-2', executorDeviceId: 'executor-b' })).toBe(1);
+ await store.registerDirectReceiptRoute({ ...route, memberId: 'member-b', guestDeviceId: 'other-guest', sessionId: 'task-3' });
+ now += 3 * 24 * 60 * 60_000;
+ await store.flush();
+ const restarted = createProviderShareUsageStore(file, { now: () => now });
+ await restarted.enqueueDirectCleanup('global:owner-a', (target) => target.memberId === 'member-a');
+ expect(restarted.listPendingDirectCleanup('global:owner-b')).toEqual([]);
+ const pending = restarted.listPendingDirectCleanup('global:owner-a');
+ expect(pending.map((target) => target.executorDeviceId)).toEqual(['executor-a', 'executor-b']);
+ expect(restarted.pendingDirectCleanupFor('global:owner-a', {
+ shareId: 'share-a', memberId: 'member-a', guestDeviceId: 'guest-pc', executorDeviceId: 'executor-b',
+ })).toEqual(pending[1]);
+ await restarted.acknowledgeDirectCleanup(pending[0]!);
+ const afterAck = createProviderShareUsageStore(file, { now: () => now });
+ expect(afterAck.listPendingDirectCleanup('global:owner-a').map((target) => target.executorDeviceId))
+ .toEqual(['executor-b']);
+ // A rejoin on M must first settle its old deletion, then advance the fence.
+ const renewed = { ...route, sessionId: 'task-4', executorDeviceId: 'executor-b',
+ generation: '22222222-2222-4222-8222-222222222222', expiresAt: now + 30 * 60_000 };
+ await expect(afterAck.registerDirectReceiptRoute(renewed)).rejects.toThrow('cleanup is still pending');
+ await afterAck.acknowledgeDirectCleanup(pending[1]!);
+ expect(await afterAck.registerDirectReceiptRoute(renewed)).toBe(2);
+ await afterAck.acknowledgeDirectCleanup(pending[1]!); // stale ACK cannot clear a new grant
+ expect(afterAck.listPendingDirectCleanup('global:owner-a')).toEqual([]);
+ await afterAck.enqueueDirectCleanup('global:owner-a', (target) => target.memberId === 'member-a');
+ expect(afterAck.listPendingDirectCleanup('global:owner-a')).toMatchObject([{
+ executorDeviceId: 'executor-b', cleanupEpoch: 2,
+ }]);
+ expect(afterAck.listPendingDirectCleanup('global:owner-a')[0]?.pendingId).not.toBe(pending[1]?.pendingId);
+ });
+
it('splits each row by computer in the group without changing the row key, so older versions keep the totals', async () => {
const now = new Date(2026, 9, 11, 12).getTime();
const file = path.join(dir, 'usage.json');
@@ -261,12 +766,18 @@ describe('provider share usage store', () => {
expect(saved.rows[0]!.turns).toBe(515);
});
- it('starts from an empty ledger when the file is corrupt and drops malformed rows', () => {
+ it('rejects corrupt files, retries the same store, and still drops malformed accounting rows', async () => {
const file = path.join(dir, 'usage.json');
- fs.writeFileSync(file, '{not json');
- expect(createProviderShareUsageStore(file).query(new Set(['s']), 'all')).toEqual([]);
+ const store = createProviderShareUsageStore(file);
+ for (const invalid of ['{not json', 'null', '{"version":2,"rows":[]}', '{"version":1,"rows":null}']) {
+ fs.writeFileSync(file, invalid);
+ expect(() => store.query(new Set(['s']), 'all')).toThrow('ledger');
+ await expect(store.flush()).rejects.toThrow('ledger');
+ expect(fs.readFileSync(file, 'utf8')).toBe(invalid);
+ }
fs.writeFileSync(file, JSON.stringify({ version: 1, rows: [{ day: '2026-10-01', shareId: 's', memberId: 'm', kind: 'pi', providerId: null, model: 'x', turns: -1 }] }));
- expect(createProviderShareUsageStore(file).query(new Set(['s']), 'all')).toEqual([]);
+ expect(store.query(new Set(['s']), 'all')).toEqual([]);
+ await store.flush();
});
it('computes range starts in local days', () => {
diff --git a/apps/desktop/src/main/device-link/__tests__/remoteModelAccess.test.ts b/apps/desktop/src/main/device-link/__tests__/remoteModelAccess.test.ts
index 4e08ddb209..0ee6abc61c 100644
--- a/apps/desktop/src/main/device-link/__tests__/remoteModelAccess.test.ts
+++ b/apps/desktop/src/main/device-link/__tests__/remoteModelAccess.test.ts
@@ -86,8 +86,26 @@ describe('remote model permissions', () => {
fs.mkdirSync(path.dirname(filePath()), { recursive: true });
fs.writeFileSync(filePath(), JSON.stringify({ providers: { p: { members: {}, budgets: [] } } }));
expect(make().allows('p', 'astra', 'alice')).toBe(false);
+ expect(make().allowsDelegatedExecution('p', 'astra', 'alice')).toBe(false);
expect(make().allows('p', 'astra')).toBe(true);
});
+ // Unit: the real persisted grant must keep live budgets on O's relay path;
+ // ordinary model grants do not distinguish an offline delegated lease.
+ it('withdraws delegated eligibility for a live budget and restores it when disabled', async () => {
+ const store = make();
+ const policy = { rules: [{ id: 'a', models: ['astra'], maxPercent: 30 }], recommendedModel: 'terra', basis: 'member-input-output-7d' as const, enabled: true };
+ const eligibility: boolean[] = [];
+ store.subscribe(() => { eligibility.push(store.allowsDelegatedExecution('p', 'astra', 'alice')); });
+ expect(store.allowsDelegatedExecution('p', 'astra', 'alice')).toBe(true);
+ await store.set('p', null, 'alice', () => {}, policy);
+ expect(make().allowsDelegatedExecution('p', 'astra', 'alice')).toBe(false);
+ expect(store.allows('p', 'astra', 'alice')).toBe(true);
+ expect(store.allowsDelegatedExecution('p', 'astra', 'bob')).toBe(true);
+ await store.set('p', null, 'alice', () => {}, { ...policy, enabled: false });
+ expect(eligibility).toEqual([false, true]);
+ await store.set('p', [], 'alice', () => {});
+ expect(store.allowsDelegatedExecution('p', 'astra', 'alice')).toBe(false);
+ });
it.each([{}, ['x', 'x'], [''], [' x'], [42], Array(4097).fill('m')])('refuses malformed model selections %#', (value) => {
expect(isRemoteModelSelection(value)).toBe(false);
});
diff --git a/apps/desktop/src/main/device-link/dispatch.ts b/apps/desktop/src/main/device-link/dispatch.ts
index 8ed0f404d6..cf51bbadfa 100644
--- a/apps/desktop/src/main/device-link/dispatch.ts
+++ b/apps/desktop/src/main/device-link/dispatch.ts
@@ -51,6 +51,7 @@ import { compactToolCardResult } from '../../shared/toolResultPersistCap.js';
*/
import { RemoteInvokeTiming } from './remoteInvokeTiming.js';
+import { delegatedProviderShareGuestAccess } from './providerShareDelegatedAccess.js';
import { observeRemoteSendPush } from './remoteSendTrace.js';
import {
computeAllowlistHash,
@@ -392,6 +393,8 @@ export interface ProviderShareAccessPort {
insights?(controller: string, request: unknown): Promise<unknown>;
insightsCurrent?(controller: string, result: unknown): boolean;
guestAccess(controller: string): { shareId: string; memberId: string; providerId: string } | null;
+ /** Catalog invalidation comes only from the share owner, never a delegated executor. */
+ catalogGuestAccess?(controller: string): { shareId: string; memberId: string; providerId: string } | null;
/** 不认识的受邀者连进来时按需刷新一次分享快照。 */
ensureKnown(controller: string): Promise<void>;
hasShares(): boolean;
@@ -411,7 +414,9 @@ function providerShareGuestAccess(controller: string): ReturnType<ProviderShareA
/** Empty invalidation only, scoped to the currently authorized shared provider. Never subscribe guests to owner topics. */
export function notifyProviderShareCatalogChanged(providerId: string): void {
for (const peer of acceptedLinkControllers) {
- if (!isProviderSharePeer(peer) || providerShareGuestAccess(peer)?.providerId !== providerId) continue;
+ const catalogAccess = providerShareAccess?.catalogGuestAccess
+ ? providerShareAccess.catalogGuestAccess(peer) : providerShareGuestAccess(peer);
+ if (!isProviderSharePeer(peer) || catalogAccess?.providerId !== providerId) continue;
sendPushBestEffort(peer, 'maker:provider:changed', {});
}
}
@@ -2782,10 +2787,12 @@ function handleLinkOpen(
});
return;
}
- if (!providerShareGuestAccess(src)
- || !sanitizeControllerCapabilities(payload?.capabilities).includes(PROVIDER_SHARE_RELAY_CAPABILITY)) {
- logProviderShareDenial(src, 'link-open', providerShareGuestAccess(src) ? 'missing-relay-capability' : undefined);
- client.closeLink(src, 'revoked', 'inbound');
+ const guestAccess = providerShareGuestAccess(src);
+ if (!guestAccess || !sanitizeControllerCapabilities(payload?.capabilities).includes(PROVIDER_SHARE_RELAY_CAPABILITY)) {
+ logProviderShareDenial(src, 'link-open', guestAccess ? 'missing-relay-capability' : undefined);
+ // A newly allocated M can see link-open before its delegated lease is
+ // installed. Lack of a lease is never a durable guest revocation.
+ client.closeLink(src, guestAccess ? 'revoked' : 'transport-timeout', 'inbound');
return;
}
try {
@@ -4436,6 +4443,8 @@ async function runProviderShareInvoke(
return PROVIDER_SHARE_ACCESS_FAILURE;
}
if (!payload || typeof payload.channel !== 'string') return PROVIDER_SHARE_ACCESS_FAILURE;
+ // An executor's short lease authorizes only remote Agent execution, never the share owner's catalog or management reads.
+ if (delegatedProviderShareGuestAccess(src) && payload.channel !== REMOTE_AGENT_CHANNEL) return PROVIDER_SHARE_ACCESS_FAILURE;
if (!PROVIDER_SHARE_CHANNELS.has(payload.channel)) {
log.warn(`blocked provider-share channel from ${shortId(src)}: ${payload.channel}`);
return { ok: false, error: { code: 'CHANNEL_NOT_ALLOWED', message: `channel '${payload.channel}' not allowed for shared providers` } };
diff --git a/apps/desktop/src/main/device-link/index.ts b/apps/desktop/src/main/device-link/index.ts
index 720aa5b190..c59354bf33 100644
--- a/apps/desktop/src/main/device-link/index.ts
+++ b/apps/desktop/src/main/device-link/index.ts
@@ -1764,8 +1764,9 @@ function assertRemoteControlTargetEnabled(deviceId: string): void {
*/
const CONNECT_READY_TIMEOUT_MS = 1_500;
-async function ensureOnlineForRequest(): Promise<void> {
- if (!client || client.getStatus() === 'online') return;
+async function ensureOnlineForRequest(deviceId?: string): Promise<void> {
+ if (!client || client.getStatus() === 'online'
+ || (deviceId && client.hasOfflineDirectPath(deviceId))) return;
await client.waitUntilOnline(CONNECT_READY_TIMEOUT_MS);
}
@@ -1958,12 +1959,12 @@ export async function remoteInvoke(
}
const invoke = async (): Promise<InvokeResultPayload> => {
// 熔断门禁(外层 guardInvoke)在连接等待之前:open 态快速失败,不消耗 1.5s 等待。
- await ensureOnlineForRequest();
+ await ensureOnlineForRequest(deviceId);
// fail-closed 边界不得跨 await 失效:等待期间用户可能已关闭该设备控制(复验
// 授权),或显式 CLOSE_LINK(复验取消代次)(review P1 ×2)。
preSend();
if (!client) throw new Error('[DEVICE_LINK_NOT_CONNECTED] device-link client not initialized');
- // 共享任务与供应商分享的对端是另一个账号:只走 relay,不尝试点对点直连。
+ // 同账号专用的 tryPeerInvoke 不用于 scoped peer;供应商分享直连由 DeviceLinkClient 的可靠传输层处理。
if (!isScopedPeer(deviceId)) {
// 直连会保存这个回调,之后在空闲关闭等定时器里调用(届时 preSend 可能已失效)。
// 必须是 async:失效时返回 rejected promise,不能同步抛出绕过调用方的 .catch。
@@ -2017,7 +2018,7 @@ export async function remoteBackgroundInvoke(
// 分享来的供应商:任务记录里是 `share:<id>`,换成分享者那台电脑的本地 peer key。
const deviceId = await resolveRemoteAgentTargetWhenReady(agentDeviceId);
options?.preSend?.();
- const shared = deviceId !== agentDeviceId;
+ const shared = deviceId !== agentDeviceId || parseProviderSharePeer(deviceId)?.role === 'host';
if (!shared) return backgroundInvokeDevice(deviceId, channel, args, options);
try {
// 跨区域分享:分享者电脑在另一个区域的 relay 上,经那条连接发送。
@@ -2087,7 +2088,7 @@ export async function remoteSubscribe(
// CLOSE_LINK 的在途调用;之后的新调用(重放重试 / 用户重开)按新代次照常。
const closeEpoch = openLinkCloseEpochs.get(deviceId) ?? 0;
const run = async (): Promise<InvokeResultPayload> => {
- await ensureOnlineForRequest();
+ await ensureOnlineForRequest(deviceId);
let liveTopics = liveTopicsNow();
if (liveTopics.length === 0) return { ok: true, result: null };
if (!client) throw new Error('[DEVICE_LINK_NOT_CONNECTED] device-link client not initialized');
diff --git a/apps/desktop/src/main/device-link/providerShareApi.ts b/apps/desktop/src/main/device-link/providerShareApi.ts
index 2b22cc8e9d..4dc3dd834b 100644
--- a/apps/desktop/src/main/device-link/providerShareApi.ts
+++ b/apps/desktop/src/main/device-link/providerShareApi.ts
@@ -78,6 +78,68 @@ export const providerShareApi = createProviderShareApi({
},
});
+/** Only the share's authenticated host device may authorize a same-account executor. */
+export async function grantProviderShareDelegation(input: {
+ shareId: string; memberId: string; guestDeviceId: string; executorDeviceId: string;
+}): Promise<{ expiresAt: number; generation: string }> {
+ const scope = captureScope();
+ const value = await serverApiFetch<{ expiresAt?: unknown; generation?: unknown }>('/api/device-link/provider-shares/delegations', {
+ method: 'POST', body: input,
+ baseUrl: () => {
+ if (!scope.isCurrent()) throw new ProviderShareScopeChangedError();
+ return getClientEndpoint('deviceLinkApiBaseUrl');
+ },
+ timeoutMs: 15_000, cache: 'no-store',
+ logLabel: '/api/device-link/provider-shares/delegations',
+ redactErrorDetails: true, allowedRedactedErrorCodes: ALLOWED_REDACTED_CODES,
+ });
+ if (!Number.isSafeInteger(value.expiresAt) || (value.expiresAt as number) <= Date.now()
+ || typeof value.generation !== 'string' || !/^[0-9a-f-]{36}$/.test(value.generation)) {
+ throw new Error('Provider share delegation was not confirmed');
+ }
+ return { expiresAt: value.expiresAt as number, generation: value.generation };
+}
+
+export async function revokeProviderShareDelegation(input: {
+ shareId: string; memberId: string; guestDeviceId: string; executorDeviceId: string; generation: string;
+}): Promise<void> {
+ const scope = captureScope();
+ await serverApiFetch('/api/device-link/provider-shares/delegations/revoke', {
+ method: 'POST', body: input,
+ baseUrl: () => {
+ if (!scope.isCurrent()) throw new ProviderShareScopeChangedError();
+ return getClientEndpoint('deviceLinkApiBaseUrl');
+ },
+ timeoutMs: 15_000, cache: 'no-store',
+ logLabel: '/api/device-link/provider-shares/delegations/revoke',
+ redactErrorDetails: true, allowedRedactedErrorCodes: ALLOWED_REDACTED_CODES,
+ });
+}
+
+/** M verifies that the server accepted O's delegation before trusting a cross-account guest. */
+export async function checkProviderShareDelegation(input: {
+ shareId: string; memberId: string; guestDeviceId: string; executorDeviceId: string;
+}): Promise<{ active: boolean; ownerDeviceId?: string; expiresAt?: number; generation?: string }> {
+ const scope = captureScope();
+ const value = await serverApiFetch<{ active?: unknown; ownerDeviceId?: unknown;
+ expiresAt?: unknown; generation?: unknown }>(
+ '/api/device-link/provider-shares/delegations/check', {
+ method: 'POST', body: input,
+ baseUrl: () => {
+ if (!scope.isCurrent()) throw new ProviderShareScopeChangedError();
+ return getClientEndpoint('deviceLinkApiBaseUrl');
+ },
+ timeoutMs: 15_000, cache: 'no-store',
+ logLabel: '/api/device-link/provider-shares/delegations/check',
+ redactErrorDetails: true, allowedRedactedErrorCodes: ALLOWED_REDACTED_CODES,
+ });
+ if (value.active !== true || typeof value.ownerDeviceId !== 'string'
+ || typeof value.generation !== 'string' || !/^[0-9a-f-]{36}$/.test(value.generation)
+ || !Number.isSafeInteger(value.expiresAt) || (value.expiresAt as number) <= Date.now()) return { active: false };
+ return { active: true, ownerDeviceId: value.ownerDeviceId,
+ expiresAt: value.expiresAt as number, generation: value.generation };
+}
+
/**
* 供应商分享运行时的账号作用域:模式 + 数据所有者,不含代次。同一账号的投影修复会推进代次但不
* 重连设备互联,不能因此让分享失效;换账号时数据所有者变化,且登出 / 换号会先停掉运行时。
diff --git a/apps/desktop/src/main/device-link/providerShareCrossRegion.ts b/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
index 147c967053..e2a7527592 100644
--- a/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
+++ b/apps/desktop/src/main/device-link/providerShareCrossRegion.ts
@@ -40,6 +40,7 @@ import { createOutboundHttpAgent } from '../maker-host/outbound-fetch.js';
import { serverApiFetch } from '../serverApiClient.js';
import { throwIpcError } from '../utils/ipcValidate.js';
import { deviceName } from './deviceName.js';
+import { desktopDirectRuntime } from './directLink.js';
import { fetchIdentityCard, rethrowProviderShareError, sha256Hex } from './providerShareApi.js';
const log = createLogger('provider-share:cross-region');
@@ -232,10 +233,20 @@ async function recoverExistingMembership(rt: Runtime | null, region: Region, err
if (current(rt)) await refreshRegion(rt, region);
}
+/** An invitation belongs to the account/runtime that began it, including before startup. */
+function assertRequestCurrent(rt: Runtime | null, account: string | null): void {
+ if (!account || accountKey() !== account || runtime !== rt || (rt && !current(rt))) {
+ throwIpcError('DEVICE_LINK_NOT_CONNECTED', 'Account changed');
+ }
+}
+
export async function crossRegionPreview(region: Region, invitation: string): Promise<ProviderShareLinkPreview> {
+ const account = accountKey();
const rt = runtime;
const base = await peerApiBase(region);
+ assertRequestCurrent(rt, account);
const identityCard = await fetchIdentityCard('share-request', sha256Hex(invitation));
+ assertRequestCurrent(rt, account);
const value = await peerRequest(base, '/preview', { invitation, identityCard }).catch(async (error: unknown) => {
await recoverExistingMembership(rt, region, error);
throw error;
@@ -253,7 +264,9 @@ export async function crossRegionSendRequest(region: Region, invitation: string)
if (!account) throwIpcError('DEVICE_LINK_NOT_CONNECTED', 'Not signed in');
const rt = runtime;
const base = await peerApiBase(region);
+ assertRequestCurrent(rt, account);
const identityCard = await fetchIdentityCard('share-request', sha256Hex(invitation));
+ assertRequestCurrent(rt, account);
const value = await peerRequest(base, '/requests', { invitation, identityCard }).catch(async (error: unknown) => {
await recoverExistingMembership(rt, region, error);
throw error;
@@ -287,6 +300,9 @@ export async function crossRegionWithdraw(region: Region, requestId: string, req
function createClient(rt: Runtime, state: RegionState): DeviceLinkClient {
const wsUrl = state.apiBase.replace(/^http/, 'ws') + WS_PATH;
const client = new DeviceLinkClient({
+ // The capture process is shared with the local-region client. A cross-region
+ // socket closing must only close its own sessions, never suspend that process.
+ directRuntime: { create: (id, events) => desktopDirectRuntime.create(id, events) },
getWsUrl: () => wsUrl,
authorizationScheme: 'ProviderShareGuest',
getToken: async () => {
@@ -363,7 +379,9 @@ function refreshRegion(rt: Runtime, region: Region): Promise<void> {
const deviceId = getDeviceId();
if (!deviceId) return;
const base = await peerApiBase(region);
+ if (!isCurrent()) return;
const identityCard = await fetchIdentityCard('share-session', sha256Hex(deviceId));
+ if (!isCurrent()) return;
const value = await peerRequest(base, '/session', {
identityCard,
deviceId,
@@ -545,12 +563,24 @@ export function isCrossRegionProviderShareTarget(peerKey: string): boolean {
return peer?.role === 'host' && isCrossRegionShare(peer.shareId);
}
+/** Relay-confirmed link renewal refreshes the bounded direct lease on both peers. */
+export async function renewCrossRegionProviderShareLink(peerKey: string): Promise<void> {
+ const peer = parseProviderSharePeer(peerKey);
+ const client = peer ? stateForShare(peer.shareId)?.client : null;
+ if (!client) throw new DeviceLinkError('NOT_CONNECTED', 'cross-region provider share is not connected');
+ await client.waitUntilOnline(ONLINE_WAIT_MS);
+ await client.openLink(peerKey, {
+ controllerName: deviceName(), protocolVersion: 1, appVersion: app.getVersion(),
+ capabilities: [PROVIDER_SHARE_RELAY_CAPABILITY, DEVICE_LINK_CAPABILITY_BACKGROUND_LINK_V1],
+ });
+}
+
export async function crossRegionInvoke(peerKey: string, channel: string, args: unknown[], timeoutMs?: number): Promise<InvokeResultPayload> {
const peer = parseProviderSharePeer(peerKey);
const state = peer ? stateForShare(peer.shareId) : null;
const client = state?.client;
if (!client) throw new DeviceLinkError('NOT_CONNECTED', 'cross-region provider share is not connected');
- await client.waitUntilOnline(ONLINE_WAIT_MS);
+ if (!client.hasOfflineDirectPath(peerKey)) await client.waitUntilOnline(ONLINE_WAIT_MS);
const open = () => client.openLink(peerKey, {
controllerName: deviceName(),
protocolVersion: 1,
diff --git a/apps/desktop/src/main/device-link/providerShareDelegatedAccess.ts b/apps/desktop/src/main/device-link/providerShareDelegatedAccess.ts
new file mode 100644
index 0000000000..59dd991be7
--- /dev/null
+++ b/apps/desktop/src/main/device-link/providerShareDelegatedAccess.ts
@@ -0,0 +1,264 @@
+import { isProviderSharePeer, providerShareGuestPeer, type RemoteAgentRequest } from '@cindy/device-link';
+import { randomUUID } from 'node:crypto';
+
+import { getDeviceId } from '../authManager.js';
+import { isRemoteProviderInvocationAllowed } from '../maker-host/remote-provider-access-store.js';
+import { checkProviderShareDelegation, providerShareOwnerKey } from './providerShareApi.js';
+import { readDeviceLinkSettings } from './settings-store.js';
+
+const LEASE_MS = 30 * 60_000;
+const MAX_LEASES = 512;
+/** A completed turn can report its counters just after its execution lease expires. */
+const RECEIPT_GRACE_MS = 5 * 60_000;
+const MAX_RECEIPT_AUTHORITIES = 20_000;
+const MAX_BLOCKED_PEERS = 20_000;
+
+type Delegate = Extract<RemoteAgentRequest, { op: 'delegate' }>;
+type Access = { shareId: string; memberId: string; providerId: string };
+type Lease = { ownerScope: string; ownerDeviceId: string; access: Access; model: string;
+ generation: string; cleanupEpoch: number; wallUntil: number; monoUntil: number; nonce: string };
+type ReceiptAuthority = Pick<Lease, 'ownerScope' | 'ownerDeviceId' | 'generation' | 'wallUntil' | 'monoUntil'>;
+/** One guest peer may have concurrent tasks with different approved models. */
+const leases = new Map<string, Map<string, Lease>>();
+/** Accounting only: never consulted by guest admission, model access, or run lifetime. */
+const receiptOnlyAuthorities = new Map<string, ReceiptAuthority>();
+const pending = new Map<string, { mark: symbol; generation: string; ownerDeviceId: string;
+ cleanupEpoch: number }>();
+const blockedPeers = new Map<string, { ownerScope: string; ownerDeviceId: string }>();
+const receiptKey = (peer: string, sessionId: string) => JSON.stringify([peer, sessionId]);
+
+function retainReceiptAuthority(peer: string, sessionId: string, lease: Lease,
+ wall = Date.now(), mono = performance.now()): void {
+ if (lease.ownerScope !== providerShareOwnerKey()) return;
+ // A stopped run may still deliver the done event for a turn it already used.
+ // Its accounting window starts when execution stops, never after the lease deadline.
+ const wallUntil = Math.min(lease.wallUntil, wall) + RECEIPT_GRACE_MS;
+ const monoUntil = Math.min(lease.monoUntil, mono) + RECEIPT_GRACE_MS;
+ if (wallUntil <= wall || monoUntil <= mono) return;
+ const key = receiptKey(peer, sessionId);
+ receiptOnlyAuthorities.delete(key);
+ receiptOnlyAuthorities.set(key, { ownerScope: lease.ownerScope, ownerDeviceId: lease.ownerDeviceId,
+ generation: lease.generation, wallUntil, monoUntil });
+ while (receiptOnlyAuthorities.size > MAX_RECEIPT_AUTHORITIES) {
+ receiptOnlyAuthorities.delete(receiptOnlyAuthorities.keys().next().value!);
+ }
+}
+
+function prune(): void {
+ const wall = Date.now(), mono = performance.now(), scope = providerShareOwnerKey();
+ for (const [peer, tasks] of leases) {
+ for (const [sessionId, lease] of tasks) {
+ if (lease.ownerScope !== scope) {
+ tasks.delete(sessionId);
+ } else if (lease.wallUntil <= wall || lease.monoUntil <= mono) {
+ tasks.delete(sessionId);
+ retainReceiptAuthority(peer, sessionId, lease, wall, mono);
+ }
+ }
+ if (!tasks.size) leases.delete(peer);
+ }
+ for (const [key, authority] of receiptOnlyAuthorities) {
+ if (authority.ownerScope !== scope || authority.wallUntil <= wall
+ || authority.monoUntil <= mono) receiptOnlyAuthorities.delete(key);
+ }
+}
+
+function leaseAllowed(lease: Lease): boolean {
+ const settings = readDeviceLinkSettings();
+ return settings.remoteControlEnabled && !settings.revokedControllers?.includes(lease.ownerDeviceId)
+ && isRemoteProviderInvocationAllowed(lease.access.providerId);
+}
+
+function validTask(peer: string, sessionId: string): Lease | null {
+ prune();
+ const lease = leases.get(peer)?.get(sessionId);
+ return lease && leaseAllowed(lease) ? lease : null;
+}
+
+/** A grant only comes from a same-account, authenticated device-link peer; runHost checks that before calling. */
+export async function applyProviderShareDelegation(ownerDeviceId: string, request: Delegate,
+ check: typeof checkProviderShareDelegation = checkProviderShareDelegation): Promise<boolean> {
+ if (isProviderSharePeer(ownerDeviceId) || !getDeviceId() || ownerDeviceId === getDeviceId()) {
+ throw new Error('REMOTE_AGENT_INVALID');
+ }
+ const settings = readDeviceLinkSettings();
+ if (request.action === 'grant'
+ && (!settings.remoteControlEnabled || settings.revokedControllers?.includes(ownerDeviceId))) {
+ throw new Error('REMOTE_AGENT_UNAVAILABLE');
+ }
+ const peer = providerShareGuestPeer(request.shareId, request.memberId, request.guestDeviceId);
+ const key = receiptKey(peer, request.sessionId);
+ prune();
+ const tasks = leases.get(peer);
+ if (request.action === 'revoke') {
+ if (pending.get(key)?.generation === request.generation) pending.delete(key);
+ const lease = tasks?.get(request.sessionId);
+ if (tasks && lease?.ownerDeviceId === ownerDeviceId
+ && request.generation && lease.generation === request.generation) {
+ retainReceiptAuthority(peer, request.sessionId, lease);
+ tasks.delete(request.sessionId);
+ if (!tasks.size) leases.delete(peer);
+ return true;
+ }
+ return false;
+ }
+ if (!request.generation) throw new Error('REMOTE_AGENT_INVALID');
+ const count = [...leases.values()].reduce((sum, entries) => sum + entries.size, 0);
+ if (!isRemoteProviderInvocationAllowed(request.providerId)
+ || (!tasks?.has(request.sessionId) && count >= MAX_LEASES)) throw new Error('REMOTE_AGENT_UNAVAILABLE');
+ if (tasks && [...tasks.values()].some((lease) => lease.ownerDeviceId !== ownerDeviceId)) {
+ throw new Error('REMOTE_AGENT_INVALID');
+ }
+ const scope = providerShareOwnerKey();
+ const mark = Symbol();
+ pending.set(key, { mark, generation: request.generation, ownerDeviceId,
+ cleanupEpoch: request.cleanupEpoch ?? 0 });
+ let approved: Awaited<ReturnType<typeof check>>;
+ let current = false;
+ try {
+ approved = await check({ shareId: request.shareId, memberId: request.memberId,
+ guestDeviceId: request.guestDeviceId, executorDeviceId: getDeviceId()! });
+ } finally {
+ current = pending.get(key)?.mark === mark;
+ if (current) pending.delete(key);
+ }
+ if (!current || !approved.active || approved.ownerDeviceId !== ownerDeviceId
+ || approved.generation !== request.generation
+ || !approved.expiresAt || approved.expiresAt <= Date.now()
+ || providerShareOwnerKey() !== scope) throw new Error('REMOTE_AGENT_INVALID');
+ // Revalidate after the network round trip; a settings/account change cannot
+ // turn an old response into a fresh local guest permission.
+ const currentSettings = readDeviceLinkSettings();
+ if (!currentSettings.remoteControlEnabled || currentSettings.revokedControllers?.includes(ownerDeviceId)
+ || !isRemoteProviderInvocationAllowed(request.providerId)) throw new Error('REMOTE_AGENT_UNAVAILABLE');
+ const next = leases.get(peer) ?? new Map<string, Lease>();
+ if ([...next.values()].some((lease) => lease.ownerDeviceId !== ownerDeviceId)) {
+ throw new Error('REMOTE_AGENT_INVALID');
+ }
+ if (!next.has(request.sessionId) && [...leases.values()].reduce((sum, entries) => sum + entries.size, 0) >= MAX_LEASES) {
+ throw new Error('REMOTE_AGENT_UNAVAILABLE');
+ }
+ const duration = Math.min(LEASE_MS, approved.expiresAt - Date.now());
+ // A fresh task lease supersedes any accounting-only authority for this task.
+ receiptOnlyAuthorities.delete(key);
+ next.set(request.sessionId, {
+ ownerScope: scope, ownerDeviceId,
+ access: { shareId: request.shareId, memberId: request.memberId, providerId: request.providerId },
+ model: request.model, generation: request.generation,
+ cleanupEpoch: request.cleanupEpoch ?? 0,
+ wallUntil: Date.now() + duration, monoUntil: performance.now() + duration,
+ nonce: randomUUID(),
+ });
+ leases.set(peer, next);
+ blockedPeers.delete(peer);
+ return false;
+}
+
+function guestBlocked(peer: string): boolean {
+ const blocked = blockedPeers.get(peer);
+ if (!blocked) return false;
+ if (blocked.ownerScope === providerShareOwnerKey()) return true;
+ blockedPeers.delete(peer);
+ return false;
+}
+
+/** Periodic server recheck catches share revocation even if O restarted and lost its in-memory routing state. */
+export function delegatedProviderShareLeases(): Array<{ peer: string; sessionId: string; lease: Lease }> {
+ prune();
+ return [...leases].flatMap(([peer, tasks]) => [...tasks].map(([sessionId, lease]) => ({ peer, sessionId, lease })));
+}
+
+export function invalidateProviderShareDelegation(peer: string, sessionId: string, nonce: string): void {
+ const tasks = leases.get(peer);
+ const lease = tasks?.get(sessionId);
+ if (!tasks || lease?.nonce !== nonce) return;
+ retainReceiptAuthority(peer, sessionId, lease);
+ tasks.delete(sessionId);
+ if (!tasks.size) leases.delete(peer);
+}
+
+export function delegatedProviderShareGuestAccess(controller: string): Access | null {
+ prune();
+ for (const lease of leases.get(controller)?.values() ?? []) {
+ if (leaseAllowed(lease)) return lease.access;
+ }
+ return null;
+}
+
+/** A delegated provider belongs to one task, even when the same guest uses another local provider concurrently. */
+export function delegatedProviderShareTaskAccess(controller: string, sessionId: string): Access | null {
+ return validTask(controller, sessionId)?.access ?? null;
+}
+
+export function delegatedProviderShareModelAllowed(controller: string, model: string, sessionId?: string): boolean {
+ return !guestBlocked(controller) && sessionId !== undefined
+ && validTask(controller, sessionId)?.model === model;
+}
+
+export function delegatedProviderShareSessionAllowed(controller: string, sessionId: string): boolean {
+ return !guestBlocked(controller) && validTask(controller, sessionId) !== null;
+}
+
+export function delegatedProviderShareOwnerDevice(controller: string, sessionId: string): string | null {
+ return validTask(controller, sessionId)?.ownerDeviceId ?? null;
+}
+
+export function delegatedProviderShareReceiptAuthority(controller: string, sessionId: string):
+ { ownerDeviceId: string; generation: string } | null {
+ // Accounting a finished turn is independent of whether another turn could
+ // start now; prune still enforces expiry and the current account scope.
+ prune();
+ const lease = leases.get(controller)?.get(sessionId);
+ if (lease) return { ownerDeviceId: lease.ownerDeviceId, generation: lease.generation };
+ const expired = receiptOnlyAuthorities.get(receiptKey(controller, sessionId));
+ return expired ? { ownerDeviceId: expired.ownerDeviceId, generation: expired.generation } : null;
+}
+
+/** An authenticated O's deletion invalidates every old task for exactly this direct guest. */
+export function revokeDelegatedProviderShareGuest(ownerDeviceId: string, peer: string,
+ forgetEpoch: number, confirmedOwnership = false): boolean {
+ if (!isProviderSharePeer(peer)) throw new Error('REMOTE_AGENT_INVALID');
+ const scope = providerShareOwnerKey();
+ let matched = false;
+ const tasks = leases.get(peer);
+ const prefix = `[${JSON.stringify(peer)},`;
+ // A new server-checked grant can be installed before runHost has persisted
+ // its higher epoch in the guest index. Never erase that newer task.
+ if ([...(tasks?.values() ?? [])].some((lease) => lease.ownerDeviceId === ownerDeviceId
+ && lease.ownerScope === scope && lease.cleanupEpoch > forgetEpoch)
+ || [...pending].some(([key, grant]) => key.startsWith(prefix)
+ && grant.ownerDeviceId === ownerDeviceId && grant.cleanupEpoch > forgetEpoch)) return false;
+ if (tasks) {
+ for (const [sessionId, lease] of tasks) {
+ if (lease.ownerDeviceId === ownerDeviceId && lease.ownerScope === scope
+ && lease.cleanupEpoch <= forgetEpoch) {
+ tasks.delete(sessionId);
+ matched = true;
+ }
+ }
+ if (!tasks.size) leases.delete(peer);
+ }
+ for (const [key, grant] of pending) {
+ if (key.startsWith(prefix) && grant.ownerDeviceId === ownerDeviceId
+ && grant.cleanupEpoch <= forgetEpoch) {
+ pending.delete(key);
+ matched = true;
+ }
+ }
+ for (const [key, authority] of receiptOnlyAuthorities) {
+ if (key.startsWith(prefix) && authority.ownerDeviceId === ownerDeviceId
+ && authority.ownerScope === scope) {
+ receiptOnlyAuthorities.delete(key);
+ matched = true;
+ }
+ }
+ if (!matched && !confirmedOwnership) return true;
+ blockedPeers.delete(peer);
+ blockedPeers.set(peer, { ownerScope: scope, ownerDeviceId });
+ while (blockedPeers.size > MAX_BLOCKED_PEERS) blockedPeers.delete(blockedPeers.keys().next().value!);
+ return true;
+}
+
+export function clearProviderShareDelegations(): void {
+ leases.clear(); receiptOnlyAuthorities.clear(); pending.clear(); blockedPeers.clear();
+}
diff --git a/apps/desktop/src/main/device-link/providerShareHost.ts b/apps/desktop/src/main/device-link/providerShareHost.ts
index 4a61ce93ea..79eb89b5da 100644
--- a/apps/desktop/src/main/device-link/providerShareHost.ts
+++ b/apps/desktop/src/main/device-link/providerShareHost.ts
@@ -23,6 +23,7 @@ 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 { delegatedProviderShareGuestAccess } from './providerShareDelegatedAccess.js';
import {
PROVIDER_SHARE_REMOTE_LINK_WINDOW_MS,
readProviderShareApprovalWindows,
@@ -46,6 +47,9 @@ export interface ProviderShareGuestAccess {
}
export interface ProviderShareHostEvents {
+ /** Durable membership fencing and cleanup run before this snapshot admits guests. */
+ prepareSnapshot?(shares: readonly ProviderShareOwned[]): Promise<void>;
+ memberReady?(member: ProviderShareMemberRef & { joinedAt: string }): boolean;
/** 快照变化(管理页刷新)。 */
changed(shares: readonly ProviderShareOwned[]): void;
/**
@@ -99,6 +103,7 @@ interface Runtime {
knownRequests: Set<string>;
reconciled: boolean;
stopped: boolean;
+ blockedMembers: Set<string>;
/** 本机分享:供应商 → 另一台电脑生成的链接的窗口期截止时刻。 */
quietUntil: Map<string, number>;
/** 本机分享:服务端返回 linkId 时,按具体链接归属的窗口期截止时刻。 */
@@ -215,7 +220,7 @@ function schedule(rt: Runtime): void {
(rt.timer as { unref?: () => void }).unref?.();
}
-function applySnapshot(rt: Runtime, next: ProviderShareOwned[]): void {
+function applySnapshot(rt: Runtime, next: ProviderShareOwned[], prepared = false): void {
const previous = rt.shares;
if (JSON.stringify(previous) !== JSON.stringify(next)) accessRevision++;
rt.shares = next;
@@ -225,7 +230,11 @@ function applySnapshot(rt: Runtime, next: ProviderShareOwned[]): void {
for (const share of previous) {
for (const member of share.members) {
const after = next.find((item) => item.shareId === share.shareId)?.members.find((item) => item.memberId === member.memberId);
- if (!after) rt.events.revoked({ shareId: share.shareId, memberId: member.memberId }, true);
+ if (!after || after.joinedAt !== member.joinedAt) {
+ // The durable preparation hook has already queued/purged this incarnation.
+ // Do not launch a second asynchronous purge after admitting the new one.
+ if (!prepared) rt.events.revoked({ shareId: share.shareId, memberId: member.memberId }, true);
+ }
else if (member.status === 'active' && after.status !== 'active') rt.events.revoked({ shareId: share.shareId, memberId: member.memberId }, false);
}
}
@@ -346,6 +355,7 @@ export function startProviderShareHost(events: ProviderShareHostEvents, options:
knownRequests: new Set(),
reconciled: false,
stopped: false,
+ blockedMembers: new Set(),
quietUntil: saved ? new Map(Object.entries(saved.quietUntil)) : retainedQuiet,
quietLinks: saved
? new Map((saved.quietLinks ?? []).map((item) => [`${item.providerId}:${item.linkId}`, item.until]))
@@ -379,7 +389,16 @@ export function refreshProviderShareHost(reason: string): Promise<void> {
const shares = await providerShareApi.listOwned();
if (!current(rt)) return;
const self = getDeviceId();
- applySnapshot(rt, shares.filter((share) => !self || share.hostDeviceId === self));
+ const next = shares.filter((share) => !self || share.hostDeviceId === self);
+ const before = rt.shares;
+ for (const share of before) for (const member of share.members) {
+ const after = next.find((item) => item.shareId === share.shareId)?.members.find((item) => item.memberId === member.memberId);
+ if (!after || after.joinedAt !== member.joinedAt) rt.blockedMembers.add(JSON.stringify([share.shareId, member.memberId]));
+ }
+ await rt.events.prepareSnapshot?.(next);
+ if (!current(rt) || rt.shares !== before) return;
+ applySnapshot(rt, next, !!rt.events.prepareSnapshot);
+ rt.blockedMembers.clear();
if (!rt.reconciled) {
rt.reconciled = true;
rt.events.reconcile(new Map(rt.shares.map((share) => [share.shareId, new Set(share.members.map((member) => member.memberId))])));
@@ -428,6 +447,22 @@ export function getProviderShareHostSnapshot(): readonly ProviderShareOwned[] {
return runtime?.shares ?? [];
}
+/** After S issues a pair grant, verify it did not authorize a newer incarnation
+ * than O's prepared snapshot. A cached snapshot alone cannot close that race. */
+export async function verifyProviderShareMemberGeneration(member: ProviderShareMemberRef & { joinedAt: string }): Promise<void> {
+ const rt = runtime;
+ if (!rt || !current(rt)) throw new Error('Provider share owner changed');
+ const shares = await providerShareApi.listOwned();
+ if (!current(rt)) throw new Error('Provider share owner changed');
+ const saved = shares.find((share) => share.shareId === member.shareId && share.hostDeviceId === getDeviceId())
+ ?.members.find((entry) => entry.memberId === member.memberId);
+ if (!saved || saved.status !== 'active' || saved.joinedAt !== member.joinedAt) {
+ rt.blockedMembers.add(JSON.stringify([member.shareId, member.memberId]));
+ void refreshProviderShareHost('membership-generation');
+ throw new Error('Provider share membership changed during grant');
+ }
+}
+
/** 同账号另一台电脑经管理生成的链接:只将这条链接的申请交给那台弹窗。 */
export async function quietProviderShareRequests(providerId: string, linkId?: string): Promise<void> {
const rt = runtime;
@@ -511,6 +546,7 @@ export type ProviderShareGuestDenial =
| 'share-unknown'
| 'share-on-other-device'
| 'member-not-active'
+ | 'member-cleanup-pending'
| 'remote-control-off'
| 'provider-not-remote';
@@ -529,6 +565,10 @@ function checkGuestAccess(controller: string): GuestAccessCheck {
if (self && share.hostDeviceId !== self) return { denied: 'share-on-other-device' };
const member = share.members.find((item) => item.memberId === peer.memberId);
if (!member || member.status !== 'active') return { denied: 'member-not-active' };
+ if (rt.blockedMembers.has(JSON.stringify([share.shareId, member.memberId]))
+ || rt.events.memberReady?.({ shareId: share.shareId, memberId: member.memberId, joinedAt: member.joinedAt }) === false) {
+ return { denied: 'member-cleanup-pending' };
+ }
if (!readDeviceLinkSettings().remoteControlEnabled) return { denied: 'remote-control-off' };
if (!isRemoteProviderInvocationAllowed(share.providerId)) return { denied: 'provider-not-remote' };
return { access: { shareId: share.shareId, memberId: member.memberId, providerId: share.providerId } };
@@ -539,6 +579,12 @@ function checkGuestAccess(controller: string): GuestAccessCheck {
* 「允许被远程调用」。任一不满足返回 null。
*/
export function providerShareGuestAccess(controller: string): ProviderShareGuestAccess | null {
+ const result = checkGuestAccess(controller);
+ return 'access' in result ? result.access : delegatedProviderShareGuestAccess(controller);
+}
+
+/** An O-only decision must never use the executor's delegated fallback. */
+export function ownedProviderShareGuestAccess(controller: string): ProviderShareGuestAccess | null {
const result = checkGuestAccess(controller);
return 'access' in result ? result.access : null;
}
diff --git a/apps/desktop/src/main/device-link/providerShareRuntime.ts b/apps/desktop/src/main/device-link/providerShareRuntime.ts
index c49a65eb36..9dedbd573f 100644
--- a/apps/desktop/src/main/device-link/providerShareRuntime.ts
+++ b/apps/desktop/src/main/device-link/providerShareRuntime.ts
@@ -20,7 +20,9 @@ import {
PROVIDER_SHARE_NEUTRAL_DEVICE_NAME,
PROVIDER_SHARE_RECEIVED_CATALOGS_CHANNEL,
MAX_FRAME_BYTES,
+ REMOTE_AGENT_CHANNEL,
parseProviderSharePeer,
+ providerShareGuestPeer,
scrubProviderShareLabel,
scrubSharedProviderCatalog,
type InvokeResultPayload,
@@ -78,7 +80,7 @@ import { getDeviceLinkInvokeContext } from './invoke-context.js';
import { tapWindowBroadcast } from './broadcast-tap.js';
import { MAKER_PUSH } from '../maker-ipc/channels.js';
import { broadcast as broadcastLocal } from './index.js';
-import { fetchIdentityCard, providerShareApi, providerShareLinkFor, sha256Hex } from './providerShareApi.js';
+import { fetchIdentityCard, providerShareApi, providerShareLinkFor, providerShareOwnerKey, sha256Hex } from './providerShareApi.js';
import { configureProviderShareApprovalWindows } from './providerShareApprovalWindows.js';
import {
findReceivedShare,
@@ -110,6 +112,7 @@ import {
getProviderShareQuietRequestIds,
getProviderShareWatchedRequests,
markProviderShareHostActive,
+ ownedProviderShareGuestAccess,
providerShareGuestAccess,
providerShareAccessRevision,
providerShareGuestDenial,
@@ -128,7 +131,7 @@ import {
type ProviderShareReshareEvents,
type ProviderShareReshareRecord,
} from './providerShareReshare.js';
-import { getProviderShareUsageStore, providerUsageLocalDay } from './providerShareUsageStore.js';
+import { getProviderShareUsageStore, installProviderShareUsageStore, providerUsageLocalDay } from './providerShareUsageStore.js';
import { readDeviceLinkSettings, readLastKnownDeviceNames } from './settings-store.js';
import { currentProviderPartyUsageStore, type ProviderPartyUsage } from '../usage/providerPartyUsageStore.js';
@@ -141,6 +144,11 @@ type ShareInvoke = (agentDeviceId: string, channel: string, args: unknown[], opt
let broadcastFn: Broadcast | null = null;
let shareInvoke: ShareInvoke | null = null;
let running = false;
+let directForgetTimer: ReturnType<typeof setInterval> | null = null;
+let directForgetWork: Promise<void> | null = null;
+let directForgetAgain = false;
+let directForgetCursor = 0;
+let directForgetEpoch = 0;
const liveNotifications = new Set<Notification>();
function emit(channel: string, payload: unknown): void {
@@ -192,11 +200,70 @@ function format(template: string, values: Record<string, string>): string {
}
function revoke(match: (controller: string) => boolean, purge: boolean): void {
+ if (purge) {
+ void (async () => {
+ const scope = providerShareOwnerKey();
+ const store = getProviderShareUsageStore() ?? installProviderShareUsageStore(app.getPath('userData'));
+ await store.enqueueDirectCleanup(scope, (target) => match(providerShareGuestPeer(
+ target.shareId, target.memberId, target.guestDeviceId,
+ )));
+ await retryDirectForgets();
+ })().catch((error: unknown) => {
+ log.warn('provider share direct guest cleanup could not be queued', { error: String(error) });
+ });
+ }
void revokeProviderShareControllers(match, purge).catch((error) => {
log.warn('provider share revoke failed', { purge, error: error instanceof Error ? error.message : String(error) });
});
}
+/** O's durable deletion queue survives offline M and an O restart. Only an ACK removes a target. */
+function retryDirectForgets(): Promise<void> {
+ if (directForgetWork) {
+ directForgetAgain = true;
+ return directForgetWork;
+ }
+ const invoke = shareInvoke;
+ if (!running || !invoke) return Promise.resolve();
+ const epoch = directForgetEpoch;
+ const work = (async () => {
+ const assertCurrent = captureProviderManagementScope();
+ const scope = providerShareOwnerKey();
+ const store = getProviderShareUsageStore() ?? installProviderShareUsageStore(app.getPath('userData'));
+ const batch = store.listPendingDirectCleanup(scope, 32, directForgetCursor);
+ directForgetCursor += batch.length;
+ for (let index = 0; index < batch.length; index += 4) {
+ await Promise.allSettled(batch.slice(index, index + 4).map(async (target) => {
+ if (!target.pendingId || epoch !== directForgetEpoch || !running) return;
+ try {
+ const result = await invoke(target.executorDeviceId, REMOTE_AGENT_CHANNEL, [{
+ op: 'forget', directGuest: { shareId: target.shareId, memberId: target.memberId,
+ guestDeviceId: target.guestDeviceId, forgetId: target.pendingId,
+ cleanupEpoch: target.cleanupEpoch },
+ }], { preSend: assertCurrent });
+ if (!result.ok) throw new Error(result.error?.code ?? 'remote cleanup failed');
+ assertCurrent();
+ if (epoch !== directForgetEpoch || !running || providerShareOwnerKey() !== scope) return;
+ await store.acknowledgeDirectCleanup(target);
+ } catch (error) {
+ log.warn('provider share direct guest cleanup delivery failed', { error: String(error) });
+ }
+ }));
+ }
+ })().catch((error: unknown) => {
+ log.warn('provider share direct guest cleanup retry failed', { error: String(error) });
+ }).finally(() => {
+ if (directForgetWork !== work) return;
+ directForgetWork = null;
+ if (directForgetAgain) {
+ directForgetAgain = false;
+ void retryDirectForgets();
+ }
+ });
+ directForgetWork = work;
+ return work;
+}
+
/** 转分享记录所属的那台组所在电脑(受邀者对端)。 */
function reshareControllerMatcher(record: ProviderShareResharePeer): (controller: string) => boolean {
return (controller) => {
@@ -260,10 +327,47 @@ export function startProviderShareRuntime(broadcast: Broadcast, options: { invok
invalidateProviderShareGuestPrefsCache();
broadcastFn = broadcast;
shareInvoke = options.invoke ?? null;
+ directForgetEpoch += 1;
+ if (directForgetTimer) clearInterval(directForgetTimer);
+ directForgetTimer = setInterval(() => { void retryDirectForgets(); }, 60_000);
+ (directForgetTimer as { unref?: () => void }).unref?.();
const readInvoke = options.invoke;
running = true;
+ void retryDirectForgets();
setProviderShareReshareEvents(reshareEvents);
startProviderShareHost({
+ async prepareSnapshot(shares) {
+ const assertCurrent = captureProviderManagementScope();
+ const scope = providerShareOwnerKey();
+ const ownerDeviceId = getDeviceId();
+ if (!ownerDeviceId) throw new Error('Provider share owner device is unavailable');
+ const store = getProviderShareUsageStore() ?? installProviderShareUsageStore(app.getPath('userData'));
+ const pending = await store.reconcileMemberGenerations(scope, ownerDeviceId, shares);
+ assertCurrent();
+ // Every changed incarnation is blocked by memberReady until local/relay
+ // cleanup and all durable direct forgets have been acknowledged.
+ for (const member of pending) {
+ try {
+ assertCurrent();
+ await pruneProviderShareReshares((record) => record.shareId === member.shareId && record.memberId === member.memberId);
+ assertCurrent();
+ // Only the installed host can ACK local cleanup after checking its
+ // persisted guest index. A missing handler must leave this fence pending.
+ await revokeProviderShareControllers(providerShareMemberMatcher(member), true);
+ assertCurrent();
+ } catch (error) {
+ log.warn('provider share membership cleanup remains pending', { error: String(error) });
+ }
+ }
+ void retryDirectForgets();
+ },
+ memberReady(member) {
+ const store = getProviderShareUsageStore();
+ const ownerDeviceId = getDeviceId();
+ return !!store && !!ownerDeviceId && store.memberGenerationReady({
+ ownerScope: providerShareOwnerKey(), ownerDeviceId, shareId: member.shareId, memberId: member.memberId,
+ }, member.joinedAt);
+ },
changed() {
emit(PROVIDER_SHARE_IPC.OWNED_CHANGED, null);
},
@@ -329,6 +433,9 @@ export function startProviderShareRuntime(broadcast: Broadcast, options: { invok
export function stopProviderShareRuntime(): void {
invalidateProviderShareGuestPrefsCache();
running = false;
+ directForgetEpoch += 1;
+ if (directForgetTimer) clearInterval(directForgetTimer);
+ directForgetTimer = null;
shareInvoke = null;
setProviderShareReshareEvents(null);
stopProviderShareHost();
@@ -1069,6 +1176,7 @@ export function registerProviderShareIpc(): void {
insights,
insightsCurrent: insights.isCurrent,
guestAccess: providerShareGuestAccess,
+ catalogGuestAccess: ownedProviderShareGuestAccess,
ensureKnown: ensureProviderSharePeerKnown,
hasShares: () => getProviderShareHostSnapshot().length > 0,
denial: providerShareGuestDenial,
diff --git a/apps/desktop/src/main/device-link/providerShareUsageStore.ts b/apps/desktop/src/main/device-link/providerShareUsageStore.ts
index b28ba74e0d..7137edd1f8 100644
--- a/apps/desktop/src/main/device-link/providerShareUsageStore.ts
+++ b/apps/desktop/src/main/device-link/providerShareUsageStore.ts
@@ -5,19 +5,27 @@
* 那台的键)。行的键与合计仍是原来那套,旧版本读到时照常累计合计、原样带着 `byMember` 写回,降级不丢用量;
* 合计比各台之和多出来的部分(加这个字段之前记的、降级期间旧版本记的,或单行分布超容量的)读出来算没区分电脑(null)。
*
- * Agent 在分享者电脑上运行,这里的数据最准,也不经过服务端。文件放在 userData/remote-agent 下,
+ * Agent 在分享者电脑上运行时本机直接记录;委托组内电脑直连时,由执行电脑发送带去重 ID 的用量回执。
+ * 文件放在 userData/remote-agent 下,
* 原子替换写入;分享与成员 id 由服务端生成、全局唯一,查询时只返回当前账号拥有的分享。
* 删除成员后记录保留(管理页不再显示);同一人重新加入时服务端沿用原成员 id,用量接续。
*/
import fs from 'node:fs';
import fsp from 'node:fs/promises';
import path from 'node:path';
+import { randomUUID } from 'node:crypto';
import type { GuestUsageSample } from '../remote-agent/host/guestUsage';
const FILE_VERSION = 1;
const RETAIN_DAYS = 400;
const MAX_ROWS = 20_000;
+const MAX_RECENT_USAGE_IDS = 20_000;
+const MAX_DIRECT_RECEIPT_ROUTES = 20_000;
+const MAX_DIRECT_TASK_LOCATIONS = 20_000;
+const MAX_DIRECT_CLEANUP_TARGETS = 20_000;
+const DIRECT_RECEIPT_GRACE_MS = 30 * 60_000;
+const USAGE_RETRY_DEDUP_MS = DIRECT_RECEIPT_GRACE_MS + 2 * 60_000;
const FLUSH_DELAY_MS = 1_000;
const MEMBER_KEY = /^[A-Za-z0-9_.:-]{1,300}$/;
/** 一行里最多分几台组内电脑(防止损坏的文件无限膨胀)。 */
@@ -38,6 +46,79 @@ export interface ProviderShareUsageRow extends Counters {
byMember?: Record<string, Counters>;
}
+/** Minimal O-issued assignment proof for a delayed, content-free executor receipt. */
+export interface ProviderShareDirectReceiptRoute {
+ ownerScope: string;
+ ownerDeviceId: string;
+ shareId: string;
+ memberId: string;
+ guestDeviceId: string;
+ sessionId: string;
+ executorDeviceId: string;
+ executorProviderId: string;
+ agentKind: string;
+ providerId: string;
+ memberKey: string;
+ model: string;
+ generation: string;
+ expiresAt: number;
+ /** Written before M receives the grant; only committed routes accept usage. */
+ createdAt?: number;
+ committedAt?: number;
+ revokedAt?: number;
+ /** Exact server membership incarnation, never compared with a local clock. */
+ memberJoinedAt?: string;
+}
+
+export interface ProviderShareMemberGeneration {
+ ownerScope: string;
+ ownerDeviceId: string;
+ shareId: string;
+ memberId: string;
+ joinedAt: string;
+ present: boolean;
+ pendingCleanup: boolean;
+ /** Retryable local/legacy relay scopes, saved before runHost may remove its index. */
+ cleanupScopes?: Array<{ controller: string; relay?: string }>;
+}
+
+export type ProviderShareDirectTaskIdentity = Pick<ProviderShareDirectReceiptRoute,
+ 'ownerScope' | 'ownerDeviceId' | 'shareId' | 'memberId' | 'guestDeviceId' | 'sessionId'>;
+
+/**
+ * Durable native-session whereabouts, NOT an execution grant. O must issue a new
+ * short-lived delegation and M must validate it before this location can be used.
+ * generation is only a compare-and-clear fence against late fallback/renewal notices.
+ */
+export interface ProviderShareDirectTaskLocation extends Omit<ProviderShareDirectReceiptRoute,
+ 'expiresAt' | 'createdAt' | 'committedAt' | 'revokedAt'> {
+ committedAt: number;
+}
+
+/** O keeps every M that may retain this guest's history until deletion is acknowledged. */
+export interface ProviderShareDirectCleanupTarget {
+ ownerScope: string;
+ shareId: string;
+ memberId: string;
+ guestDeviceId: string;
+ executorDeviceId: string;
+ /** Monotonic for this guest/executor; an old forget cannot erase a newer grant. */
+ cleanupEpoch: number;
+ pendingId?: string;
+ cleaned?: boolean;
+}
+
+export interface ProviderShareDirectReceipt {
+ shareId: string;
+ memberId: string;
+ guestDeviceId: string;
+ sessionId: string;
+ generation: string;
+ agentKind: string;
+ usageId: string;
+ samples: readonly GuestUsageSample[];
+}
+
export type ProviderShareUsageRange = '7d' | 'month' | 'all';
export interface ProviderShareModelUsage extends Counters {
@@ -150,9 +231,122 @@ function parseRow(value: unknown): ProviderShareUsageRow | null {
return byMember ? { ...rest, byMember } : rest;
}
+function parseDirectReceiptRoute(value: unknown): ProviderShareDirectReceiptRoute | null {
+ if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+ const route = value as Record<string, unknown>;
+ const bounded = (key: string, max: number) => typeof route[key] === 'string'
+ && (route[key] as string).length > 0 && (route[key] as string).length <= max;
+ if (!bounded('ownerScope', 512) || !bounded('ownerDeviceId', 128)
+ || !bounded('shareId', 128) || !bounded('memberId', 128)
+ || !bounded('guestDeviceId', 128) || !bounded('sessionId', 128)
+ || !bounded('executorDeviceId', 128) || !bounded('executorProviderId', 256)
+ || !bounded('agentKind', 64) || !bounded('providerId', 256) || !bounded('model', 512)
+ || typeof route.memberKey !== 'string' || !MEMBER_KEY.test(route.memberKey)
+ || typeof route.generation !== 'string' || !/^[0-9a-f-]{36}$/.test(route.generation)
+ || !Number.isSafeInteger(route.expiresAt) || (route.expiresAt as number) <= 0
+ || (route.createdAt !== undefined && (!Number.isSafeInteger(route.createdAt)
+ || (route.createdAt as number) <= 0))
+ || (route.committedAt !== undefined && (!Number.isSafeInteger(route.committedAt)
+ || (route.committedAt as number) <= 0))
+ || (route.revokedAt !== undefined && (!Number.isSafeInteger(route.revokedAt)
+ || (route.revokedAt as number) <= 0))
+ || (route.memberJoinedAt !== undefined && !bounded('memberJoinedAt', 128))) return null;
+ return {
+ ownerScope: route.ownerScope as string, ownerDeviceId: route.ownerDeviceId as string,
+ shareId: route.shareId as string, memberId: route.memberId as string,
+ guestDeviceId: route.guestDeviceId as string, sessionId: route.sessionId as string,
+ executorDeviceId: route.executorDeviceId as string, executorProviderId: route.executorProviderId as string,
+ agentKind: route.agentKind as string, providerId: route.providerId as string,
+ memberKey: route.memberKey as string, model: route.model as string,
+ generation: route.generation as string, expiresAt: route.expiresAt as number,
+ ...(route.createdAt !== undefined ? { createdAt: route.createdAt as number } : {}),
+ ...(route.committedAt !== undefined ? { committedAt: route.committedAt as number } : {}),
+ ...(route.revokedAt !== undefined ? { revokedAt: route.revokedAt as number } : {}),
+ ...(route.memberJoinedAt !== undefined ? { memberJoinedAt: route.memberJoinedAt as string } : {}),
+ };
+}
+
+const memberGenerationKey = (member: Pick<ProviderShareMemberGeneration,
+ 'ownerScope' | 'ownerDeviceId' | 'shareId' | 'memberId'>) => JSON.stringify([
+ member.ownerScope, member.ownerDeviceId, member.shareId, member.memberId,
+]);
+
+function parseMemberGeneration(value: unknown): ProviderShareMemberGeneration | null {
+ if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+ const row = value as Record<string, unknown>;
+ const bounded = (key: string, max: number) => typeof row[key] === 'string'
+ && (row[key] as string).length > 0 && (row[key] as string).length <= max;
+ if (!bounded('ownerScope', 512) || !bounded('ownerDeviceId', 128) || !bounded('shareId', 128)
+ || !bounded('memberId', 128) || !bounded('joinedAt', 128)
+ || typeof row.present !== 'boolean' || typeof row.pendingCleanup !== 'boolean') return null;
+ const scopes: NonNullable<ProviderShareMemberGeneration['cleanupScopes']> = [];
+ if (row.cleanupScopes !== undefined) {
+ if (!Array.isArray(row.cleanupScopes)) return null;
+ for (const scope of row.cleanupScopes) {
+ if (!scope || typeof scope.controller !== 'string' || !scope.controller || scope.controller.length > 2048
+ || (scope.relay !== undefined && (typeof scope.relay !== 'string' || !scope.relay || scope.relay.length > 2048))) return null;
+ scopes.push({ controller: scope.controller, ...(scope.relay ? { relay: scope.relay } : {}) });
+ }
+ }
+ return { ownerScope: row.ownerScope as string, ownerDeviceId: row.ownerDeviceId as string,
+ shareId: row.shareId as string, memberId: row.memberId as string, joinedAt: row.joinedAt as string,
+ present: row.present, pendingCleanup: row.pendingCleanup,
+ ...(scopes.length ? { cleanupScopes: scopes } : {}) };
+}
+
+const directReceiptRouteKey = (route: ProviderShareDirectReceiptRoute) => JSON.stringify([
+ route.ownerScope, route.ownerDeviceId, route.shareId, route.memberId, route.guestDeviceId,
+ route.sessionId, route.executorDeviceId, route.executorProviderId,
+ route.agentKind, route.providerId, route.memberKey,
+ route.model, route.generation,
+]);
+
+const directTaskLocationKey = (task: ProviderShareDirectTaskIdentity) => JSON.stringify([
+ task.ownerScope, task.ownerDeviceId, task.shareId, task.memberId, task.guestDeviceId, task.sessionId,
+]);
+
+function parseDirectTaskLocation(value: unknown): ProviderShareDirectTaskLocation | null {
+ if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+ // Reuse the bounded identity parser without keeping a lease or revocation state.
+ const route = parseDirectReceiptRoute({ ...value, expiresAt: 1, createdAt: undefined, revokedAt: undefined });
+ if (!route || route.committedAt === undefined) return null;
+ const { expiresAt, createdAt, revokedAt, ...location } = route;
+ void expiresAt; void createdAt; void revokedAt;
+ return { ...location, committedAt: route.committedAt };
+}
+
+const directCleanupKey = (target: ProviderShareDirectCleanupTarget) => JSON.stringify([
+ target.ownerScope, target.shareId, target.memberId, target.guestDeviceId, target.executorDeviceId,
+]);
+
+function parseDirectCleanupTarget(value: unknown): ProviderShareDirectCleanupTarget | null {
+ if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+ const row = value as Record<string, unknown>;
+ const valid = (key: string, max: number) => typeof row[key] === 'string'
+ && (row[key] as string).length > 0 && (row[key] as string).length <= max;
+ if (!valid('ownerScope', 512) || !valid('shareId', 128) || !valid('memberId', 128)
+ || !valid('guestDeviceId', 128) || !valid('executorDeviceId', 128)
+ || (row.cleanupEpoch !== undefined && (!Number.isSafeInteger(row.cleanupEpoch)
+ || (row.cleanupEpoch as number) < 0))
+ || (row.cleaned !== undefined && typeof row.cleaned !== 'boolean')
+ || (row.pendingId !== undefined && (typeof row.pendingId !== 'string'
+ || !/^[0-9a-f-]{36}$/.test(row.pendingId)))) return null;
+ return { ownerScope: row.ownerScope as string, shareId: row.shareId as string,
+ memberId: row.memberId as string, guestDeviceId: row.guestDeviceId as string,
+ executorDeviceId: row.executorDeviceId as string, cleanupEpoch: row.cleanupEpoch as number ?? 0,
+ ...(row.cleaned === true ? { cleaned: true } : {}),
+ ...(typeof row.pendingId === 'string' ? { pendingId: row.pendingId } : {}) };
+}
+
export function createProviderShareUsageStore(filePath: string, options: { now?: () => number } = {}) {
const now = options.now ?? Date.now;
let rows: Map<string, ProviderShareUsageRow> | null = null;
+ const recentUsageIds = new Map<string, number>();
+ const directReceiptRoutes = new Map<string, ProviderShareDirectReceiptRoute>();
+ const directTaskLocations = new Map<string, ProviderShareDirectTaskLocation>();
+ const memberGenerations = new Map<string, ProviderShareMemberGeneration>();
+ const directCleanupTargets = new Map<string, ProviderShareDirectCleanupTarget>();
+ let cleanupPersistenceFailed = false;
let timer: ReturnType<typeof setTimeout> | null = null;
// Missing data on/before this local date can affect a rolling snapshot until it ages out.
let incompleteThroughDay: string | null = null;
@@ -177,24 +371,91 @@ export function createProviderShareUsageStore(filePath: string, options: { now?:
function load(): Map<string, ProviderShareUsageRow> {
if (rows) return rows;
- rows = new Map();
+ // Publish no cache until the entire safety ledger has been read and checked.
+ // A transient read error must remain retryable, never become a new baseline.
+ let parsed: Record<string, unknown>;
try {
- const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8')) as {
- version?: unknown; rows?: unknown; incomplete?: unknown; incompleteThroughDay?: unknown;
- };
- if (parsed.incompleteThroughDay !== undefined) markIncomplete(parsed.incompleteThroughDay, false);
- else if (parsed.incomplete === true) markIncomplete(); // Migrate the old undated marker once.
- if (parsed.version === FILE_VERSION && Array.isArray(parsed.rows)) {
- for (const raw of parsed.rows) {
- const row = parseRow(raw);
- if (row) rows.set(keyOf(row), row);
- else markIncomplete((raw as { day?: unknown } | null)?.day);
- }
- } else markIncomplete();
+ const value: unknown = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+ if (!value || typeof value !== 'object' || Array.isArray(value)
+ || (value as Record<string, unknown>).version !== FILE_VERSION
+ || !Array.isArray((value as Record<string, unknown>).rows)) {
+ throw new Error('Invalid provider share usage ledger');
+ }
+ parsed = value as Record<string, unknown>;
} catch (error) {
- // A missing ledger is empty; unreadable/corrupt data must not become a measured 0%.
- if ((error as NodeJS.ErrnoException).code !== 'ENOENT') markIncomplete();
+ if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+ rows = new Map();
+ return rows;
+ }
+ throw new Error('Provider share usage ledger is unavailable', { cause: error });
+ }
+ const loadedRows = new Map<string, ProviderShareUsageRow>();
+ const readSafetyMap = <T>(field: string, parse: (raw: unknown) => T | null,
+ keyOfValue: (value: T) => string): Map<string, T> => {
+ const values = parsed[field];
+ // Optional fields were absent in earlier valid v1 files. Present but
+ // malformed fields/entries are unreadable safety state, not empty state.
+ if (values === undefined) return new Map();
+ if (!Array.isArray(values)) throw new Error(`Invalid provider share usage ledger: ${field}`);
+ const result = new Map<string, T>();
+ for (const raw of values) {
+ const value = parse(raw);
+ if (!value) throw new Error(`Invalid provider share usage ledger: ${field}`);
+ const key = keyOfValue(value);
+ if (result.has(key)) throw new Error(`Duplicate provider share usage ledger entry: ${field}`);
+ result.set(key, value);
+ }
+ return result;
+ };
+ const loadedMembers = readSafetyMap('memberGenerations', parseMemberGeneration, memberGenerationKey);
+ const loadedUsageIds = readSafetyMap<[string, number]>('recentUsageIds', (raw) => {
+ if (!Array.isArray(raw) || raw.length !== 2 || typeof raw[0] !== 'string'
+ || !/^[0-9a-f-]{36}$/.test(raw[0]) || !Number.isSafeInteger(raw[1]) || raw[1] < 0) return null;
+ return [raw[0], raw[1] as number];
+ }, (entry) => entry[0]);
+ const loadedRoutes = readSafetyMap('directReceiptRoutes', parseDirectReceiptRoute, directReceiptRouteKey);
+ const loadedTargets = readSafetyMap('directCleanupTargets', parseDirectCleanupTarget, directCleanupKey);
+ const loadedLocations = readSafetyMap('directTaskLocations', parseDirectTaskLocation, directTaskLocationKey);
+ // Read oversized valid images in full. Admission limits reject new entries;
+ // slicing here could discard a pending forget or the only old M destination.
+ const legacyRoutes = [...loadedRoutes.values()];
+ for (const source of [...legacyRoutes, ...loadedLocations.values()]) {
+ const target = parseDirectCleanupTarget(source)!;
+ const key = directCleanupKey(target);
+ if (!loadedTargets.has(key)) loadedTargets.set(key, target);
+ }
+ const migrateLocations = parsed.directTaskLocations === undefined;
+ if (migrateLocations) {
+ for (const route of legacyRoutes) {
+ if (route.committedAt === undefined || route.revokedAt !== undefined) continue;
+ const location = parseDirectTaskLocation(route)!;
+ const key = directTaskLocationKey(location);
+ const previous = loadedLocations.get(key);
+ if (!previous || previous.committedAt <= location.committedAt) loadedLocations.set(key, location);
+ }
+ }
+ for (const [key, location] of loadedLocations) {
+ const cleanup = loadedTargets.get(directCleanupKey({ ...location, cleanupEpoch: 0 }));
+ if (cleanup?.pendingId || cleanup?.cleaned) loadedLocations.delete(key);
+ }
+ for (const raw of parsed.rows as unknown[]) {
+ const row = parseRow(raw);
+ if (row) loadedRows.set(keyOf(row), row);
+ else markIncomplete((raw as { day?: unknown } | null)?.day);
}
+ if (parsed.incompleteThroughDay !== undefined) markIncomplete(parsed.incompleteThroughDay, false);
+ else if (parsed.incomplete === true) markIncomplete();
+ // All parsing/migration succeeded; publish the complete snapshot together.
+ for (const [key, member] of loadedMembers) memberGenerations.set(key, member);
+ for (const [key, entry] of loadedUsageIds) recentUsageIds.set(key, entry[1]);
+ for (const [key, route] of loadedRoutes) {
+ if (route.expiresAt + DIRECT_RECEIPT_GRACE_MS > now()) directReceiptRoutes.set(key, route);
+ }
+ for (const [key, target] of loadedTargets) directCleanupTargets.set(key, target);
+ for (const [key, location] of loadedLocations) directTaskLocations.set(key, location);
+ rows = loadedRows;
+ // Explicit emptiness prevents a cleared location from being remigrated.
+ if (migrateLocations) scheduleFlush();
return rows;
}
@@ -206,17 +467,34 @@ export function createProviderShareUsageStore(filePath: string, options: { now?:
for (const [key] of oldest.slice(0, map.size - MAX_ROWS)) map.delete(key);
}
- async function writeNow(): Promise<void> {
+ async function writeNow(commit?: { route: ProviderShareDirectReceiptRoute; location: ProviderShareDirectTaskLocation }): Promise<void> {
const map = load();
+ if (timer) {
+ clearTimeout(timer);
+ timer = null;
+ }
prune(map);
if (incompleteThroughDay && incompleteThroughDay < providerShareUsageRangeStart('7d', now())!) incompleteThroughDay = null;
- const body = JSON.stringify({ version: FILE_VERSION, rows: [...map.values()],
+ for (const [id, at] of recentUsageIds) if (at < now() - USAGE_RETRY_DEDUP_MS) recentUsageIds.delete(id);
+ for (const [key, route] of directReceiptRoutes) {
+ if (route.expiresAt + DIRECT_RECEIPT_GRACE_MS <= now()) directReceiptRoutes.delete(key);
+ }
+ // A committing location is staged only in the disk image. Synchronous lookups
+ // and receipts cannot observe it until the atomic replacement has succeeded.
+ const receiptRoutes = commit
+ ? new Map(directReceiptRoutes).set(directReceiptRouteKey(commit.route), commit.route) : directReceiptRoutes;
+ const taskLocations = commit
+ ? new Map(directTaskLocations).set(directTaskLocationKey(commit.location), commit.location) : directTaskLocations;
+ const body = JSON.stringify({ version: FILE_VERSION, rows: [...map.values()], recentUsageIds: [...recentUsageIds],
+ directReceiptRoutes: [...receiptRoutes.values()], directCleanupTargets: [...directCleanupTargets.values()],
+ directTaskLocations: [...taskLocations.values()], memberGenerations: [...memberGenerations.values()],
...(incompleteThroughDay ? { incomplete: true, incompleteThroughDay } : {}) });
const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
await fsp.mkdir(path.dirname(filePath), { recursive: true });
try {
await fsp.writeFile(tmp, body, { encoding: 'utf8', mode: 0o600 });
await fsp.rename(tmp, filePath);
+ cleanupPersistenceFailed = false;
} finally {
await fsp.rm(tmp, { force: true }).catch(() => undefined);
}
@@ -226,11 +504,85 @@ export function createProviderShareUsageStore(filePath: string, options: { now?:
if (timer) return;
timer = setTimeout(() => {
timer = null;
- writing = writing.then(writeNow).catch(() => undefined);
+ writing = writing.then(() => writeNow()).catch(() => undefined);
}, FLUSH_DELAY_MS);
(timer as { unref?: () => void }).unref?.();
}
+ /** Receipt ACKs and route publication require the same durable ledger image. */
+ async function persistNow(): Promise<void> {
+ if (timer) {
+ clearTimeout(timer);
+ timer = null;
+ }
+ const pending = writing.then(() => writeNow());
+ writing = pending.catch(() => undefined);
+ await pending;
+ }
+
+ /** Include mutation AND rollback in the write queue, so another write cannot
+ * persist a failed commit's tentative route/location before rollback runs. */
+ function serializeMutation<T>(operation: () => Promise<T>): Promise<T> {
+ const pending = writing.then(operation);
+ writing = pending.then(() => undefined, () => undefined);
+ return pending;
+ }
+
+ function clearDirectTaskLocation(task: ProviderShareDirectTaskIdentity, expectedGeneration: string): Promise<boolean> {
+ return serializeMutation(async () => {
+ load();
+ const key = directTaskLocationKey(task);
+ const previous = directTaskLocations.get(key);
+ if (!previous || previous.generation !== expectedGeneration) return false;
+ directTaskLocations.delete(key);
+ try { await writeNow(); }
+ catch (error) { directTaskLocations.set(key, previous); throw error; }
+ return true;
+ });
+ }
+
+ function findDirectTaskLocation(task: ProviderShareDirectTaskIdentity): ProviderShareDirectTaskLocation | null {
+ load();
+ if (!memberGenerationReady(task)) return null;
+ const location = directTaskLocations.get(directTaskLocationKey(task));
+ return location ? { ...location } : null;
+ }
+
+ function memberGenerationReady(member: Pick<ProviderShareMemberGeneration,
+ 'ownerScope' | 'ownerDeviceId' | 'shareId' | 'memberId'>, joinedAt?: string): boolean {
+ load();
+ const saved = memberGenerations.get(memberGenerationKey(member));
+ // Older files have no membership baseline. First authoritative snapshot adopts
+ // it; it cannot reconstruct a deletion that predates this feature's first observation.
+ if (!saved) return joinedAt === undefined;
+ if (!saved.present || saved.pendingCleanup || (joinedAt !== undefined && saved.joinedAt !== joinedAt)) return false;
+ return ![...directCleanupTargets.values()].some((target) => target.ownerScope === member.ownerScope
+ && target.shareId === member.shareId && target.memberId === member.memberId && target.pendingId);
+ }
+
+ function markDirectCleanup(ownerScope: string, match: (target: ProviderShareDirectCleanupTarget) => boolean): boolean {
+ let changed = false;
+ const matched = new Set<string>();
+ for (const [key, target] of directCleanupTargets) {
+ if (target.ownerScope !== ownerScope || !match(target)) continue;
+ matched.add(key);
+ if (target.pendingId || target.cleaned) continue;
+ directCleanupTargets.set(key, { ...target, pendingId: randomUUID() });
+ changed = true;
+ }
+ for (const [key, location] of directTaskLocations) {
+ if (!matched.has(directCleanupKey({ ...location, cleanupEpoch: 0 }))) continue;
+ directTaskLocations.delete(key);
+ changed = true;
+ }
+ for (const [key, route] of directReceiptRoutes) {
+ if (route.revokedAt !== undefined || !matched.has(directCleanupKey({ ...route, cleanupEpoch: 0 }))) continue;
+ directReceiptRoutes.set(key, { ...route, revokedAt: now() });
+ changed = true;
+ }
+ return changed;
+ }
+
return {
/** Same member/provider only, today's local calendar date plus six preceding dates. */
memberTokenSnapshot(shareIds: ReadonlySet<string>, providerId: string, memberId: string, at = now()) {
@@ -238,7 +590,15 @@ export function createProviderShareUsageStore(filePath: string, options: { now?:
const end = localDay(at);
const date = new Date(at);
const totals = new Map<string, number>();
- for (const row of load().values()) {
+ let loaded: Map<string, ProviderShareUsageRow>;
+ try { loaded = load(); }
+ catch {
+ // Usage remains unavailable, and unreadable cleanup/authorization state
+ // must never be replaced with an empty ledger just to recover metering.
+ return { available: false, windowStart: start, windowEnd: end,
+ nextWindowAt: new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1).getTime(), models: [] };
+ }
+ for (const row of loaded.values()) {
if (!shareIds.has(row.shareId) || row.memberId !== memberId || row.providerId !== providerId
|| row.day < start || row.day > end) continue;
totals.set(row.model, (totals.get(row.model) ?? 0) + row.inputTokens + row.outputTokens);
@@ -247,6 +607,264 @@ export function createProviderShareUsageStore(filePath: string, options: { now?:
nextWindowAt: new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1).getTime(),
models: [...totals].map(([model, tokens]) => ({ model, tokens })) };
},
+ memberGenerationReady,
+ /** Persist every observed member, including relay-only members, before admission.
+ * Removal/reapproval is equality of server joinedAt, not client clock ordering. */
+ async reconcileMemberGenerations(ownerScope: string, ownerDeviceId: string,
+ shares: readonly { shareId: string; members: readonly { memberId: string; joinedAt: string }[] }[]): Promise<ProviderShareMemberGeneration[]> {
+ return serializeMutation(async () => {
+ load();
+ const next = new Map<string, ProviderShareMemberGeneration>();
+ for (const share of shares) for (const member of share.members) {
+ const parsed = parseMemberGeneration({ ownerScope, ownerDeviceId, shareId: share.shareId,
+ memberId: member.memberId, joinedAt: member.joinedAt, present: true, pendingCleanup: false });
+ if (!parsed) throw new Error('Invalid provider share membership generation');
+ next.set(memberGenerationKey(parsed), parsed);
+ }
+ const added = [...next.keys()].filter((key) => !memberGenerations.has(key)).length;
+ if (added > 0 && memberGenerations.size + added > MAX_DIRECT_TASK_LOCATIONS) {
+ throw new Error('Provider share membership ledger is full');
+ }
+ let changed = false;
+ for (const [key, previous] of memberGenerations) {
+ if (previous.ownerScope !== ownerScope || previous.ownerDeviceId !== ownerDeviceId) continue;
+ const incoming = next.get(key);
+ if ((!incoming && previous.present) || (incoming && (!previous.present || previous.joinedAt !== incoming.joinedAt))) {
+ memberGenerations.set(key, { ...previous, ...(incoming ? { joinedAt: incoming.joinedAt } : {}),
+ present: !!incoming, pendingCleanup: true });
+ markDirectCleanup(ownerScope, (target) => target.shareId === previous.shareId && target.memberId === previous.memberId);
+ changed = true;
+ }
+ next.delete(key);
+ }
+ for (const [key, member] of next) { memberGenerations.set(key, member); changed = true; }
+ if (changed || cleanupPersistenceFailed) {
+ try { await writeNow(); }
+ catch (error) { cleanupPersistenceFailed = true; throw error; }
+ }
+ return this.listPendingMemberCleanup(ownerScope, ownerDeviceId);
+ });
+ },
+ listPendingMemberCleanup(ownerScope: string, ownerDeviceId: string): ProviderShareMemberGeneration[] {
+ load();
+ return [...memberGenerations.values()].filter((member) => member.ownerScope === ownerScope
+ && member.ownerDeviceId === ownerDeviceId && member.pendingCleanup)
+ .map((member) => ({ ...member, ...(member.cleanupScopes ? { cleanupScopes: member.cleanupScopes.map((scope) => ({ ...scope })) } : {}) }));
+ },
+ async rememberMemberCleanupScopes(member: ProviderShareMemberGeneration,
+ scopes: NonNullable<ProviderShareMemberGeneration['cleanupScopes']>): Promise<void> {
+ return serializeMutation(async () => {
+ load();
+ const key = memberGenerationKey(member);
+ const current = memberGenerations.get(key);
+ if (!current?.pendingCleanup || current.joinedAt !== member.joinedAt || current.present !== member.present) {
+ throw new Error('Provider share membership changed during cleanup');
+ }
+ const combined = [...new Map([...(current.cleanupScopes ?? []), ...scopes].map((scope) =>
+ [JSON.stringify([scope.controller, scope.relay]), scope])).values()];
+ const updated = parseMemberGeneration({ ...current, cleanupScopes: combined });
+ if (!updated) throw new Error('Invalid provider share cleanup scope');
+ memberGenerations.set(key, updated);
+ try { await writeNow(); }
+ catch (error) { cleanupPersistenceFailed = true; throw error; }
+ });
+ },
+ async acknowledgeMemberCleanup(member: ProviderShareMemberGeneration): Promise<void> {
+ return serializeMutation(async () => {
+ load();
+ const key = memberGenerationKey(member);
+ const current = memberGenerations.get(key);
+ if (!current?.pendingCleanup || current.joinedAt !== member.joinedAt || current.present !== member.present) return;
+ const updated = { ...current, pendingCleanup: false, cleanupScopes: undefined };
+ memberGenerations.set(key, updated);
+ try { await writeNow(); }
+ catch (error) { memberGenerations.set(key, current); throw error; }
+ });
+ },
+ /** Exact scoped lookup; returning a location never authorizes resume/fork/image access. */
+ getDirectTaskLocation(ownerScope: string, ownerDeviceId: string, shareId: string,
+ memberId: string, guestDeviceId: string, sessionId: string): ProviderShareDirectTaskLocation | null {
+ return findDirectTaskLocation({ ownerScope, ownerDeviceId, shareId, memberId, guestDeviceId, sessionId });
+ },
+ /** Object-identity form of getDirectTaskLocation for callers already holding the complete scope. */
+ findDirectTaskLocation,
+ /** Explicit task removal; stale generations cannot erase a newer assignment. */
+ clearDirectTaskLocation,
+ /** Call after accepting a move to the legacy relay path, not when merely revoking a lease. */
+ markDirectTaskRelayed: clearDirectTaskLocation,
+ /** Mark deleted members durably before attempting O→M cleanup. Repeats keep the same pending ID. */
+ async enqueueDirectCleanup(ownerScope: string,
+ match: (target: ProviderShareDirectCleanupTarget) => boolean): Promise<void> {
+ return serializeMutation(async () => {
+ load();
+ const changed = markDirectCleanup(ownerScope, match);
+ if (changed || cleanupPersistenceFailed) {
+ try { await writeNow(); }
+ catch (error) { cleanupPersistenceFailed = true; throw error; }
+ }
+ });
+ },
+ pendingDirectCleanupFor(ownerScope: string, target: Pick<ProviderShareDirectCleanupTarget,
+ 'shareId' | 'memberId' | 'guestDeviceId' | 'executorDeviceId'>):
+ (ProviderShareDirectCleanupTarget & { pendingId: string }) | null {
+ load();
+ const row = directCleanupTargets.get(directCleanupKey({ ...target, ownerScope, cleanupEpoch: 0 }));
+ return row?.pendingId ? { ...row, pendingId: row.pendingId } : null;
+ },
+ listPendingDirectCleanup(ownerScope: string, limit = 32, offset = 0): ProviderShareDirectCleanupTarget[] {
+ load();
+ const pending = [...directCleanupTargets.values()]
+ .filter((target) => target.ownerScope === ownerScope && target.pendingId);
+ return Array.from({ length: Math.min(pending.length, Math.max(0, Math.min(32, limit))) }, (_, index) =>
+ ({ ...pending[(offset + index) % pending.length]! }));
+ },
+ async acknowledgeDirectCleanup(target: ProviderShareDirectCleanupTarget): Promise<void> {
+ return serializeMutation(async () => {
+ load();
+ const key = directCleanupKey(target);
+ const current = directCleanupTargets.get(key);
+ if (!current?.pendingId || current.pendingId !== target.pendingId) return;
+ const updated = { ...current, pendingId: undefined, cleaned: true };
+ directCleanupTargets.set(key, updated);
+ try { await writeNow(); }
+ catch (error) {
+ if (directCleanupTargets.get(key) === updated) directCleanupTargets.set(key, current);
+ throw error;
+ }
+ });
+ },
+ /** Active assignments only; delayed receipt acceptance uses the independent grace window. */
+ listActiveDirectReceiptRoutes(ownerScope: string): ProviderShareDirectReceiptRoute[] {
+ load();
+ return [...directReceiptRoutes.values()]
+ .filter((route) => route.ownerScope === ownerScope && route.expiresAt > now()
+ && route.revokedAt === undefined)
+ .map((route) => ({ ...route }));
+ },
+ async markDirectReceiptRouteRevoked(input: ProviderShareDirectReceiptRoute): Promise<void> {
+ return serializeMutation(async () => {
+ load();
+ const route = directReceiptRoutes.get(directReceiptRouteKey(input));
+ if (!route || route.revokedAt !== undefined) return;
+ const key = directReceiptRouteKey(route);
+ const updated = { ...route, revokedAt: now() };
+ directReceiptRoutes.set(key, updated);
+ try { await writeNow(); }
+ catch (error) {
+ if (directReceiptRoutes.get(key) === updated) directReceiptRoutes.set(key, route);
+ throw error;
+ }
+ });
+ },
+ async registerDirectReceiptRoute(input: ProviderShareDirectReceiptRoute): Promise<number> {
+ return serializeMutation(async () => {
+ const route = parseDirectReceiptRoute(input);
+ if (!route || route.expiresAt <= now()) throw new Error('Invalid direct receipt route');
+ load();
+ if (!memberGenerationReady(route, route.memberJoinedAt)) throw new Error('Provider share member cleanup is pending');
+ if (!directTaskLocations.has(directTaskLocationKey(route)) && directTaskLocations.size >= MAX_DIRECT_TASK_LOCATIONS) {
+ throw new Error('Direct task location ledger is full');
+ }
+ for (const [key, saved] of directReceiptRoutes) {
+ if (saved.expiresAt + DIRECT_RECEIPT_GRACE_MS <= now()) directReceiptRoutes.delete(key);
+ }
+ const key = directReceiptRouteKey(route);
+ if (directReceiptRoutes.get(key)?.revokedAt !== undefined) {
+ throw new Error('Direct receipt route was revoked');
+ }
+ if (!directReceiptRoutes.has(key) && directReceiptRoutes.size >= MAX_DIRECT_RECEIPT_ROUTES) {
+ throw new Error('Direct receipt route ledger is full');
+ }
+ const cleanupTarget = parseDirectCleanupTarget(route)!;
+ const cleanupKey = directCleanupKey(cleanupTarget);
+ const previousTarget = directCleanupTargets.get(cleanupKey);
+ if (!previousTarget && directCleanupTargets.size >= MAX_DIRECT_CLEANUP_TARGETS) {
+ throw new Error('Direct guest cleanup ledger is full');
+ }
+ if (previousTarget?.pendingId) throw new Error('Direct guest cleanup is still pending');
+ if (cleanupPersistenceFailed) await writeNow();
+ const previousRoute = directReceiptRoutes.get(key);
+ const cleanupEpoch = (previousTarget?.cleanupEpoch ?? 0) + 1;
+ const nextRoute = { ...route, createdAt: previousRoute?.createdAt ?? now(), committedAt: previousRoute?.committedAt };
+ const nextTarget = { ...cleanupTarget, cleanupEpoch };
+ directReceiptRoutes.set(key, nextRoute);
+ directCleanupTargets.set(cleanupKey, nextTarget);
+ try { await writeNow(); }
+ catch (error) {
+ if (directReceiptRoutes.get(key) === nextRoute) {
+ if (previousRoute) directReceiptRoutes.set(key, previousRoute);
+ else directReceiptRoutes.delete(key);
+ }
+ if (directCleanupTargets.get(cleanupKey) === nextTarget) {
+ if (previousTarget) directCleanupTargets.set(cleanupKey, previousTarget);
+ else directCleanupTargets.delete(cleanupKey);
+ }
+ throw error;
+ }
+ return cleanupEpoch;
+ });
+ },
+ async commitDirectReceiptRoute(input: ProviderShareDirectReceiptRoute): Promise<void> {
+ return serializeMutation(async () => {
+ load();
+ const key = directReceiptRouteKey(input);
+ const route = directReceiptRoutes.get(key);
+ if (!route || route.revokedAt !== undefined || route.expiresAt <= now()) {
+ throw new Error('Direct receipt route cannot be committed');
+ }
+ if (!memberGenerationReady(route, route.memberJoinedAt)) throw new Error('Provider share member cleanup is pending');
+ // Retried commits cannot overwrite a newer model, or resurrect a location
+ // explicitly cleared when G moved to the relay path.
+ if (route.committedAt !== undefined) return;
+ const locationKey = directTaskLocationKey(route);
+ const previousLocation = directTaskLocations.get(locationKey);
+ if (!previousLocation && directTaskLocations.size >= MAX_DIRECT_TASK_LOCATIONS) {
+ throw new Error('Direct task location ledger is full');
+ }
+ const updated = { ...route, committedAt: now() };
+ const location = parseDirectTaskLocation(updated)!;
+ await writeNow({ route: updated, location });
+ directReceiptRoutes.set(key, updated);
+ directTaskLocations.set(locationKey, location);
+ });
+ },
+ async recordDirectReceipt(ownerScope: string, ownerDeviceId: string, executorDeviceId: string,
+ receipt: ProviderShareDirectReceipt): Promise<boolean> {
+ load();
+ const route = [...directReceiptRoutes.values()].find((saved) => saved.ownerScope === ownerScope
+ && saved.ownerDeviceId === ownerDeviceId && saved.executorDeviceId === executorDeviceId
+ && saved.shareId === receipt.shareId && saved.memberId === receipt.memberId
+ && saved.guestDeviceId === receipt.guestDeviceId && saved.sessionId === receipt.sessionId
+ && saved.generation === receipt.generation
+ && saved.agentKind === receipt.agentKind
+ && saved.committedAt !== undefined
+ && saved.expiresAt + DIRECT_RECEIPT_GRACE_MS > now());
+ if (!route || !/^[0-9a-f-]{36}$/.test(receipt.usageId)
+ || receipt.samples.length === 0 || receipt.samples.length > 64
+ || receipt.samples.some((sample) => !sample.model || sample.model.length > 512
+ || COUNTERS.some((field) => !isCount(sample[field]) || sample[field] > 1e15))) {
+ throw new Error('REMOTE_AGENT_INVALID');
+ }
+ const recorded = this.recordOnce(receipt.usageId, route.shareId, route.memberId, {
+ kind: route.agentKind, providerId: route.providerId, memberKey: route.memberKey,
+ samples: receipt.samples,
+ });
+ await persistNow();
+ return recorded;
+ },
+ /** Idempotent report from an assigned executor; IDs survive a host restart. */
+ recordOnce(usageId: string, shareId: string, memberId: string,
+ usage: { kind: string; providerId: string | null; memberKey: string; samples: readonly GuestUsageSample[] }): boolean {
+ load();
+ if (recentUsageIds.has(usageId)) return false;
+ for (const [id, at] of recentUsageIds) if (at < now() - USAGE_RETRY_DEDUP_MS) recentUsageIds.delete(id);
+ // Never evict an ID that M can still retry: reject new receipts until
+ // space returns, rather than silently counting a replay twice.
+ if (recentUsageIds.size >= MAX_RECENT_USAGE_IDS) throw new Error('REMOTE_AGENT_BUSY');
+ this.record(shareId, memberId, usage);
+ recentUsageIds.set(usageId, now());
+ return true;
+ },
/** memberKey:这一轮在哪台组内电脑运行(本机为 `local`)。 */
record(
shareId: string,
@@ -361,10 +979,11 @@ export function createProviderShareUsageStore(filePath: string, options: { now?:
},
async flush(): Promise<void> {
+ load();
if (timer) {
clearTimeout(timer);
timer = null;
- writing = writing.then(writeNow).catch(() => undefined);
+ writing = writing.then(() => writeNow()).catch(() => undefined);
}
await writing;
},
diff --git a/apps/desktop/src/main/device-link/remoteModelAccess.ts b/apps/desktop/src/main/device-link/remoteModelAccess.ts
index de69dae675..4ba32fc4a4 100644
--- a/apps/desktop/src/main/device-link/remoteModelAccess.ts
+++ b/apps/desktop/src/main/device-link/remoteModelAccess.ts
@@ -14,6 +14,8 @@ const selection = (value: unknown): string[] => isRemoteModelSelection(value) &&
/** Remote-only authorization; local model preferences and supplier credentials never pass through this store. */
export function createRemoteModelAccessStore(options: { filePath(): string; scopeKey(): string }) {
+ const listeners = new Set<() => void>();
+ const log = createLogger('remote-model-access');
const store = createOverrideSettingsFile<Settings>({
...options,
defaults: () => {
@@ -35,7 +37,7 @@ export function createRemoteModelAccessStore(options: { filePath(): string; scop
}];
})) };
},
- log: createLogger('remote-model-access'), label: 'remote-model-access',
+ log, label: 'remote-model-access',
maxBytes: 4 * 1024 * 1024, preserveUnreadableFile: true,
logLoadedValue: false, logReadErrorDetails: false,
});
@@ -65,6 +67,15 @@ export function createRemoteModelAccessStore(options: { filePath(): string; scop
return Boolean(model) && (providerModels === null || providerModels.includes(model)) && (models === null || models.includes(model));
} catch { return false; }
},
+ /** Offline direct leases cannot enforce O's live per-member usage budget. */
+ allowsDelegatedExecution(providerId: string, model: string, memberId: string): boolean {
+ try {
+ const { models, providerModels, memberBudget } = read(providerId, memberId);
+ return Boolean(model) && (providerModels === null || providerModels.includes(model))
+ && (models === null || models.includes(model))
+ && !(memberBudget?.enabled && memberBudget.rules.length > 0);
+ } catch { return false; }
+ },
async set(providerId: string, models: RemoteModelSelection, memberId: string | undefined, assertCurrent: () => void, memberBudget?: ProviderShareMemberBudget | null) {
if (!isRemoteModelSelection(models)) throwIpcError('INVALID_PARAMS', 'Invalid remote model selection');
if (memberBudget !== undefined && (!memberId || (memberBudget !== null && !isProviderShareMemberBudget(memberBudget))))
@@ -92,7 +103,16 @@ export function createRemoteModelAccessStore(options: { filePath(): string; scop
return { providers };
});
assertCurrent();
- return read(providerId, memberId);
+ const updated = read(providerId, memberId);
+ for (const listener of listeners) {
+ try { listener(); }
+ catch (error) { log.warn('remote model access listener failed', { error: String(error) }); }
+ }
+ return updated;
+ },
+ subscribe(listener: () => void): () => void {
+ listeners.add(listener);
+ return () => { listeners.delete(listener); };
},
};
}
diff --git a/apps/desktop/src/main/device-link/selfHostedRelayRuntime.ts b/apps/desktop/src/main/device-link/selfHostedRelayRuntime.ts
index 153936ace0..ae6c741a6d 100644
--- a/apps/desktop/src/main/device-link/selfHostedRelayRuntime.ts
+++ b/apps/desktop/src/main/device-link/selfHostedRelayRuntime.ts
@@ -247,7 +247,12 @@ async function prepareHostData(dataDir: string, config: RelayConfig): Promise<st
if (existingId && readRelaySecrets(existingId) && fs.existsSync(stateFile)) return existingId;
if (!authManager.getCurrentUserId()) throw new Error('NOT_SIGNED_IN');
fs.rmSync(dataDir, { recursive: true, force: true });
- if (existingId) deleteRelaySecrets(existingId);
+ if (existingId) {
+ const wasActive = readRelayConfig().active?.relayId === existingId;
+ deleteRelaySecrets(existingId);
+ // Missing secrets switch the routing source to official immediately.
+ if (wasActive) restartDeviceLinkForRelayChange();
+ }
const relayId = randomUUID();
const secrets = createOwnerSecrets(relayId);
await initializeRelay({ dataDir, ...ownerInitArgs(relayId, secrets, deviceName().slice(0, 64) || 'Cindy') });
@@ -503,6 +508,8 @@ async function leaveMemberRelay(): Promise<void> {
}
assertOwner();
deleteRelaySecrets(relay.relayId);
+ // Retire the old connection before the caller resumes on the official route.
+ restartDeviceLinkForRelayChange();
}
/** 切换到另一个中转前收尾:成员退出;本机中转停掉(不通知成员停用,切回时还能接着用)。 */
@@ -530,6 +537,8 @@ async function enableHost(command: Extract<SelfHostedRelayCommand, { type: 'enab
host: { ...previous.host, enabled: true, port: command.port, listenAll: command.listenAll, externalUrl: command.externalUrl },
};
writeRelayConfig(config);
+ // Clearing an active route must retire its connection before host startup yields.
+ if (previous.active) restartDeviceLinkForRelayChange();
await startHost(config);
assertOwner();
const relayId = readRelayConfig().host.relayId;
@@ -553,10 +562,11 @@ async function enableHost(command: Extract<SelfHostedRelayCommand, { type: 'enab
ownerPublicKey: relayPublicKeyOf(crypto, secrets.seed)!,
},
});
+ // Publish the route and synchronously retire the old token/connection in one turn.
+ restartDeviceLinkForRelayChange();
// 中转所在电脑一休眠,所有设备都会断开:开启时顺带打开「保持唤醒」。
if (!readDeviceLinkSettings().keepAwake) await setKeepAwakeEnabled(true).catch(() => undefined);
assertOwner();
- restartDeviceLinkForRelayChange();
return { state: getState() };
}
diff --git a/apps/desktop/src/main/device-link/settings-store.ts b/apps/desktop/src/main/device-link/settings-store.ts
index 1f7ec624c6..325a8448fd 100644
--- a/apps/desktop/src/main/device-link/settings-store.ts
+++ b/apps/desktop/src/main/device-link/settings-store.ts
@@ -205,6 +205,11 @@ async function acquireWriteLock(file: string): Promise<(() => void) | null> {
/** 进程内写序列化:异步 acquire 之间可能交错,同进程写者先排队再抢跨进程锁 */
let writeChain: Promise<unknown> = Promise.resolve();
+const settingsChangeListeners = new Set<(key: keyof DeviceLinkSettings) => void>();
+export function onDeviceLinkSettingChanged(listener: (key: keyof DeviceLinkSettings) => void): () => void {
+ settingsChangeListeners.add(listener);
+ return () => { settingsChangeListeners.delete(listener); };
+}
/**
* 锁内单次写:取盘上最新基线 → 在最新值上跑 updater → 整文件写回。
@@ -263,6 +268,10 @@ export function updateDeviceLinkSetting<K extends keyof DeviceLinkSettings>(
unlock();
}
log.info('device-link setting written', { key, value: written });
+ for (const listener of settingsChangeListeners) {
+ try { listener(key); }
+ catch (error) { log.warn('device-link setting listener failed', { error: String(error) }); }
+ }
return written;
});
writeChain = task.catch(() => undefined); // 队列不因单次失败断链
diff --git a/apps/desktop/src/main/lifecycle.ts b/apps/desktop/src/main/lifecycle.ts
index ddf472f8ca..77a7cc05aa 100644
--- a/apps/desktop/src/main/lifecycle.ts
+++ b/apps/desktop/src/main/lifecycle.ts
@@ -53,6 +53,7 @@ import { isResourceUsageWebContentsId } from './resource-usage-window/registry.j
import { isRemoteDesktopViewer } from './remote-desktop-viewer/registry.js';
import { isRsbWindowWebContentsId } from './right-sidebar-window/registry.js';
import { isReviewArtifactConfirmWebContentsId } from './reviewer/reviewArtifactConfirmWindowRegistry.js';
+import { isCaptureWindowWebContents } from './remote-desktop/captureWindowRegistry.js';
/**
* 瞬时网络错误的 wire payload (main → renderer)。code 永远存在 (Node 的 ErrnoException
@@ -639,7 +640,14 @@ export function installQuitHandler(timeoutMs = 2000): void {
// 例外 3:RSB popup 虽然是 `window` 类型,但它是局部网页 surface;崩溃时由
// native popup manager 回收并让对应 tab 展示恢复态,不能拖垮主窗口。
// 例外 4:资源用量窗是预热复用的辅助 renderer;Controller 会有限重建,崩溃不影响主界面。
+ // 隐藏传输窗口也有自己的失败清理;其 renderer 崩溃只撤下对应传输,不能关闭 device-link。
app.on('render-process-gone', (_event, webContents, details) => {
+ if (isCaptureWindowWebContents(webContents)) {
+ log.warn(
+ `capture transport render-process-gone (isolated, no shutdown): reason=${details.reason} exitCode=${details.exitCode}`,
+ );
+ return;
+ }
if (isGhostSandboxWebContentsId(webContents.id)) {
log.warn(
`ghost sandbox render-process-gone (isolated, no shutdown): reason=${details.reason} exitCode=${details.exitCode}`,
diff --git a/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts b/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts
index 1b05289d5e..fc1ecd2ffc 100644
--- a/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts
+++ b/apps/desktop/src/main/localDb/__tests__/orcaTeamStore.test.ts
@@ -3,7 +3,7 @@ import { drizzle } from 'drizzle-orm/better-sqlite3';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { DbClient } from '../client/DbClient.js';
-import { clearCurrentDbClient, setCurrentDbClient } from '../client/current.js';
+import { clearCurrentDbClient, setCurrentDbClient, getCurrentDbClientSnapshot } from '../client/current.js';
import { tx as runInprocTx } from '../worker/opHandlers/tx.js';
import { setSessionRouteLockImplementation } from '../sessionRouteLock.js';
import { setSessionRuntimeCleanup } from '../sessionRuntimeCleanup.js';
@@ -53,6 +53,43 @@ describe('orcaTeamStore', () => {
rawDb = null;
});
+ // F6-B, integration: real SQLite role writes stay in their captured owner.
+ it.each(['owner', 'cancel'] as const)('rejects a stale %s before role mutation', async reason => {
+ const { setSessionOrcaRole } = await import('../orcaTeamStore.js');
+ const client = createTestDbClient(); setCurrentDbClient(client, 'owner-a');
+ await seedOrcaWorkers(client);
+ const owner = getCurrentDbClientSnapshot()!;
+ if (reason === 'owner') setCurrentDbClient(client, 'owner-b');
+ const assertCurrent = () => { if (reason === 'cancel') throw new Error('cancelled attempt'); };
+ const before = await client.queryOne('SELECT orca_role FROM sessions WHERE id = ?', ['lead-session-1']);
+ await expect(setSessionOrcaRole('lead-session-1', 'worker', { owner, assertCurrent })).rejects.toThrow();
+ expect(await client.queryOne('SELECT orca_role FROM sessions WHERE id = ?', ['lead-session-1'])).toEqual(before);
+ expect(h.tapWindowBroadcast).not.toHaveBeenCalled();
+ });
+
+ it('keeps an issued write in its original DB and suppresses its late broadcast', async () => {
+ const { setSessionOrcaRole } = await import('../orcaTeamStore.js');
+ const first = createTestDbClient(); setCurrentDbClient(first, 'owner-a');
+ await seedOrcaWorkers(first);
+ const firstRaw = rawDb!;
+ const owner = getCurrentDbClientSnapshot()!;
+ const second = createTestDbClient();
+ await seedOrcaWorkers(second);
+ try {
+ const before = await second.queryOne('SELECT orca_role FROM sessions WHERE id = ?', ['lead-session-1']);
+ const writing = setSessionOrcaRole('lead-session-1', 'worker', { owner });
+ setCurrentDbClient(second, 'owner-b');
+ await expect(writing).rejects.toThrow('REMOTE_AGENT_EXPIRED');
+ expect(await first.queryOne('SELECT orca_role FROM sessions WHERE id = ?', ['lead-session-1'])).toEqual({ orca_role: 'worker' });
+ expect(await second.queryOne('SELECT orca_role FROM sessions WHERE id = ?', ['lead-session-1'])).toEqual(before);
+ expect(h.tapWindowBroadcast).not.toHaveBeenCalled();
+ expect(h.notifyAgentIslandSessionPatch).not.toHaveBeenCalled();
+ await setSessionOrcaRole('lead-session-1', 'lead');
+ expect(await second.queryOne('SELECT orca_role FROM sessions WHERE id = ?', ['lead-session-1'])).toEqual({ orca_role: 'lead' });
+ expect(h.tapWindowBroadcast).toHaveBeenCalledTimes(1);
+ } finally { firstRaw.close(); }
+ });
+
it.each(['team', 'stranded', 'single'])('rechecks %s archive authority after the existing route lock wait', async action => {
const store = await import('../orcaTeamStore.js');
const client = createTestDbClient();
diff --git a/apps/desktop/src/main/localDb/ipc/__tests__/sessionsUpdate.test.ts b/apps/desktop/src/main/localDb/ipc/__tests__/sessionsUpdate.test.ts
index 8eca57464d..ff795bcdaa 100644
--- a/apps/desktop/src/main/localDb/ipc/__tests__/sessionsUpdate.test.ts
+++ b/apps/desktop/src/main/localDb/ipc/__tests__/sessionsUpdate.test.ts
@@ -1,3 +1,6 @@
+import { registerMakerSessionCreateHandler } from '../../../maker-ipc/sessionCreateHandler';
+import { MAKER_INVOKE } from '../../../maker-ipc/channels';
+import { withSendToSessionLock } from '../../../maker-ipc/sendToSessionLock';
import { setSessionOpeningModelAdmission, type SessionOpenBody } from '../../sessionOpening';
/**
* sessionsUpdate.test.ts — `local-db:sessions:update` handler 集成接线。
@@ -1972,3 +1975,132 @@ it('does not create a renderer task when common model admission fails', async ()
await expect(invokeCreate({ id: 'rejected-open', title: 'Rejected task' })).rejects.toThrow('model unavailable');
expect(h.sqlite!.prepare('SELECT id FROM sessions WHERE id = ?').get('rejected-open')).toBeUndefined();
});
+
+// DB tier, T08b/F6: real IPC and route lock; only bootstrap IO is deferred.
+// Previous tests began after creation, missing the terminal/create lock inversion.
+describe('terminal intent during session creation', () => {
+ function deferred() {
+ let resolve!: () => void;
+ const promise = new Promise<void>(done => { resolve = done; });
+ return { promise, resolve };
+ }
+ function creationFixture() {
+ const holds = new Map<string, ReturnType<typeof deferred>>();
+ const entered: string[] = [];
+ const broadcast = vi.fn();
+ registerMakerSessionCreateHandler({ handle: (name: string, handler: (...args: unknown[]) => unknown) => h.handlers.set(name, handler) } as never, {
+ creationOwner: () => h.client!, withSessionLock: withSendToSessionLock,
+ bootstrapSession: async opts => {
+ const hold = deferred(); holds.set(opts.id!, hold); entered.push(opts.id!);
+ await hold.promise;
+ return { session: { id: opts.id!, agentKind: 'codex', workDir: opts.workingDir, capabilities: {} },
+ didInjectOrcaInstructions: false, didInjectProjectContext: false };
+ },
+ markOrcaRoleIfNeeded: async () => {}, markKnownNonOrcaIfApplicable() {},
+ sendWorkerReadyMessage: vi.fn(), broadcastSessionCreated: broadcast,
+ logCreateSession() {}, warnStderr() {},
+ });
+ setSessionRouteLockImplementation(withSendToSessionLock);
+ return { holds, entered, broadcast,
+ start: (id = 'codex-local') => Promise.resolve(h.handlers.get(MAKER_INVOKE.CREATE_SESSION)!({}, {
+ id, agentKind: 'codex', model: 'm', workspaceKind: 'dialogue', workingDir: '/fixture',
+ })) };
+ }
+ it.each([['update', 'archived'], ['update', 'deleted'], ['patch-meta', 'archived'], ['patch-meta', 'deleted']] as const)('%s commits %s and rejects creation before held ensure finishes', async (surface, status) => {
+ const f = creationFixture(); let failure: unknown;
+ const opening = f.start().catch(error => { failure = error; });
+ await vi.waitFor(() => expect(f.entered).toEqual(['codex-local']), { interval: 1 });
+ const oldHold = f.holds.get('codex-local')!;
+ const terminal = surface === 'update' ? invokeUpdate('codex-local', { status }) : invokePatchMeta('codex-local', { status });
+ try {
+ await vi.waitFor(() => expect(String(failure)).toContain('REMOTE_AGENT_EXPIRED'), { interval: 1, timeout: 100 });
+ await terminal;
+ expect(h.sqlite!.prepare('SELECT status FROM sessions WHERE id=?').get('codex-local')).toEqual({ status });
+ expect(h.runtimeCleanup).toHaveBeenCalledExactlyOnceWith('codex-local');
+ expect(f.broadcast).not.toHaveBeenCalled();
+ } finally { oldHold.resolve(); await Promise.all([opening, terminal]); }
+ expect(f.broadcast).not.toHaveBeenCalled();
+ });
+ it('does not cancel for nonterminal or invalid updates', async () => {
+ const f = creationFixture(); let state = 'pending';
+ const opening = f.start().then(() => { state = 'resolved'; }, () => { state = 'rejected'; });
+ await vi.waitFor(() => expect(f.entered).toHaveLength(1), { interval: 1 });
+ try {
+ await invokeUpdate('codex-local', { title: 'still active' });
+ await expect(invokeUpdate('codex-local', { status: 'archived', notificationsMuted: 'yes' })).rejects.toThrow();
+ await expect(invokeUpdate('codex-local', { status: 'deleted', contextWindowBudget: -1 })).rejects.toThrow();
+ expect(state).toBe('pending');
+ } finally { f.holds.get('codex-local')!.resolve(); await opening; }
+ expect(state).toBe('resolved');
+ });
+ it('rejects stale-owner and protected Bot terminal intent without cancellation', async () => {
+ const f = creationFixture(); let state = 'pending';
+ const opening = f.start('codex-local').then(() => { state = 'resolved'; }, () => { state = 'rejected'; });
+ const bot = f.start('bot-local');
+ await vi.waitFor(() => expect(f.entered).toHaveLength(2), { interval: 1 });
+ try {
+ await expect(invokeUpdate('bot-local', { status: 'archived' })).rejects.toThrow('PRECONDITION_FAILED');
+ h.captureOwnerScope = true; h.ownerCurrent = false;
+ await expect(invokeUpdate('codex-local', { status: 'deleted' })).rejects.toThrow('Session owner changed');
+ expect(state).toBe('pending');
+ } finally {
+ h.ownerCurrent = true; f.holds.get('bot-local')!.resolve(); f.holds.get('codex-local')!.resolve();
+ await Promise.all([opening, bot]);
+ }
+ expect(state).toBe('resolved');
+ });
+ it('does not cancel the prior owner when another account has the same UUID', async () => {
+ const f = creationFixture(); let state = 'pending';
+ const opening = f.start().then(() => { state = 'resolved'; }, () => { state = 'rejected'; });
+ await vi.waitFor(() => expect(f.entered).toHaveLength(1), { interval: 1 });
+ const original = h.client!;
+ h.client = { drizzle: h.db! };
+ let queued!: () => void;
+ const locked = new Promise<void>(resolve => { queued = resolve; });
+ setSessionRouteLockImplementation((id, task) => { queued(); return withSendToSessionLock(id, task); });
+ const terminal = invokeUpdate('codex-local', { status: 'deleted' });
+ try {
+ await locked;
+ expect(state).toBe('pending');
+ } finally {
+ h.client = original; f.holds.get('codex-local')!.resolve();
+ await opening; await terminal;
+ }
+ expect(state).toBe('resolved');
+ });
+ it('late old ensure cannot publish or cancel a newer same-ID creation or sibling', async () => {
+ const f = creationFixture();
+ const old = f.start().catch(error => error);
+ const sibling = f.start('cc-local');
+ await vi.waitFor(() => expect(f.entered).toHaveLength(2), { interval: 1 });
+ const oldHold = f.holds.get('codex-local')!;
+ let archived = false;
+ const terminal = invokeUpdate('codex-local', { status: 'archived' }).then(() => { archived = true; });
+ try {
+ await vi.waitFor(() => expect(archived).toBe(true), { interval: 1, timeout: 100 });
+ expect(String(await old)).toContain('REMOTE_AGENT_EXPIRED');
+ const fresh = f.start();
+ await vi.waitFor(() => expect(f.entered).toHaveLength(3), { interval: 1 });
+ oldHold.resolve(); await Promise.resolve(); await Promise.resolve();
+ expect(f.broadcast).not.toHaveBeenCalled();
+ f.holds.get('codex-local')!.resolve(); f.holds.get('cc-local')!.resolve();
+ await Promise.all([fresh, sibling]);
+ expect(f.broadcast.mock.calls.map(call => call[0]).sort()).toEqual(['cc-local', 'codex-local']);
+ } finally { oldHold.resolve(); for (const hold of f.holds.values()) hold.resolve(); await Promise.all([old, sibling, terminal]); }
+ });
+ it('patch-meta checks authorization before cancelling a held creation', async () => {
+ const f = creationFixture(); let failure: unknown, denied: unknown;
+ const opening = f.start().catch(error => { failure = error; });
+ await vi.waitFor(() => expect(f.entered).toHaveLength(1), { interval: 1 });
+ const terminal = patchSessionMetaInDb('codex-local', { status: 'deleted' }, {
+ beforeWrite: () => { throw new Error('not authorized'); },
+ }).catch(error => { denied = error; });
+ try {
+ await vi.waitFor(() => expect(String(denied)).toContain('not authorized'), { interval: 1, timeout: 100 });
+ expect(failure).toBeUndefined();
+ expect(h.runtimeCleanup).not.toHaveBeenCalled();
+ } finally { f.holds.get('codex-local')!.resolve(); await Promise.all([opening, terminal]); }
+ expect(failure).toBeUndefined();
+ });
+
+});
diff --git a/apps/desktop/src/main/localDb/ipc/sessions.ts b/apps/desktop/src/main/localDb/ipc/sessions.ts
index ec60e4d91f..1bb0e14e1d 100644
--- a/apps/desktop/src/main/localDb/ipc/sessions.ts
+++ b/apps/desktop/src/main/localDb/ipc/sessions.ts
@@ -1,3 +1,4 @@
+import { captureSessionCreationCancellation } from '../sessionRuntimeCleanup.js';
import { removeSessionModelInterface } from '../../maker-host/session-model-interface.js';
import { isEndedWriteSuppressed } from '../sessionActiveTurn.js';
import { ensureOpenedProjectGit, openSession } from '../sessionOpening.js';
@@ -2177,6 +2178,23 @@ export function registerSessionIpc(
* (GUI 侧栏、MCP 工具、device-link)一并生效;GUI 侧的预检只为及时反馈,规则
* 以本函数为准,不得在入口层另立一份。
*/
+
+/** Pre-lock cancellation is limited to validated terminal intent; commit/cleanup stay locked. */
+async function cancelValidatedCreation(
+ dbClient: DbClient, sessionId: string, status: unknown,
+ assertCurrent: () => void,
+): Promise<void> {
+ if (status !== 'archived' && status !== 'deleted') return;
+ const cancel = captureSessionCreationCancellation(dbClient, sessionId);
+ const [target] = await dbClient.drizzle.select({ source: sessions.source })
+ .from(sessions).where(eq(sessions.id, sessionId)).limit(1);
+ if (!target) throwIpcError('NOT_FOUND', 'Session 不存在');
+ await assertGenericSessionLifecycleAllowed(dbClient.drizzle, sessionId);
+ assertCurrent();
+ if (getDbClient() !== dbClient) throwIpcError('PRECONDITION_FAILED', 'Session owner changed');
+ cancel();
+}
+
export async function updateSessionInDb(
sid: string,
p: Record<string, unknown>,
@@ -2420,6 +2438,10 @@ export async function updateSessionInDb(
const previousContextWindowBudget: number | null = hasContextWindowBudgetChange
? readSessionContextWindowBudget(sid)
: null;
+ await cancelValidatedCreation(dbClient, sid, p.status, () => {
+ moveGuard?.assertCurrent();
+ if (!isOwnerScopeCurrent(ownerScope)) throwIpcError('PRECONDITION_FAILED', 'Session owner changed');
+ });
let deletedSideChats: SessionsSetTerminalStatusResult['deletedSideChats'] | undefined;
await withStatusWriteLock(
db,
@@ -2690,6 +2712,12 @@ export async function patchSessionMetaInDb(
// 控制端远程改名走这条,与本机改名同口径(同样先记号后写库)。
if (patch.title !== undefined) noteUserTitleWritten(sessionId);
let deletedSideChats: SessionsSetTerminalStatusResult['deletedSideChats'] | undefined;
+ await cancelValidatedCreation(dbClient, sessionId, patch.status, () => {
+ if (!isOwnerScopeCurrent(ownerScope) || options.signal?.aborted) {
+ throwIpcError('PRECONDITION_FAILED', 'Session send aborted');
+ }
+ options.beforeWrite?.();
+ });
const updated = await withStatusWriteLock(db, sessionId, patch.status, async () => {
if (patch.status !== undefined) await assertGenericSessionLifecycleAllowed(db, sessionId);
options.beforeWrite?.();
diff --git a/apps/desktop/src/main/localDb/orcaTeamStore.ts b/apps/desktop/src/main/localDb/orcaTeamStore.ts
index 5383ce1eb9..2b0175ab22 100644
--- a/apps/desktop/src/main/localDb/orcaTeamStore.ts
+++ b/apps/desktop/src/main/localDb/orcaTeamStore.ts
@@ -5,7 +5,7 @@ import { orcaWorkerSessionTitle } from '@cindy/maker-shared/orca-team';
import type { OrcaRemotePendingReport } from '../../shared/orcaRemoteWorker.js';
import { parseOrcaRemoteLead } from '../../shared/orcaRemoteWorker.js';
-import { getDbClient } from './client/current.js';
+import { getDbClient, getCurrentDbClientSnapshot, type CurrentDbClientSnapshot } from './client/current.js';
import type { OrcaRemoteWorkerProxySessionSeed } from './client/tx/types.js';
import { orcaWorkers, orcaTeams, orcaWorkerCreationReservations, orcaRemoteOpens, sessions } from './schema.js';
import { createLogger } from '../logger.js';
@@ -722,9 +722,21 @@ async function listActiveWorkerSessionIdsForInactiveTeams(
export async function setSessionOrcaRole(
sessionId: string,
role: OrcaRole | null,
+ options: { owner?: CurrentDbClientSnapshot; assertCurrent?: () => void } = {},
): Promise<void> {
- const db = getDbClient().drizzle;
+ const owner = options.owner ?? getCurrentDbClientSnapshot();
+ const assertCurrent = () => {
+ options.assertCurrent?.();
+ if (!owner || getCurrentDbClientSnapshot() !== owner) {
+ throw new Error('[REMOTE_AGENT_EXPIRED] The task owner has changed.');
+ }
+ };
+ assertCurrent();
+ const db = owner!.client.drizzle;
await db.update(sessions).set({ orcaRole: role }).where(eq(sessions.id, sessionId));
+ // The issued write belongs to the captured DB. Never broadcast its result
+ // into another account, or after the owning creation has been cancelled.
+ assertCurrent();
broadcastSessionPatch(sessionId, { orcaRole: role });
}
diff --git a/apps/desktop/src/main/localDb/sessionRuntimeCleanup.ts b/apps/desktop/src/main/localDb/sessionRuntimeCleanup.ts
index eb8aaae944..e37b145266 100644
--- a/apps/desktop/src/main/localDb/sessionRuntimeCleanup.ts
+++ b/apps/desktop/src/main/localDb/sessionRuntimeCleanup.ts
@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
import { requestSessionArchiveSync } from './sessionArchiveSync.js';
type SessionRuntimeCleanup = (sessionId: string) => void;
@@ -20,3 +21,63 @@ export function cleanupSessionRuntimeForTerminalStatus(sessionId: string, status
sessionRuntimeCleanup?.(sessionId);
requestSessionArchiveSync();
}
+
+// Only live creation attempts are retained. The DB client identifies the owner;
+// the async context identifies the exact attempt, including late preparation.
+interface SessionCreationAttempt {
+ sessionId: string;
+ owner: object;
+ readOwner: () => object;
+ controller: AbortController;
+}
+const creationContext = new AsyncLocalStorage<SessionCreationAttempt>();
+const creations = new Set<SessionCreationAttempt>();
+
+export function currentSessionCreationSignal(sessionId: string): AbortSignal | undefined {
+ const attempt = creationContext.getStore();
+ return attempt?.sessionId === sessionId ? attempt.controller.signal : undefined;
+}
+
+export function assertSessionCreationCurrent(): void {
+ const attempt = creationContext.getStore();
+ if (!attempt) return;
+ if (attempt.owner !== attempt.readOwner()) {
+ attempt.controller.abort(new Error('[REMOTE_AGENT_EXPIRED] The task owner has changed.'));
+ }
+ attempt.controller.signal.throwIfAborted();
+}
+
+/** Call only after validating the terminal request against this owner's DB. */
+export function captureSessionCreationCancellation(owner: object, sessionId: string): () => void {
+ const snapshot = [...creations].filter(attempt => attempt.owner === owner && attempt.sessionId === sessionId);
+ return () => {
+ for (const attempt of snapshot) {
+ if (creations.has(attempt)) {
+ attempt.controller.abort(new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.'));
+ }
+ }
+ };
+}
+
+/** Held inside the existing route lock; cancellation releases it before late preparation completes. */
+export async function runSessionCreationAttempt<T>(
+ sessionId: string,
+ readOwner: () => object,
+ task: () => Promise<T>,
+): Promise<T> {
+ const attempt: SessionCreationAttempt = {
+ sessionId, owner: readOwner(), readOwner, controller: new AbortController(),
+ };
+ creations.add(attempt);
+ const signal = attempt.controller.signal;
+ let rejectCancelled!: (error: unknown) => void;
+ const cancelled = new Promise<never>((_resolve, reject) => { rejectCancelled = reject; });
+ const onAbort = () => rejectCancelled(signal.reason);
+ signal.addEventListener('abort', onAbort, { once: true });
+ try {
+ return await Promise.race([creationContext.run(attempt, task), cancelled]);
+ } finally {
+ signal.removeEventListener('abort', onAbort);
+ creations.delete(attempt);
+ }
+}
diff --git a/apps/desktop/src/main/maker-host/index.ts b/apps/desktop/src/main/maker-host/index.ts
index f7d973df82..7a98cf31fd 100644
--- a/apps/desktop/src/main/maker-host/index.ts
+++ b/apps/desktop/src/main/maker-host/index.ts
@@ -137,7 +137,8 @@ import { readProviderGroupBinding } from '../provider-group/bindings.js';
import { createSubscriptionFastPolicy } from './subscription-fast-policy.js';
import { getProviderGroupGuestSwitch } from '../provider-group/guestSwitch.js';
import { tapWindowBroadcast } from '../device-link/broadcast-tap.js';
-import { remoteBackgroundInvoke, remoteInvoke } from '../device-link/index.js';
+import { openRemoteLink, remoteBackgroundInvoke, remoteInvoke } from '../device-link/index.js';
+import { isCrossRegionProviderShareTarget, renewCrossRegionProviderShareLink } from '../device-link/providerShareCrossRegion.js';
import { handleListDevices, defaultDeps as deviceDirectoryDeps } from '../device-link/ipc.js';
import { parseProviderShareAgentDeviceId } from '../device-link/providerShareGuest.js';
import { isProviderShareCredentialConsentSkipped } from '../device-link/providerShareGuestPrefs.js';
@@ -2932,6 +2933,8 @@ export function getMaker(): Maker {
startDeviceAgentSession: createDeviceAgentStarter({
readImageDeliveryEpoch: readGeneratedImageEpoch,
remoteInvoke: remoteBackgroundInvoke,
+ renewSharedProviderLink: (peer) => isCrossRegionProviderShareTarget(peer)
+ ? renewCrossRegionProviderShareLink(peer) : openRemoteLink(peer),
rgPath: getRipgrepBinaryPath,
// 对方的 Codex 把本机当 exec-server 执行环境:用本机随包的同一个 codex。
codexPath: () => getCachedBinaryStatus('codex').binaryPath ?? undefined,
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/sessionCreateHandler.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/sessionCreateHandler.test.ts
index ede9b2a91b..8fb5fac19c 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/sessionCreateHandler.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/sessionCreateHandler.test.ts
@@ -1,3 +1,4 @@
+import { runSessionCreationAttempt, captureSessionCreationCancellation } from '../../localDb/sessionRuntimeCleanup';
import { describe, expect, it, vi } from 'vitest';
import { MAKER_INVOKE } from '../channels';
@@ -306,3 +307,49 @@ describe('maker session CREATE_SESSION IPC handler', () => {
]);
});
});
+
+// Unit, F6: a validated terminal request may resume after the old creation finished.
+// Capture its attempt before validation awaits; never cancel a replacement with the same UUID.
+it('a late terminal cancellation snapshot cannot cancel a replacement or sibling creation', async () => {
+ const owner = {};
+ let finishOld!: () => void, finishNew!: () => void, finishSibling!: () => void;
+ const old = runSessionCreationAttempt('same', () => owner, () => new Promise<void>(done => { finishOld = done; }));
+ const cancelOld = captureSessionCreationCancellation(owner, 'same');
+ finishOld(); await old;
+ let newState = 'pending', siblingState = 'pending';
+ const replacement = runSessionCreationAttempt('same', () => owner, () => new Promise<void>(done => { finishNew = done; }))
+ .then(() => { newState = 'resolved'; }, () => { newState = 'rejected'; });
+ const sibling = runSessionCreationAttempt('sibling', () => owner, () => new Promise<void>(done => { finishSibling = done; }))
+ .then(() => { siblingState = 'resolved'; }, () => { siblingState = 'rejected'; });
+ cancelOld(); await Promise.resolve(); await Promise.resolve();
+ expect(newState).toBe('pending'); expect(siblingState).toBe('pending');
+ finishNew(); finishSibling(); await Promise.all([replacement, sibling]);
+ expect(newState).toBe('resolved'); expect(siblingState).toBe('resolved');
+});
+
+// Unit, F6: once bootstrap returns, cancellation still owns that exact handle
+// until IPC publication. Delayed role persistence must not send/broadcast it.
+it('closes the returned instance once when terminal cancellation interrupts publication', async () => {
+ const harness = new IpcHarness(), owner = {};
+ let finishRole!: () => void;
+ const role = new Promise<void>(done => { finishRole = done; });
+ const close = vi.fn(async () => {});
+ const deps = createDeps({ creationOwner: () => owner,
+ closeCancelledSession: close,
+ markOrcaRoleIfNeeded: vi.fn(() => role),
+ });
+ registerMakerSessionCreateHandler(harness, deps);
+ let failure: unknown;
+ const pending = harness.invoke(MAKER_INVOKE.CREATE_SESSION, {
+ id: 'session-1', agentKind: 'codex', model: 'm', workingDir: '/fixture', orcaRole: 'lead',
+ }).catch(error => { failure = error; });
+ await vi.waitFor(() => expect(deps.markOrcaRoleIfNeeded).toHaveBeenCalledOnce(), { interval: 1 });
+ captureSessionCreationCancellation(owner, 'session-1')();
+ await pending;
+ expect(String(failure)).toContain('REMOTE_AGENT_EXPIRED');
+ expect(close).toHaveBeenCalledExactlyOnceWith((await deps.bootstrapSession.mock.results[0]!.value).session);
+ finishRole(); await Promise.resolve(); await Promise.resolve();
+ expect(deps.broadcastSessionCreated).not.toHaveBeenCalled();
+ expect(deps.sendWorkerReadyMessage).not.toHaveBeenCalled();
+ expect(close).toHaveBeenCalledOnce();
+});
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 9007d1dcd1..19df966fb4 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -1,6 +1,7 @@
+import { assertSessionCreationCurrent, currentSessionCreationSignal } from '../localDb/sessionRuntimeCleanup.js';
import { readTaskDeliveryNote } from '../bot-autonomy/hub.js';
import { setVoiceTaskDispatch, setVoiceCallMemoryReader } from '../voice-conversation/taskBridge.js';
-import { buildBotMemoryScopeKey } from '@cindy/maker-core';
+import { buildBotMemoryScopeKey, SessionCreationCleanupPendingError } from '@cindy/maker-core';
import { createOrcaWorkerProjectHandlers } from './orcaWorkerProjectHandlers';
import { getTeamByWorkerSession } from '../localDb/orcaTeamStore';
import { readWorkerProjectContext, createWorkerWorktree, rememberWorkerProject, probeWorkerProject, resolveWorkerWorktreeSource, getWorkerOwnedWorktree } from './orcaWorkerProject';
@@ -84,6 +85,7 @@ import {
writeProviderGroupBinding,
} from '../provider-group/bindings.js';
import { getProviderGroupGuestSwitch } from '../provider-group/guestSwitch.js';
+import { liveDirectGuestSession } from '../remote-agent/controller/service.js';
import { currentProviderPartyUsageStore } from '../usage/providerPartyUsageStore.js';
import { recordSessionProviderPartyUsage } from './sessionProviderPartyUsage.js';
import { createProviderGroupLeaseReporter, type ProviderGroupLeaseReporter } from '../provider-group/leaseReporter.js';
@@ -405,6 +407,8 @@ import * as cindyChatAttachments from '../cindy-media/chatAttachments.js';
import { materializeSshRemoteMedia } from '../file-browser/ssh-media.js';
import { readGeneratedImageFile, MAX_GENERATED_IMAGE_BYTES } from '../cindy-media/generatedMedia.js';
import { createGeneratedImageDelivery } from '../cindy-media/generatedImageDelivery.js';
+import { authorizeSharedTaskHistory, liveSharedTaskTarget } from '../remote-agent/controller/providerShareTaskLocation.js';
+import { resolveRemoteAgentTarget } from '../device-link/providerShareGuest.js';
import { setGeneratedImageRecovery } from '../cindy-media/generatedImageRecovery.js';
import {
getCurrentDbClientSnapshot,
@@ -8760,13 +8764,22 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
orcaRole: CreateOpts['orcaRole'],
): Promise<void> {
if (orcaRole !== 'lead' && orcaRole !== 'worker') return;
+ const owner = getCurrentDbClientSnapshot();
+ const assertCurrent = () => {
+ assertSessionCreationCurrent();
+ if (!owner || getCurrentDbClientSnapshot() !== owner) {
+ throw new Error('[REMOTE_AGENT_EXPIRED] The task owner has changed.');
+ }
+ };
+ assertCurrent();
await assertReviewSettingsUnlocked(sessionId);
+ assertCurrent();
if (orcaRole === 'worker') {
markKnownOrcaWorkerSession(sessionId);
clearSuppressedOrcaWorkerAgentIslandSession(sessionId);
}
try {
- await setSessionOrcaRole(sessionId, orcaRole);
+ await setSessionOrcaRole(sessionId, orcaRole, { owner: owner!, assertCurrent });
} catch (err) {
log.warn('failed to mark orca_role', {
sessionId,
@@ -8978,6 +8991,15 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
didInjectOrcaInstructions: boolean;
didInjectProjectContext: boolean;
}> {
+ let session: Awaited<ReturnType<typeof maker.createSession>> | undefined;
+ const creationSignal = o.id ? currentSessionCreationSignal(o.id) : undefined;
+ const closeCancelled = () => {
+ if (session) void maker.closeSessionIfCurrent(session).catch(error => {
+ log.warn('Cancelled creation cleanup failed', { sessionId: o.id, error: String(error) });
+ });
+ };
+ creationSignal?.addEventListener('abort', closeCancelled, { once: true });
+ try {
assertAccess?.();
await applyPersistedCindyMakeMarker(o, readSessionSource);
assertAccess?.();
@@ -8991,7 +9013,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
const agentDeviceId = await readSessionAgentDeviceId(o.id);
if (agentDeviceId) o.agentDeviceId = agentDeviceId;
}
+ assertAccess?.();
let providerGroupStart = await applyProviderGroupAssignment(o);
+ assertAccess?.();
// 模型与供应商来自那台电脑(由那台按它自己的目录校验),本机目录里没有它们。
const agentOnOtherDevice = Boolean(o.agentDeviceId) && !o.remoteHostId;
if (o.id && !o.remoteHostId) worktreeManager.assertPrecreatedSessionNotCancelled(o.id);
@@ -9008,7 +9032,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
makerMemoryEnabled: o.makerMemoryEnabled,
displayReasoning: o.displayReasoning,
};
+ assertAccess?.();
await options.waitForAccountProviderModelsReady();
+ assertAccess?.();
const runtimeOverride =
typeof o.id === 'string' ? getSessionRuntimeControlSnapshot(o.id).effectiveOverride : null;
if (runtimeOverride && runtimeOverride.agentKind === o.agentKind) {
@@ -9023,6 +9049,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
}
assertAccess?.();
await applyPersistedReviewMode(o);
+ assertAccess?.();
const didInjectOrcaInstructions = o.reviewMode === true ? false : applyOrcaInstructions(o);
const didInjectProjectContext =
o.reviewMode === true ? false : await applyProjectContextInjection(o);
@@ -9046,6 +9073,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
},
});
+ assertAccess?.();
await hydrateProviderIdBeforeSessionStart(o);
assertAccess?.();
/** 本机运行时的启动准入(Agent 在另一台电脑运行时由那台按它自己的目录裁决)。 */
@@ -9096,9 +9124,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
};
if (!agentOnOtherDevice) await admitLocalRoute();
assertAccess?.();
- let session: Awaited<ReturnType<typeof maker.createSession>> | undefined;
let nativeRelocation: Awaited<ReturnType<typeof relocateForFreshStart>> | undefined;
while (!session) {
+ assertAccess?.();
try {
// Claude's ID is prefilled before the CLI accepts resume. Require its
// native initialization handshake for every transferred copy, including
@@ -9107,7 +9135,13 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
delete vendorOptions._cindyRequireNativeResume;
if (nativeHistoryResume || nativeRelocation?.nativeId) vendorOptions._cindyRequireNativeResume = true;
o.vendorOptions = vendorOptions;
- session = await maker.createSession(o);
+ session = await maker.createSession(o, creationSignal);
+ try { assertAccess?.(); } catch (error) {
+ const cancelledSession = session;
+ session = undefined;
+ await maker.closeSessionIfCurrent(cancelledSession, 'requested');
+ throw error;
+ }
if (nativeRelocation?.nativeId && session.sdkSessionId !== nativeRelocation.nativeId) {
const opened = session;
session = undefined;
@@ -9116,6 +9150,10 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
}
nativeRelocation = undefined;
} catch (error) {
+ assertAccess?.();
+ // Native ownership is unresolved, not a route/resume failure. Do not
+ // relocate history or try another provider while the old handle lives.
+ if (error instanceof SessionCreationCleanupPendingError) throw error;
if (nativeRelocation?.fallback) {
const fallback = nativeRelocation.fallback;
nativeRelocation = undefined;
@@ -9138,6 +9176,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
return null;
})
: null;
+ assertAccess?.();
// 分享来的供应商被分享者建成了组:续接回到原来那台却接不下时,组所在电脑发来「需要换一台」凭证
// (provider-groups.md §6.1 分享的人):同一个分享位置带交接重新打开,打开时带回凭证,由组换一台。
const guestRelocation = !next && o.id && o.resumeSessionId && isProviderShareAgentDeviceId(o.agentDeviceId)
@@ -9174,6 +9213,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
}
}
await markProjectContextIfNeeded(session.id, didInjectProjectContext);
+ assertAccess?.();
wireSessionToIpc(session);
markOrcaMcpHydratedIfNeeded(session.id, o);
@@ -9202,7 +9242,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
.limit(1);
return pRow?.providerId;
},
- hydrateSessionProvider,
+ hydrateSessionProvider: (...args) => { assertAccess?.(); hydrateSessionProvider(...args); },
});
// bridge 会话态(effort / fast)同点 hydrate:让 resume / 重启后的首个 bridge 请求就带上
// 用户上次选定的思维深度与 Fast(否则要等用户再点一次开关才写进内存 store)。
@@ -9211,6 +9251,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
.from(sessions)
.where(eq(sessions.id, session.id))
.limit(1);
+ assertAccess?.();
if (runtimeOverride) {
setSessionEffort(session.id, runtimeOverride.effort);
setSessionFastMode(session.id, runtimeOverride.fastMode);
@@ -9250,6 +9291,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// 统一补一次反范式快照(幂等;本地"先会话后 worktree"路径此时无绑定,天然跳过)。
// 失败非致命 —— 徽标与回收都以 worktreeStore 为准。
try {
+ assertAccess?.();
const wtMeta = worktreeStore.get(session.id);
if (wtMeta?.path) {
const db = getDbClient().drizzle;
@@ -9265,7 +9307,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
});
}
+ assertAccess?.();
return { session, didInjectOrcaInstructions, didInjectProjectContext };
+ } finally { creationSignal?.removeEventListener('abort', closeCancelled); }
}
installLocalAgentVisibleSessionHost((localMaker) => {
@@ -9878,6 +9922,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
remoteHostIdToEnsure = await readSessionRemoteHostIdCached(sessionIdForLookup);
}
}
+ assertSessionCreationCurrent();
if (!remoteHostIdToEnsure) return;
if (createOpts && typeof createOpts === 'object') {
@@ -9900,7 +9945,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
}
}
+ assertSessionCreationCurrent();
await ensureRemoteHostReady(remoteHostIdToEnsure);
+ assertSessionCreationCurrent();
const ensureAgentKind: 'claude-code' | 'codex' | 'pi' | null =
session?.agentKind === 'codex' ||
session?.agentKind === 'claude-code' ||
@@ -9933,6 +9980,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// ensureRemoteAgentInstalledOrInstall 已对不 ready 抛 SSH_NOT_CONNECTED,
// 这里只是 best-effort 增强(与 claude-code 分支的立即 throw 语义对齐点
// 不同:pi 的 agent 二进制检查已兜底)。
+ assertSessionCreationCurrent();
if (ensureAgentKind === 'pi') {
const host = getRemoteSshPool().get(remoteHostIdToEnsure);
if (host?.getStatus() === 'ready') {
@@ -9976,6 +10024,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// remote-forward 直连本机 HTTP bridge):转发 / config.toml / daemon env
// 就绪必须先于 transport 创建 (daemon discover/bootstrap)。best-effort —
// 失败时 session 按"远端无 MCP"放行,与历史行为一致;协同类工具此时不可用。
+ assertSessionCreationCurrent();
if (ensureAgentKind === 'codex') {
const host = getRemoteSshPool().get(remoteHostIdToEnsure);
if (host?.getStatus() === 'ready') {
@@ -9987,6 +10036,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// 最后一次启动恒为携带双方的 MCP bootstrap;marker 一致时仅 1 次
// cat RTT 零副作用。
await reconcileCodexAgentProxyEnv(host);
+ assertSessionCreationCurrent();
const result = await ensureRemoteCodexMcpBridge(host, {
ensureBridgeStarted: ensureCodexMcpBridgeStartedForRemote,
// config 漂移生效要重启 daemon, 重启会断同 host 的 live turn:
@@ -9999,6 +10049,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
// Maker Memory 全局开着时把 cindy_memory 一并注入远端 daemon config。
isMakerMemoryEnabled: () => maker.makerMemory?.isEnabled() ?? false,
});
+ assertSessionCreationCurrent();
if (
result.ok &&
result.daemonRebootstrapped &&
@@ -10153,14 +10204,19 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
};
const makerSessionRegistry = createElectronIpcHandlerRegistry();
- registerMakerSessionCreateHandler(makerSessionRegistry, {
+ registerMakerSessionCreateHandler<Session>(makerSessionRegistry, {
// CREATE_SESSION 同样先走 remote ensure:remote draft (尤其 collab
// lead) 的 SSH 重连 / agent 安装 / codex daemon MCP 注入必须先于
// bootstrap, 否则 lead 首个 turn 没有 cindy_orca, 与 orca 架构文档的
// "session start/resume 前置" 契约不符。本地会话 ensure 内部直接返回。
+ creationOwner: getDbClient,
+ closeCancelledSession: async session => { await maker.closeSessionIfCurrent(session); },
bootstrapSession: async (co) => {
+ assertSessionCreationCurrent();
await ensureRemoteReadyForSessionStart({ createOpts: co });
- const result = await bootstrapSession(co);
+ assertSessionCreationCurrent();
+ const result = await bootstrapSession(co, assertSessionCreationCurrent);
+ assertSessionCreationCurrent();
// maker:create-session 是手机 / device-link 的创建入口,不经过
// local-db:sessions:create,因此后者维护 recent_workdirs 的逻辑不会运行。
// worktree 两步流此时 co.workingDir 已是隔离目录;picker 需要记住用户选的
@@ -11520,6 +11576,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
},
// 分享来的供应商被分享者建成了组:组所在电脑发来「需要换一台」时自动交接(provider-groups.md §6.1)。
guestSwitch: getProviderGroupGuestSwitch(),
+ directGuestSession: liveDirectGuestSession,
continueSession: async (sessionId, token, info) =>
agentInputCoordinatorHolder
? agentInputCoordinatorHolder.continueAfterUsageLimitReset(sessionId, token, info)
@@ -25863,6 +25920,20 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
const generatedImageDelivery = createGeneratedImageDelivery({
invoke: remoteBackgroundInvoke,
+ liveSharedTaskTarget,
+ resolveSharedOwnerTarget: async (ownerRoute) => resolveRemoteAgentTarget(ownerRoute),
+ authorizeSharedTaskHistory: async (sessionId, ownerRoute) => {
+ const snapshot = getCurrentDbClientSnapshot();
+ if (!snapshot) throw new Error('REMOTE_SOURCE_REQUIRED');
+ const [session] = await snapshot.client.drizzle.select({ model: sessions.model })
+ .from(sessions).where(eq(sessions.id, sessionId)).limit(1);
+ if (getCurrentDbClientSnapshot() !== snapshot) throw new Error('SCOPE_CHANGED');
+ if (!session) throw new Error('REMOTE_SOURCE_REQUIRED');
+ const authorized = await authorizeSharedTaskHistory(ownerRoute, sessionId, 'codex', session.model);
+ if (getCurrentDbClientSnapshot() !== snapshot) throw new Error('SCOPE_CHANGED');
+ // Pin legacy O as well, so a later direct assignment cannot move an old image's source.
+ return resolveRemoteAgentTarget(authorized.target);
+ },
publish: (sessionId, event, persistId, resolvedContent) => {
broadcastToAllWindows(MAKER_PUSH.EVENT, { sessionId, event, persistId, resolvedContent }, captureDataOwnerBroadcastScope());
},
diff --git a/apps/desktop/src/main/maker-ipc/sessionCreateHandler.ts b/apps/desktop/src/main/maker-ipc/sessionCreateHandler.ts
index c93e4923ec..62da14d561 100644
--- a/apps/desktop/src/main/maker-ipc/sessionCreateHandler.ts
+++ b/apps/desktop/src/main/maker-ipc/sessionCreateHandler.ts
@@ -1,3 +1,4 @@
+import { assertSessionCreationCurrent, currentSessionCreationSignal, runSessionCreationAttempt } from '../localDb/sessionRuntimeCleanup.js';
import type { AgentKind } from '@cindy/maker-core';
import { MAKER_INVOKE } from './channels.js';
@@ -52,6 +53,9 @@ export interface MakerSessionCreateResultSession {
export interface MakerSessionCreateHandlerDeps<
TSession extends MakerSessionCreateResultSession = MakerSessionCreateResultSession,
> {
+ /** Captured per creation; prevents another account with the same UUID cancelling it. */
+ creationOwner?: () => object;
+ closeCancelledSession?: (session: TSession) => Promise<void>;
bootstrapSession(opts: MakerSessionCreateOpts): Promise<{
session: TSession;
didInjectOrcaInstructions: boolean;
@@ -91,6 +95,7 @@ export function registerMakerSessionCreateHandler<TSession extends MakerSessionC
);
const run = async () => {
+ assertSessionCreationCurrent();
let bootstrapped: Awaited<ReturnType<typeof deps.bootstrapSession>>;
try {
bootstrapped = await deps.bootstrapSession(o);
@@ -112,38 +117,62 @@ export function registerMakerSessionCreateHandler<TSession extends MakerSessionC
}
const { session, didInjectOrcaInstructions, didInjectProjectContext } = bootstrapped;
- deps.logCreateSession({
- agentKind: o.agentKind,
- model: o.model,
- fastMode: o.fastMode ?? 'default',
- workDir: o.workingDir,
- providedId: !!o.id,
- usedOrcaInstructions: didInjectOrcaInstructions,
- usedProjectContext: didInjectProjectContext,
- extraDirsCount: o.extraDirs?.length ?? 0,
- });
+ const signal = currentSessionCreationSignal(session.id);
+ let closing = false;
+ const closeCancelled = () => {
+ if (closing) return;
+ closing = true;
+ void deps.closeCancelledSession?.(session).catch(error => {
+ deps.warnStderr(session.agentKind, 'Cancelled creation cleanup failed: ' + String(error));
+ });
+ };
+ signal?.addEventListener('abort', closeCancelled, { once: true });
+ if (signal?.aborted) closeCancelled();
+ try {
+ assertSessionCreationCurrent();
+ deps.logCreateSession({
+ agentKind: o.agentKind,
+ model: o.model,
+ fastMode: o.fastMode ?? 'default',
+ workDir: o.workingDir,
+ providedId: !!o.id,
+ usedOrcaInstructions: didInjectOrcaInstructions,
+ usedProjectContext: didInjectProjectContext,
+ extraDirsCount: o.extraDirs?.length ?? 0,
+ });
- if (o.orcaRole === 'lead') {
- await deps.markOrcaRoleIfNeeded(session.id, o.orcaRole);
- }
- deps.markKnownNonOrcaIfApplicable(session.id, o);
- if (o.orcaRole === 'worker' && !o.resumeSessionId) {
- deps.sendWorkerReadyMessage(session);
- }
- deps.broadcastSessionCreated(session.id);
+ if (o.orcaRole === 'lead') {
+ await deps.markOrcaRoleIfNeeded(session.id, o.orcaRole);
+ }
+ assertSessionCreationCurrent();
+ deps.markKnownNonOrcaIfApplicable(session.id, o);
+ if (o.orcaRole === 'worker' && !o.resumeSessionId) {
+ deps.sendWorkerReadyMessage(session);
+ }
+ deps.broadcastSessionCreated(session.id);
- return {
- sessionId: session.id,
- agentKind: session.agentKind,
- workDir: session.workDir,
- capabilities: session.capabilities,
- usedProjectContext: didInjectProjectContext,
- };
+ return {
+ sessionId: session.id,
+ agentKind: session.agentKind,
+ workDir: session.workDir,
+ capabilities: session.capabilities,
+ usedProjectContext: didInjectProjectContext,
+ };
+ } finally { signal?.removeEventListener('abort', closeCancelled); }
};
const explicitSessionId = typeof o.id === 'string' && o.id ? o.id : null;
+ const owner = deps.creationOwner?.();
+ const create = () => {
+ if (owner && deps.creationOwner?.() !== owner) {
+ throw new Error('[REMOTE_AGENT_EXPIRED] The task owner has changed.');
+ }
+ return explicitSessionId && deps.creationOwner
+ ? runSessionCreationAttempt(explicitSessionId, deps.creationOwner, run)
+ : run();
+ };
return explicitSessionId && deps.withSessionLock
- ? deps.withSessionLock(explicitSessionId, run)
- : run();
+ ? deps.withSessionLock(explicitSessionId, create)
+ : create();
});
}
diff --git a/apps/desktop/src/main/maker-orchestration/fork.ts b/apps/desktop/src/main/maker-orchestration/fork.ts
index c72c331277..ef7379e14c 100644
--- a/apps/desktop/src/main/maker-orchestration/fork.ts
+++ b/apps/desktop/src/main/maker-orchestration/fork.ts
@@ -18,6 +18,10 @@ import { assertCindyMakeSessionAvailable } from '../cindy-make/featureGate.js';
import { remoteBackgroundInvoke } from '../device-link/index.js';
import { forkRemoteAgentSession } from '../remote-agent/controller/fork.js';
import { remoteAgentInvoker } from '../remote-agent/controller/runClient.js';
+import { parseProviderSharePeer } from '@cindy/device-link';
+import {
+ authorizeSharedTaskHistory, authorizeSharedTaskExecutor, releaseSharedTaskAuthorization,
+} from '../remote-agent/controller/providerShareTaskLocation.js';
import { getDbClient } from '../localDb/client/current';
import { sessions, messages } from '../localDb/schema';
import { sessionToCamel } from '../localDb/mapper';
@@ -999,8 +1003,9 @@ export async function forkSessionAtMessage(
(usesTailTurnFork || assistantUuid)
) {
const agentKind = dbToMakerAgentKind(forkSource.agentKind);
+ const sourceSdkSessionId = forkSource.sdkSessionId;
const forkOptions = {
- sourceSdkSessionId: forkSource.sdkSessionId,
+ sourceSdkSessionId,
...(isCodex ? { model: forkSource.model, providerId: forkSource.providerId } : {}),
upToMessageId: assistantUuid,
...(lastTurnId ? { lastTurnId } : {}),
@@ -1012,9 +1017,19 @@ export async function forkSessionAtMessage(
// agent 实例字段 —— R4 竞态 #1)。
remoteHostId: source.remoteHostId ?? null,
};
- const forkResult = await (forkSource.agentDeviceId
- ? forkRemoteAgentSession(remoteAgentInvoker(forkSource.agentDeviceId, remoteBackgroundInvoke), {
- sourceSdkSessionId: forkSource.sdkSessionId,
+ const forkRemote = async () => {
+ const ownerRoute = forkSource.agentDeviceId!;
+ const location = await authorizeSharedTaskHistory(ownerRoute, sourceSessionId, agentKind, forkSource.model);
+ let childGeneration: string | undefined;
+ if (location.direct) {
+ const deviceId = parseProviderSharePeer(location.target)?.deviceId;
+ if (!deviceId) throw new Error('[REMOTE_AGENT_INVALID] invalid shared history executor');
+ const child = await authorizeSharedTaskExecutor(ownerRoute, newSessionId, agentKind, forkSource.model, deviceId, true);
+ childGeneration = child.generation;
+ }
+ try {
+ return await forkRemoteAgentSession(remoteAgentInvoker(location.target, remoteBackgroundInvoke), {
+ sourceSdkSessionId,
upToMessageId: assistantUuid,
lastTurnId,
tailTurnsToDrop,
@@ -1024,7 +1039,14 @@ export async function forkSessionAtMessage(
agentKind,
model: forkSource.model,
providerId: forkSource.providerId,
- })
+ });
+ } catch (error) {
+ if (location.direct) await releaseSharedTaskAuthorization(ownerRoute, newSessionId, childGeneration).catch(() => undefined);
+ throw error;
+ }
+ };
+ const forkResult = await (forkSource.agentDeviceId
+ ? forkRemote()
: getMaker().forkSdkSession(agentKind, forkOptions))
.catch((err: unknown) => {
// 这里刻意用 isCodex(非 usesTailTurnFork):CODEX_FORK_STATE_UNAVAILABLE 是 codex 专属
diff --git a/apps/desktop/src/main/provider-group/__tests__/fastPolicyRuntime.test.ts b/apps/desktop/src/main/provider-group/__tests__/fastPolicyRuntime.test.ts
index 866f79cacc..6dfdf88bcf 100644
--- a/apps/desktop/src/main/provider-group/__tests__/fastPolicyRuntime.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/fastPolicyRuntime.test.ts
@@ -1,9 +1,13 @@
import fs from 'node:fs';
import path from 'node:path';
import os from 'node:os';
-import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { randomUUID } from 'node:crypto';
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { ProviderGroupConfig } from '../../../shared/providerGroup.js';
+import type { RemoteAgentHostDeps } from '../../remote-agent/host/runHost.js';
+import type { ProviderShareUsageStore } from '../../device-link/providerShareUsageStore.js';
import { hostSessionIdFor } from '../../remote-agent/host/sessionIdentity.js';
+import { providerShareGuestPeer, type ProviderShareOwned, type RemoteAgentFastPolicy, type RemoteAgentRequest } from '@cindy/device-link';
const state = vi.hoisted(() => ({
owner: 'test',
@@ -15,6 +19,115 @@ const state = vi.hoisted(() => ({
beforeCaps: undefined as undefined | (() => Promise<void>),
calls: [] as Array<{ device: string; command: Record<string, any> }>,
notify: vi.fn(async () => {}),
+ self: 'self',
+ direct: false,
+ planDevice: 'one',
+ approved: true,
+ delegatedAllowed: true,
+ modelChanged: undefined as (() => void) | undefined,
+ shareOwner: 'test',
+ shares: [] as ProviderShareOwned[],
+ revoked: [] as string[],
+ hostDeps: undefined as RemoteAgentHostDeps | undefined,
+ usage: undefined as ProviderShareUsageStore | undefined,
+ hostChanged: undefined as (() => void) | undefined,
+ pair: null as null | { generation: string; expiresAt: number; ownerDeviceId: string; executorDeviceId: string },
+ check: vi.fn(),
+ failGrant: false,
+ delegateCalls: [] as RemoteAgentRequest[],
+}));
+function ownedShareSnapshot(): readonly ProviderShareOwned[] | null {
+ if (state.owner !== state.shareOwner) return null;
+ return state.shares.map((share) => ({ ...share, members: state.approved ? share.members : [] }));
+}
+function ownedGuestAccess(peer: string) {
+ if (peer !== providerShareGuestPeer('share', 'member', 'laptop')) return null;
+ const share = ownedShareSnapshot()?.find((entry) => entry.shareId === 'share' && entry.hostDeviceId === 'self');
+ const member = share?.members.find((entry) => entry.memberId === 'member' && entry.status === 'active');
+ return share && member ? { shareId: share.shareId, memberId: member.memberId, providerId: share.providerId } : null;
+}
+vi.mock('../../authManager.js', () => ({ getDeviceId: () => 'one' }));
+vi.mock('../../device-link/providerShareApi.js', () => ({
+ providerShareOwnerKey: () => state.owner,
+ checkProviderShareDelegation: (...args: unknown[]) => state.check(...args),
+ grantProviderShareDelegation: async ({ executorDeviceId }: { executorDeviceId: string }) => {
+ if (state.failGrant) throw Error('server unavailable');
+ state.pair = { generation: randomUUID(), expiresAt: Date.now() + 30 * 60_000,
+ ownerDeviceId: 'self', executorDeviceId };
+ return state.pair;
+ },
+ // The server contract is one generation per G/M pair, not one per task.
+ revokeProviderShareDelegation: async ({ generation }: { generation: string }) => {
+ if (state.pair?.generation === generation) state.pair = null;
+ },
+}));
+vi.mock('../../device-link/settings-store.js', () => ({
+ readDeviceLinkSettings: () => ({ remoteControlEnabled: true, revokedControllers: state.revoked }),
+ onDeviceLinkSettingChanged: () => () => {},
+}));
+vi.mock('../../maker-host/remote-provider-access-store.js', () => ({ isRemoteProviderInvocationAllowed: () => true }));
+vi.mock('../../device-link/providerShareHost.js', () => ({
+ getProviderShareHostLoadedSnapshot: ownedShareSnapshot,
+ ownedProviderShareGuestAccess: ownedGuestAccess,
+ providerShareGuestAccess: ownedGuestAccess,
+ verifyProviderShareMemberGeneration: async (member: { shareId: string; memberId: string; joinedAt: string }) => {
+ const saved = ownedShareSnapshot()?.find((share) => share.shareId === member.shareId && share.hostDeviceId === 'self')
+ ?.members.find((entry) => entry.memberId === member.memberId);
+ if (!saved || saved.status !== 'active' || saved.joinedAt !== member.joinedAt) {
+ throw Error('Provider share membership changed during grant');
+ }
+ },
+ onProviderShareHostChanged: (callback: () => void) => { state.hostChanged = callback; return () => {}; },
+}));
+vi.mock('../../device-link/remoteModelAccess.js', () => ({
+ remoteModelAccess: { allows: () => true, allowsDelegatedExecution: () => state.delegatedAllowed,
+ subscribe: (callback: () => void) => { state.modelChanged = callback; return () => {}; } },
+}));
+vi.mock('../../device-link/providerShareUsageStore.js', async (original) => ({
+ ...await original<typeof import('../../device-link/providerShareUsageStore.js')>(),
+ installProviderShareUsageStore: () => state.usage!,
+ getProviderShareUsageStore: () => state.usage,
+}));
+vi.mock('../../remote-agent/host/runHost.js', () => ({
+ createRemoteAgentHost: (deps: RemoteAgentHostDeps) => { state.hostDeps = deps; return {
+ dispose() {}, issueDirectGroupSwitchToken: () => randomUUID(),
+ }; },
+}));
+vi.mock('../../remote-agent/controller/runClient.js', () => ({
+ RemoteAgentRunClient: { caps: async () => ({ directGuestExecution: true, guestRelay: true }) },
+}));
+vi.mock('../../remote-agent/controller/service', () => ({ remoteAgentPollerFor: vi.fn() }));
+vi.mock('../guestRelay.js', () => ({
+ createProviderGroupGuestRelay: () => ({
+ plan: async () => ({ kind: 'member', agentDeviceId: state.planDevice, providerId: 'openai',
+ memberKey: `device:${state.planDevice}:openai`, sameAccount: true }),
+ trackRun: () => ({ setRunning() {}, release() {} }),
+ connect: (device: string) => {
+ if (state.offline.has(device)) throw Error('executor offline');
+ return { invoke: async ([request]: RemoteAgentRequest[]) => {
+ state.delegateCalls.push(request);
+ if (request.op === 'delegate') return delegation.applyProviderShareDelegation('self', request);
+ throw Error(`Unexpected remote command: ${request.op}`);
+ } }; },
+ }),
+}));
+vi.mock('../../device-link/broadcast-tap.js', () => ({
+ captureDataOwnerBroadcastScope: () => state.owner, isDataOwnerBroadcastScopeCurrent: () => true,
+}));
+vi.mock('../../device-link/dispatch.js', () => ({ setRemoteAgentHandler() {} }));
+vi.mock('../../device-link/providerShareReshare.js', () => ({ handleProviderShareReshare() {}, providerShareReshareAllows() {} }));
+vi.mock('../reshareRuntime.js', () => ({ providerGroupReshare: {} }));
+vi.mock('../runtime.js', () => ({ getProviderGroupOwnerScope: () => state.owner }));
+vi.mock('../../remote-agent/host/limitsStore.js', () => ({ readRemoteAgentLimitsState: () => ({ value: {} }) }));
+vi.mock('../../remote-agent/host/providerAccess', () => ({ createGuestProviderRouteBinder: () => vi.fn() }));
+vi.mock('../../remote-agent/host/transcripts', () => ({}));
+vi.mock('../../cindy-media/generatedImageStorage', () => ({}));
+vi.mock('../../goal-host/usageLimit.js', () => ({}));
+vi.mock('../../maker-host/createDesktopProviderService.js', () => ({}));
+vi.mock('../../maker-host/session-provider-store.js', () => ({ bindHostedSessionProvider() {} }));
+vi.mock('../../maker-host/guest-provider-route-store.js', () => ({}));
+vi.mock('../../usage/providerPartyUsageStore.js', () => ({
+ flushProviderPartyUsage: async () => {}, currentProviderPartyUsageStore: () => ({}),
}));
const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-fast-sync-'));
vi.mock('../../logger.js', () => ({ createLogger: () => ({ info() {}, warn() {}, error() {} }) }));
@@ -36,9 +149,10 @@ vi.mock('../../maker-host/subscription-fast-policy.js', () => ({
vi.mock('../store.js', () => ({
readProviderGroup: () => state.config,
listProviderGroups: () => (state.config ? { openai: state.config } : {}),
+ onProviderGroupChanged: () => () => {},
}));
vi.mock('../../device-link/index.js', () => ({
- getSelfDeviceId: () => 'self',
+ getSelfDeviceId: () => state.self,
remoteBackgroundInvoke: async (
device: string,
_channel: string,
@@ -61,14 +175,40 @@ vi.mock('../../device-link/index.js', () => ({
...(!state.old.has(device) ? { subscriptionFastPolicy: true } : {}),
},
};
+ if (state.direct && command.op === 'fast-policy') {
+ state.self = device;
+ try { return { ok: true, result: await runtime.receiveGroupFastPolicy('self', command as RemoteAgentFastPolicy) }; }
+ finally { state.self = 'self'; }
+ }
return { ok: true, result: { revision: command.revision, allowFast: command.allowFast } };
},
}));
const runtime = await import('../fastPolicyRuntime.js');
-const { groupFastPolicyStore } = await import('../fastPolicyStore.js');
+const { groupFastPolicyStore, createGroupFastPolicyStore } = await import('../fastPolicyStore.js');
+const delegation = await import('../../device-link/providerShareDelegatedAccess.js');
+const { createProviderShareUsageStore } = await import('../../device-link/providerShareUsageStore.js');
+const { installRemoteAgentHost, disposeRemoteAgentHost } = await import('../../remote-agent/host/service.js');
let sequence = 0;
beforeEach(() => {
+ state.self = 'self';
+ state.direct = false;
+ state.planDevice = 'one';
+ state.approved = true;
+ state.delegatedAllowed = true;
+ state.modelChanged = undefined;
+ state.revoked = [];
+ state.pair = null;
+ state.failGrant = false;
+ state.delegateCalls = [];
+ state.usage = undefined;
+ state.check.mockReset().mockImplementation(async ({ executorDeviceId }) =>
+ state.pair?.executorDeviceId === executorDeviceId ? { active: true, ...state.pair } : { active: false });
state.owner = `owner-${++sequence}`;
+ state.shareOwner = state.owner;
+ state.shares = [{ shareId: 'share', providerId: 'openai', providerLabel: 'OpenAI', hostDeviceId: 'self',
+ createdAt: '2026-10-28T00:00:00.000Z', requests: [],
+ members: [{ memberId: 'member', status: 'active', joinedAt: '2026-10-28T00:00:00.000Z',
+ displayName: 'Guest', avatarUrl: null, region: 'global' }] }];
state.subscription = true;
state.calls = [];
state.old.clear();
@@ -91,8 +231,242 @@ beforeEach(() => {
})),
};
});
+afterEach(async () => {
+ disposeRemoteAgentHost();
+ await state.usage?.flush();
+ vi.restoreAllMocks();
+});
afterAll(() => fs.rmSync(temporary, { recursive: true, force: true }));
+const guestPeer = providerShareGuestPeer('share', 'member', 'laptop');
+const directTask = (sessionId: string) => hostSessionIdFor(guestPeer, sessionId);
+const usageFile = () => path.join(temporary, state.owner, 'usage.json');
+async function installDirectHost() {
+ state.direct = true;
+ state.usage = createProviderShareUsageStore(usageFile());
+ // Host snapshot preparation persists the membership baseline before admission.
+ // Use the real ledger on initial install and restart; never bypass its cleanup fence.
+ await state.usage.reconcileMemberGenerations(state.owner, 'self', ownedShareSnapshot()!);
+ installRemoteAgentHost({ userDataDir: path.join(temporary, state.owner),
+ getMaker: () => { throw Error('Allocation must not start an agent on O'); } });
+}
+const allocate = (sessionId: string) => state.hostDeps!.directGuestExecution!.allocate(guestPeer,
+ { op: 'allocate', sessionId, agentKind: 'codex', model: 'gpt-5' });
+function failAllocationAt(stage: 'Fast' | 'commit' | 'register') {
+ if (stage === 'Fast') state.notify.mockRejectedValue(Error('native policy failed'));
+ else vi.spyOn(state.usage!, stage === 'commit' ? 'commitDirectReceiptRoute' : 'registerDirectReceiptRoute')
+ .mockRejectedValue(Error('journal write failed'));
+}
+
+// Unit / real installed O callbacks + durable journal. Previously only active
+// 30-minute receipts were tested: expiry/restart could send a native ID to M2.
+// Location grants no authority; the current guest and fresh lease still gate use.
+describe('durable direct task routing', () => {
+ const locate = (sessionId: string, peer = guestPeer) => state.hostDeps!.directGuestExecution!.locate!(peer,
+ { op: 'direct-locate', sessionId });
+ // Unit integration: O's live budget has no offline delegated enforcement.
+ // Exercise real allocation, policy callback and M lease revocation together.
+ it('withdraws direct leases when a member requires live budget checks, preserving history affinity', async () => {
+ await installDirectHost();
+ await allocate('budget-history');
+ expect(delegation.delegatedProviderShareTaskAccess(guestPeer, 'budget-history')).not.toBeNull();
+ state.delegatedAllowed = false;
+ state.modelChanged!();
+ await vi.waitFor(() => expect(delegation.delegatedProviderShareTaskAccess(guestPeer, 'budget-history')).toBeNull());
+ expect(await allocate('budget-new')).toBeNull();
+ expect(await allocate('budget-history')).toBeNull();
+ expect(await locate('budget-history')).toEqual({ deviceId: 'one' });
+ state.delegatedAllowed = true;
+ expect((await allocate('budget-history'))?.deviceId).toBe('one');
+ });
+ it('renews the original M after 31 minutes and O restart, despite a new M2 plan', async () => {
+ await installDirectHost();
+ const first = await allocate('history');
+ expect(first?.deviceId).toBe('one');
+ disposeRemoteAgentHost();
+ await state.usage!.flush();
+ // Advance the persisted receipt's age instead of the OS file-lock clock.
+ // This is the disk image an O restart sees 31 minutes after allocation.
+ const persisted = JSON.parse(fs.readFileSync(usageFile(), 'utf8'));
+ for (const route of persisted.directReceiptRoutes) route.expiresAt -= 31 * 60_000;
+ fs.writeFileSync(usageFile(), JSON.stringify(persisted));
+ state.planDevice = 'two';
+ await installDirectHost();
+ expect(await allocate('history')).toMatchObject({ deviceId: 'one' });
+ expect(await locate('history')).toEqual({ deviceId: 'one' });
+ expect(state.pair?.generation).not.toBe(first?.generation);
+ });
+
+ it('returns null for legacy history and never exposes another member or account location', async () => {
+ await installDirectHost();
+ expect(await allocate('history')).not.toBeNull();
+ expect(await locate('legacy')).toBeNull();
+ await expect(locate('history', providerShareGuestPeer('share', 'other-member', 'laptop'))).rejects.toThrow();
+ state.approved = false;
+ await expect(locate('history')).rejects.toThrow();
+ state.approved = true;
+ state.owner = 'another-account';
+ await expect(locate('history')).rejects.toThrow('REMOTE_AGENT_UNAVAILABLE');
+ });
+
+ it('keeps the pin and fails closed when M1 is unavailable or no longer allowed', async () => {
+ await installDirectHost();
+ expect(await allocate('history')).not.toBeNull();
+ state.planDevice = 'two';
+ state.offline.add('one');
+ expect(await allocate('history')).toBeNull();
+ expect(await locate('history')).toEqual({ deviceId: 'one' });
+ state.offline.clear();
+ state.config!.members = state.config!.members.filter((member) => member.key !== 'device:one:openai');
+ // Removal changes the new-task pool, not the location of existing history.
+ expect(await allocate('history')).toMatchObject({ deviceId: 'one' });
+ state.revoked = ['one'];
+ expect(await allocate('history')).toBeNull();
+ expect(await locate('history')).toEqual({ deviceId: 'one' });
+ expect(await state.hostDeps!.directGuestExecution!.allocate(guestPeer,
+ { op: 'allocate', sessionId: 'history', agentKind: 'codex', model: 'gpt-5', preferredExecutorDeviceId: 'two' })).toBeNull();
+ });
+
+ it('clears the durable pin only when O accepts the switch token', async () => {
+ await installDirectHost();
+ expect(await allocate('history')).not.toBeNull();
+ state.planDevice = 'two';
+ const direct = state.hostDeps!.directGuestExecution!;
+ const { token } = await direct.switch(guestPeer, { op: 'direct-switch', sessionId: 'history' });
+ expect(token).toBeTruthy();
+ expect(await locate('history')).toEqual({ deviceId: 'one' });
+ const handoff = vi.spyOn(state.usage!, 'markDirectTaskRelayed')
+ .mockRejectedValueOnce(Error('handoff journal write failed'));
+ await expect(direct.switched!(guestPeer, 'history', token!)).rejects.toThrow('handoff journal write failed');
+ expect(await locate('history')).toEqual({ deviceId: 'one' });
+ handoff.mockRestore();
+ await direct.switched!(guestPeer, 'history', token!);
+ disposeRemoteAgentHost();
+ await state.usage!.flush();
+ await installDirectHost();
+ expect(await locate('history')).toBeNull();
+ });
+
+ it('retains historical affinity on release but clears it on accepted fresh O fallback', async () => {
+ await installDirectHost();
+ const first = await allocate('history');
+ const direct = state.hostDeps!.directGuestExecution!;
+ await direct.release(guestPeer, { op: 'direct-release', sessionId: 'history', generation: first!.generation });
+ expect(await locate('history')).toEqual({ deviceId: 'one' });
+ await expect(direct.acceptRelay!(guestPeer, 'history', true)).rejects.toThrow();
+ await direct.acceptRelay!(guestPeer, 'history', false);
+ disposeRemoteAgentHost();
+ await state.usage!.flush();
+ await installDirectHost();
+ expect(await locate('history')).toBeNull();
+ });
+});
+
+// Production entry: installRemoteAgentHost's allocate + real M delegation/Fast
+// receiver and durable stores. Unit tier; transport, server pair API and member
+// selection are in-memory boundaries. Existing policy tests never allocated two
+// tasks or paused between Fast confirmation and granting an executable M lease.
+// Regression: B rollback must not revoke A's pair; group Fast prohibition must
+// be durable and applied before a guest can start (provider-groups.md §15).
+describe('direct allocation authorization and Fast prebinding', () => {
+ it.each(['Fast', 'commit', 'register'] as const)(
+ 'keeps A executable when new B fails at %s', async (stage) => {
+ await installDirectHost();
+ expect(await allocate('task_a')).not.toBeNull();
+ failAllocationAt(stage);
+ expect(await allocate('task_b')).toBeNull();
+ expect(state.pair).not.toBeNull();
+ expect(delegation.delegatedProviderShareSessionAllowed(guestPeer, 'task_a')).toBe(true);
+ expect(delegation.delegatedProviderShareSessionAllowed(guestPeer, 'task_b')).toBe(false);
+ expect(state.usage!.listActiveDirectReceiptRoutes(state.owner).map((route) => route.sessionId))
+ .toEqual(['task_a']);
+ },
+ );
+
+ it.each(['Fast', 'commit', 'register'] as const)(
+ 'keeps sibling A authorized when B renewal and its restoration fail at %s', async (stage) => {
+ await installDirectHost();
+ expect(await allocate('task_a')).not.toBeNull();
+ expect(await allocate('task_b')).not.toBeNull();
+ failAllocationAt(stage);
+ expect(await allocate('task_b')).toBeNull();
+ expect(state.pair).not.toBeNull();
+ expect(delegation.delegatedProviderShareSessionAllowed(guestPeer, 'task_a')).toBe(true);
+ },
+ );
+
+ it('revokes an unsuccessful allocation pair when no valid sibling needs it', async () => {
+ await installDirectHost();
+ failAllocationAt('Fast');
+ expect(await allocate('task_b')).toBeNull();
+ expect(state.pair).toBeNull();
+ expect(delegation.delegatedProviderShareSessionAllowed(guestPeer, 'task_b')).toBe(false);
+ });
+
+ it.each(['provisional', 'moved'] as const)(
+ 'does not preserve a pair for an obsolete committed sibling superseded by a %s assignment', async (latest) => {
+ await installDirectHost();
+ expect(await allocate('task_a')).not.toBeNull();
+ const oldA = state.usage!.listActiveDirectReceiptRoutes(state.owner)[0];
+ const newer = { ...oldA, generation: randomUUID(), committedAt: undefined,
+ ...(latest === 'moved' ? { executorDeviceId: 'two', memberKey: 'device:two:openai' } : {}) };
+ await state.usage!.registerDirectReceiptRoute(newer);
+ if (latest === 'moved') await state.usage!.commitDirectReceiptRoute(newer);
+ disposeRemoteAgentHost();
+ await state.usage!.flush();
+ await installDirectHost();
+ failAllocationAt('Fast');
+ expect(await allocate('task_b')).toBeNull();
+ expect(state.pair).toBeNull();
+ },
+ );
+
+ it('has no executable guest lease while durable Fast policy is still awaiting application', async () => {
+ await installDirectHost();
+ let entered!: () => void;
+ let release!: () => void;
+ const applying = new Promise<void>((resolve) => { entered = resolve; });
+ const applied = new Promise<void>((resolve) => { release = resolve; });
+ state.notify.mockImplementationOnce(() => { entered(); return applied; });
+ const pending = allocate('task_a');
+ await applying;
+ const executableBeforeAck = delegation.delegatedProviderShareSessionAllowed(guestPeer, 'task_a');
+ const fastBeforeAck = groupFastPolicyStore.allows(directTask('task_a'));
+ release();
+ expect(await pending).not.toBeNull();
+ expect(executableBeforeAck).toBe(false);
+ expect(fastBeforeAck).toBe(false);
+ expect(delegation.delegatedProviderShareSessionAllowed(guestPeer, 'task_a')).toBe(true);
+ // Read fresh store instances to verify the restriction crossed the restart boundary.
+ const restarted = createGroupFastPolicyStore({ scopeKey: () => state.owner,
+ filePath: () => path.join(temporary, state.owner, 'provider-group-fast-policy.json') });
+ expect(restarted.allows(directTask('task_a'))).toBe(false);
+ });
+
+ it.each(['grant', 'Fast'] as const)(
+ 'preserves A after O restarts with provisional B and restoration fails at %s', async (stage) => {
+ await installDirectHost();
+ expect(await allocate('task_a')).not.toBeNull();
+ expect(await allocate('task_b')).not.toBeNull();
+ const oldB = state.usage!.listActiveDirectReceiptRoutes(state.owner).find((row) => row.sessionId === 'task_b')!;
+ const provisional = { ...oldB, generation: randomUUID(), committedAt: undefined };
+ await state.usage!.registerDirectReceiptRoute(provisional);
+ state.pair = { ...state.pair!, generation: provisional.generation };
+ disposeRemoteAgentHost();
+ await state.usage!.flush();
+ await installDirectHost();
+ if (stage === 'grant') state.failGrant = true;
+ else failAllocationAt('Fast');
+ state.hostChanged!();
+ await vi.waitFor(() => expect(state.delegateCalls.some((request) => request.op === 'delegate'
+ && request.action === 'revoke' && request.generation === provisional.generation)).toBe(true));
+ expect(state.pair).not.toBeNull();
+ expect(state.usage!.listActiveDirectReceiptRoutes(state.owner)
+ .some((row) => row.sessionId === 'task_a' && row.committedAt !== undefined)).toBe(true);
+ },
+ );
+});
+
function blockCapabilitiesRequest() {
let enter!: () => void;
let unblock!: () => void;
@@ -238,6 +612,29 @@ describe('group owner to executor enforcement handshake', () => {
await expect(
runtime.bindGroupFastPolicy({ group: 'openai', deviceId: 'one', sessionId: 'task' }),
).resolves.toBeUndefined();
+ await expect(runtime.bindGroupFastPolicy({ group: 'openai', deviceId: 'one', sessionId: 'task',
+ providerShareGuest: { shareId: 'share', memberId: 'member', guestDeviceId: 'laptop' } }))
+ .rejects.toThrow('REMOTE_AGENT_PEER_TOO_OLD');
+ });
+
+ it('binds an owner-approved direct guest task to the group Fast prohibition', async () => {
+ const guest = { shareId: 'share', memberId: 'member', guestDeviceId: 'laptop' };
+ const command = { group: 'openai', revision: 1, allowFast: false,
+ binding: { sessionId: 'task', providerShareGuest: guest } };
+ await expect(runtime.receiveGroupFastPolicy('owner', command)).rejects.toThrow('REMOTE_AGENT_INVALID');
+ state.pair = { ownerDeviceId: 'owner', executorDeviceId: 'self',
+ generation: randomUUID(), expiresAt: Date.now() + 60_000 };
+ await expect(runtime.receiveGroupFastPolicy('another-owner', command)).rejects.toThrow('REMOTE_AGENT_INVALID');
+ await runtime.receiveGroupFastPolicy('owner', command);
+ const task = hostSessionIdFor(providerShareGuestPeer('share', 'member', 'laptop'), 'task');
+ expect(groupFastPolicyStore.allows(task)).toBe(false);
+ expect(delegation.delegatedProviderShareSessionAllowed(guestPeer, 'task')).toBe(false);
+ expect(state.check).toHaveBeenLastCalledWith({ ...guest, executorDeviceId: 'self' });
+ // A previous task lease cannot substitute for a current server authorization.
+ state.pair.expiresAt = Date.now() - 1;
+ await expect(runtime.receiveGroupFastPolicy('owner', { ...command, revision: 2, allowFast: true }))
+ .rejects.toThrow('REMOTE_AGENT_INVALID');
+ expect(groupFastPolicyStore.allows(task)).toBe(false);
});
it('reports an unreachable executor as unavailable, without marking it as an old version', async () => {
@@ -296,3 +693,73 @@ describe('group owner to executor enforcement handshake', () => {
).toBe(false);
});
});
+
+// Unit / real O allocation + M delegation + usageStore. Existing budget tests
+// change policy after publication; hold the durable commit to exercise F4's
+// missing post-await admission, including rollback restoration of a previous lease.
+describe('direct commit admission races', () => {
+ it.each(['new', 'restore'] as const)('rejects a budget enabled during %s commit and retires that generation', async (stage) => {
+ await installDirectHost();
+ if (stage === 'restore') expect(await allocate('commit-race')).not.toBeNull();
+ const commit = state.usage!.commitDirectReceiptRoute.bind(state.usage!);
+ let release!: () => void;
+ let entered!: () => void;
+ const gate = new Promise<void>((resolve) => { release = resolve; });
+ const ready = new Promise<void>((resolve) => { entered = resolve; });
+ let commits = 0;
+ vi.spyOn(state.usage!, 'commitDirectReceiptRoute').mockImplementation(async (input) => {
+ if (stage === 'restore' && ++commits === 1) throw new Error('injected first commit failure');
+ entered();
+ await gate;
+ await commit(input);
+ });
+ const request = allocate('commit-race');
+ await ready;
+ state.delegatedAllowed = false;
+ state.modelChanged!();
+ release();
+ expect(await request).toBeNull();
+ expect(delegation.delegatedProviderShareTaskAccess(guestPeer, 'commit-race')).toBeNull();
+ await vi.waitFor(() => expect(state.usage!.listActiveDirectReceiptRoutes(state.owner)).toEqual([]));
+ expect(state.pair).toBeNull();
+ });
+ it('revokes only the failed model generation while an allowed sibling keeps its pair', async () => {
+ await installDirectHost();
+ const sibling = await allocate('sibling');
+ expect(sibling).not.toBeNull();
+ const access = (await import('../../device-link/remoteModelAccess.js')).remoteModelAccess;
+ const commit = state.usage!.commitDirectReceiptRoute.bind(state.usage!);
+ vi.spyOn(state.usage!, 'commitDirectReceiptRoute').mockImplementation(async (input) => {
+ vi.spyOn(access, 'allowsDelegatedExecution').mockImplementation((_provider, model) => model !== 'gpt-6');
+ state.modelChanged!();
+ await commit(input);
+ });
+ const result = await state.hostDeps!.directGuestExecution!.allocate(guestPeer,
+ { op: 'allocate', sessionId: 'failed-model', agentKind: 'codex', model: 'gpt-6' });
+ expect(result).toBeNull();
+ expect(delegation.delegatedProviderShareTaskAccess(guestPeer, 'failed-model')).toBeNull();
+ expect(delegation.delegatedProviderShareSessionAllowed(guestPeer, 'sibling')).toBe(true);
+ expect(delegation.delegatedProviderShareReceiptAuthority(guestPeer, 'sibling')?.generation).toBe(sibling!.generation);
+ expect(state.pair).not.toBeNull();
+ expect(state.usage!.listActiveDirectReceiptRoutes(state.owner).map((route) => route.sessionId)).toEqual(['sibling']);
+ });
+});
+
+// A post-commit check must compare the freshly restored generation, not g1.
+it('restores the previous authorized model after one failed renewal commit', async () => {
+ await installDirectHost();
+ const first = await allocate('renewal');
+ expect(first).not.toBeNull();
+ const commit = state.usage!.commitDirectReceiptRoute.bind(state.usage!);
+ vi.spyOn(state.usage!, 'commitDirectReceiptRoute')
+ .mockRejectedValueOnce(new Error('injected new model commit failure'))
+ .mockImplementation(commit);
+ expect(await state.hostDeps!.directGuestExecution!.allocate(guestPeer,
+ { op: 'allocate', sessionId: 'renewal', agentKind: 'codex', model: 'gpt-6' })).toBeNull();
+ expect(delegation.delegatedProviderShareModelAllowed(guestPeer, 'gpt-5', 'renewal')).toBe(true);
+ expect(delegation.delegatedProviderShareModelAllowed(guestPeer, 'gpt-6', 'renewal')).toBe(false);
+ const rows = state.usage!.listActiveDirectReceiptRoutes(state.owner);
+ expect(rows).toHaveLength(1);
+ expect(rows[0]).toMatchObject({ sessionId: 'renewal', model: 'gpt-5' });
+ expect(rows[0].generation).not.toBe(first!.generation);
+});
diff --git a/apps/desktop/src/main/provider-group/__tests__/guestSwitch.test.ts b/apps/desktop/src/main/provider-group/__tests__/guestSwitch.test.ts
index 9887103ffe..25fe715a62 100644
--- a/apps/desktop/src/main/provider-group/__tests__/guestSwitch.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/guestSwitch.test.ts
@@ -11,7 +11,7 @@ import {
} from '../guestSwitch';
describe('provider group guest switch tokens', () => {
- it('moves an offered token to the next open, once', () => {
+ it('keeps an offered token for a failed open, then releases it after success', () => {
const tokens = createProviderGroupGuestSwitch(() => 0);
expect(tokens.takeForOpen('s1')).toBeUndefined();
tokens.offer('s1', 'token-a');
@@ -19,6 +19,8 @@ describe('provider group guest switch tokens', () => {
expect(tokens.claim('s1')).toBe(false);
expect(tokens.takeForOpen('s2')).toBeUndefined();
expect(tokens.takeForOpen('s1')).toBe('token-a');
+ expect(tokens.takeForOpen('s1')).toBe('token-a');
+ tokens.release('s1');
expect(tokens.takeForOpen('s1')).toBeUndefined();
});
diff --git a/apps/desktop/src/main/provider-group/__tests__/service.test.ts b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
index fc0fd47b49..6c892ba043 100644
--- a/apps/desktop/src/main/provider-group/__tests__/service.test.ts
+++ b/apps/desktop/src/main/provider-group/__tests__/service.test.ts
@@ -1500,6 +1500,29 @@ describe('onTurnError for a shared user (the sharer’s group picks the computer
expect(h.deps.fallback).toHaveBeenCalledWith('s1', { message: '[REMOTE_AGENT_SHARE_PAUSED] paused' }, 3);
});
+ it('requests an O-issued switch for a live direct executor failure', async () => {
+ const h = guestHarness();
+ const direct = { ownerRoute: SHARE_ROUTE, requestSwitch: vi.fn(async () => 'token-direct-aaaaaaaaaaaa') };
+ const service = createProviderGroupService({ ...h.deps, guestSwitch: h.guestSwitch,
+ directGuestSession: () => direct });
+ const signals = { message: '[REMOTE_AGENT_UNAVAILABLE] executor disconnected' };
+ expect(service.mayHandleTurnError('s1', signals)).toBe(true);
+ await service.onTurnError('s1', signals, 7);
+ expect(direct.requestSwitch).toHaveBeenCalledTimes(1);
+ expect(h.guestSwitch.takeForOpen('s1')).toBe('token-direct-aaaaaaaaaaaa');
+ expect(h.deps.switchAgentLocation).toHaveBeenCalledTimes(1);
+ });
+
+ it('hands the direct error back when O declines the switch', async () => {
+ const h = guestHarness();
+ const service = createProviderGroupService({ ...h.deps, guestSwitch: h.guestSwitch,
+ directGuestSession: () => ({ ownerRoute: SHARE_ROUTE, requestSwitch: async () => undefined }) });
+ const signals = { message: '[REMOTE_AGENT_UNAVAILABLE] executor disconnected' };
+ await service.onTurnError('s1', signals, 7);
+ expect(h.deps.switchAgentLocation).not.toHaveBeenCalled();
+ expect(h.deps.fallback).toHaveBeenCalledTimes(1);
+ });
+
it('ignores a stale token, a token the user already took over from, and failures any computer would hit', async () => {
const stale = guestHarness();
stale.guestSwitch.offer('s1', 'token-aaaaaaaaaaaaaaaa');
diff --git a/apps/desktop/src/main/provider-group/fastPolicyRuntime.ts b/apps/desktop/src/main/provider-group/fastPolicyRuntime.ts
index f67793d018..20f0e3f260 100644
--- a/apps/desktop/src/main/provider-group/fastPolicyRuntime.ts
+++ b/apps/desktop/src/main/provider-group/fastPolicyRuntime.ts
@@ -1,4 +1,4 @@
-import { REMOTE_AGENT_CHANNEL, parseRemoteAgentCaps } from '@cindy/device-link';
+import { REMOTE_AGENT_CHANNEL, parseRemoteAgentCaps, providerShareGuestPeer } from '@cindy/device-link';
import type { RemoteAgentFastPolicy } from '@cindy/device-link';
import { supportsSubscriptionFastPolicy } from '@cindy/model-providers';
import { getSelfDeviceId, remoteBackgroundInvoke } from '../device-link/index.js';
@@ -8,6 +8,8 @@ import { captureProviderManagementScope } from './managementScope.js';
import { activeOwnerScopeKey } from '../appSessionState.js';
import { readProviderGroup, listProviderGroups } from './store.js';
import { groupFastPolicyStore } from './fastPolicyStore.js';
+import { checkProviderShareDelegation } from '../device-link/providerShareApi.js';
+import { hostSessionIdFor } from '../remote-agent/host/sessionIdentity.js';
const eligible = (group: string) =>
supportsSubscriptionFastPolicy(getActiveCatalog().providers.find((p) => p.id === group));
@@ -76,11 +78,28 @@ export async function receiveGroupFastPolicy(
command: RemoteAgentFastPolicy,
): Promise<unknown> {
const assertCurrent = captureProviderManagementScope();
+ const delegated = command.binding?.providerShareGuest;
+ let directTask: string | undefined;
+ if (delegated && command.binding) {
+ const guest = providerShareGuestPeer(delegated.shareId, delegated.memberId, delegated.guestDeviceId);
+ const self = getSelfDeviceId();
+ if (!self) throw new Error('[REMOTE_AGENT_UNAVAILABLE] Computer identity is not ready');
+ // Prebind before M grants an executable task lease. Only the server-approved
+ // O may name this guest's task; an unrelated same-account device is not O.
+ const approved = await checkProviderShareDelegation({ ...delegated, executorDeviceId: self });
+ assertCurrent();
+ if (getSelfDeviceId() !== self || !approved.active || approved.ownerDeviceId !== origin
+ || !approved.expiresAt || approved.expiresAt <= Date.now()) {
+ throw new Error('[REMOTE_AGENT_INVALID] Provider-share Fast binding requires an active owner delegation');
+ }
+ directTask = hostSessionIdFor(guest, command.binding.sessionId);
+ }
const result = await groupFastPolicyStore.receive(
origin,
command,
getSelfDeviceId(),
assertCurrent,
+ directTask,
);
await notifySubscriptionFastPolicyChanged();
assertCurrent();
@@ -118,6 +137,7 @@ export async function bindGroupFastPolicy(input: {
sessionId: string;
controllerDeviceId?: string;
relay?: string;
+ providerShareGuest?: { shareId: string; memberId: string; guestDeviceId: string };
}): Promise<void> {
if (!eligible(input.group)) return;
const assertCurrent = captureProviderManagementScope();
@@ -136,6 +156,7 @@ export async function bindGroupFastPolicy(input: {
sessionId: input.sessionId,
...(input.controllerDeviceId ? { controllerDeviceId: input.controllerDeviceId } : {}),
...(input.relay ? { relay: input.relay } : {}),
+ ...(input.providerShareGuest ? { providerShareGuest: input.providerShareGuest } : {}),
},
};
if (input.deviceId) {
@@ -149,8 +170,10 @@ export async function bindGroupFastPolicy(input: {
);
} catch (error) {
assertCurrent();
- // Allowed-by-default groups retain compatibility with old executors. A prohibition requires explicit support.
- if (!state.allowFast) throw error;
+ // A delegated direct task needs a durable per-task binding even while
+ // Fast is allowed, so a later group prohibition can reach this task.
+ // Legacy same-account relays retain allowed-by-default compatibility.
+ if (!state.allowFast || input.providerShareGuest) throw error;
}
} else {
const self = getSelfDeviceId();
diff --git a/apps/desktop/src/main/provider-group/guestSwitch.ts b/apps/desktop/src/main/provider-group/guestSwitch.ts
index 2a317641fc..54f55c0c82 100644
--- a/apps/desktop/src/main/provider-group/guestSwitch.ts
+++ b/apps/desktop/src/main/provider-group/guestSwitch.ts
@@ -2,7 +2,7 @@
* 分享的人这边的「需要换一台」(docs/product-rules/provider-groups.md §6.1「谁来执行换电脑 · 分享的人」)。
*
* 分享者把分享出来的供应商建成了组时,本机的任务由组所在电脑中转到组内某台电脑运行;本机看不到是哪台。那台
- * 因电脑本身的原因失败时,组所在电脑在事件流里先发来一张一次性凭证(排在那次错误前面)。本机据此自动交接
+ * 因电脑本身的原因失败时,组所在电脑在事件流里先发来一张短期凭证(排在那次错误前面)。本机据此自动交接
* (新建会话并带上交接上下文)后重新打开,打开时带回凭证,组所在电脑再为它换一台。
*
* 只有持有组所在电脑发来的凭证才换:分享被暂停、删除、撤权等是分享本身的问题,不会触发换电脑。
@@ -25,9 +25,9 @@ export interface ProviderGroupGuestSwitch {
hasOffer(sessionId: string): boolean;
/** 这次错误要不要换一台:有新鲜的凭证则取走,登记给下一次打开,返回 true。 */
claim(sessionId: string): boolean;
- /** 打开任务时带上的凭证(取走即用掉);没有返回 undefined。 */
+ /** 打开任务时带上的凭证;失败重开可重试,成功打开后由调用方 release。 */
takeForOpen(sessionId: string): string | undefined;
- /** 交接没成:作废登记给下一次打开的凭证。 */
+ /** 成功打开、交接取消或用户接手后作废凭证。 */
release(sessionId: string): void;
/**
* 用户亲自接手(发消息、重试、换模型):作废还没用上的凭证(含交接途中已登记、等重新打开带走的),
@@ -80,8 +80,11 @@ export function createProviderGroupGuestSwitch(now: () => number = Date.now): Pr
takeForOpen(sessionId) {
const entry = armed.get(sessionId);
- armed.delete(sessionId);
- if (!entry || now() - entry.at > PROVIDER_GROUP_SWITCH_ARMED_TTL_MS) return undefined;
+ if (!entry) return undefined;
+ if (now() - entry.at > PROVIDER_GROUP_SWITCH_ARMED_TTL_MS) {
+ armed.delete(sessionId);
+ return undefined;
+ }
return entry.token;
},
diff --git a/apps/desktop/src/main/provider-group/service.ts b/apps/desktop/src/main/provider-group/service.ts
index 23dedcf118..8b9703c097 100644
--- a/apps/desktop/src/main/provider-group/service.ts
+++ b/apps/desktop/src/main/provider-group/service.ts
@@ -202,7 +202,12 @@ export interface ProviderGroupServiceDeps {
/**
* 分享的人这边的「需要换一台」凭证(guestSwitch.ts);不提供 = 分享来的供应商出错时一律交回原有处理。
*/
- guestSwitch?: Pick<ProviderGroupGuestSwitch, 'hasOffer' | 'claim' | 'release' | 'drop'>;
+ guestSwitch?: Pick<ProviderGroupGuestSwitch, 'offer' | 'hasOffer' | 'claim' | 'release' | 'drop'>;
+ /** A live G→M handle may ask O for a bounded switch token after a run failure. */
+ directGuestSession?(sessionId: string): {
+ ownerRoute: string;
+ requestSwitch(): Promise<string | undefined>;
+ } | null;
/** 这个任务现在是否正在运行一轮。 */
isTurnRunning(sessionId: string): boolean;
/**
@@ -1408,7 +1413,16 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
const shareRoute = row?.agentDeviceId;
if (!row?.model || row.remoteHostId || !shareRoute || !isProviderShareAgentDeviceId(shareRoute)) return false;
if (!(await deps.isFailoverEligible(sessionId))) return false;
- if (!guestSwitch.claim(sessionId)) return false;
+ if (!guestSwitch.claim(sessionId)) {
+ const direct = deps.directGuestSession?.(sessionId);
+ if (!direct || direct.ownerRoute !== shareRoute || !lease || run.superseded
+ || !deps.isLeaseCurrent(sessionId, lease)) return false;
+ const offered = await direct.requestSwitch().catch(() => undefined);
+ if (!offered || run.superseded || !deps.isLeaseCurrent(sessionId, lease)
+ || deps.directGuestSession?.(sessionId) !== direct) return false;
+ guestSwitch.offer(sessionId, offered);
+ if (!guestSwitch.claim(sessionId)) return false;
+ }
// 检查期间用户已接手或错误已被新的一轮接管:不换,作废刚登记给下一次打开的凭证。
if (!lease || run.superseded || !deps.isLeaseCurrent(sessionId, lease)) {
guestSwitch.release(sessionId);
@@ -1830,7 +1844,8 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov
mayHandleTurnError(sessionId, signals) {
if (decideProviderGroupFailure(signals, 'run').action !== 'switch') return false;
const binding = deps.readBinding(sessionId);
- if (!binding) return deps.guestSwitch?.hasOffer(sessionId) === true;
+ if (!binding) return deps.guestSwitch?.hasOffer(sessionId) === true
+ || !!deps.directGuestSession?.(sessionId);
if (binding.groupDeviceId) return deps.remote !== undefined;
const config = deps.readGroup(binding.providerId);
const current = config?.members.find((m) => m.key === binding.memberKey);
diff --git a/apps/desktop/src/main/provider-group/store.ts b/apps/desktop/src/main/provider-group/store.ts
index 93cae5f96b..dabfd7346f 100644
--- a/apps/desktop/src/main/provider-group/store.ts
+++ b/apps/desktop/src/main/provider-group/store.ts
@@ -102,6 +102,18 @@ export function listProviderGroups(): Record<string, ProviderGroupConfig> {
return store.read().groups;
}
+const groupChangeListeners = new Set<(providerId: string) => void>();
+export function onProviderGroupChanged(listener: (providerId: string) => void): () => void {
+ groupChangeListeners.add(listener);
+ return () => { groupChangeListeners.delete(listener); };
+}
+function notifyProviderGroupChanged(providerId: string): void {
+ for (const listener of groupChangeListeners) {
+ try { listener(providerId); }
+ catch (error) { log.warn('provider group change listener failed', { error: String(error) }); }
+ }
+}
+
/** 写入一个供应商的组;config 校正后没有组内电脑即删除这个组。返回落盘后的值。 */
export async function writeProviderGroup(
providerId: string,
@@ -142,6 +154,7 @@ export async function writeProviderGroup(
return { groups, reshareCleanups, bindingCleanups };
}));
assertCurrent();
+ notifyProviderGroupChanged(providerId);
return next.groups[providerId] ?? null;
}
@@ -185,6 +198,7 @@ export async function updateProviderGroup(
}
return { groups, reshareCleanups };
});
+ notifyProviderGroupChanged(providerId);
return next.groups[providerId] ?? null;
}
diff --git a/apps/desktop/src/main/remote-agent/__tests__/execServerProjection.e2e.test.ts b/apps/desktop/src/main/remote-agent/__tests__/execServerProjection.e2e.test.ts
index 132f5f0b53..bd3bf728d3 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/execServerProjection.e2e.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/execServerProjection.e2e.test.ts
@@ -13,6 +13,103 @@ const REPO = path.resolve(__dirname, '../../../../../..');
const CODEX = path.join(REPO, 'apps', 'codex-package-bin', process.platform + '-' + process.arch, 'bin', process.platform === 'win32' ? 'codex.exe' : 'codex');
describe.skipIf(!fs.existsSync(CODEX))('native exec-server workspace projection', () => {
+ // 真机缺口:Mac Codex 把 Windows 执行环境的沙箱级别发成 disabled,Auto 终端全部被拒。
+ // e2e tier:实际 Relay → 原生 exec-server;工作区可写,区外及 .git 不可写,不能执行的 deny-read 仍拒绝。
+ it.skipIf(process.platform !== 'win32')('enforces a POSIX agent workspace policy on the Windows executor without removing unsupported restrictions', async () => {
+ const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-exec-sandbox-')));
+ const codexHome = path.join(root, 'codex-home');
+ fs.mkdirSync(codexHome);
+ const project = path.join(root, 'project');
+ fs.mkdirSync(project);
+ fs.mkdirSync(path.join(project, '.git'));
+ fs.writeFileSync(path.join(project, 'denied.txt'), 'isolated fixture');
+ const virtual = '/Users/agent/workspace';
+ const workspace = new ExecutorWorkspace({ workingDir: project, aliases: [{ from: virtual, to: project }] });
+ workspace.setVirtualRoot('/Users/agent');
+ const messages: Array<Record<string, any>> = [];
+ let parts = '';
+ const relay = new ExecServerRelay({
+ codexPath: CODEX, cwd: project, workspace, authorize: () => ({ ok: true }),
+ env: { ...process.env, CODEX_HOME: codexHome },
+ push: async (frames) => {
+ for (const frame of frames) {
+ if (frame.kind !== 'message') continue;
+ parts += frame.data;
+ if (!frame.more) { messages.push(JSON.parse(parts)); parts = ''; }
+ }
+ },
+ });
+ const send = (message: unknown) => relay.handle({ t: 'ws', connId: 'sandbox', kind: 'message', data: JSON.stringify(message) });
+ let backgroundPid: number | undefined;
+ const sandbox = {
+ permissions: { type: 'managed', network: 'restricted', file_system: { type: 'restricted', entries: [
+ { path: { type: 'special', value: { kind: 'root' } }, access: 'read' },
+ { path: { type: 'path', path: `file://${virtual}` }, access: 'write' },
+ { path: { type: 'path', path: `file://${virtual}/.git` }, access: 'read' },
+ ] } },
+ cwd: `file://${virtual}`, userHomeDir: 'file:///Users/agent',
+ temporaryDirectories: [`file://${virtual}`], windowsSandboxLevel: 'disabled',
+ };
+ const params = {
+ argv: [process.execPath, '-e', `const fs=require('node:fs');let r={};fs.writeFileSync('allowed.txt','ok');r.workspaceWrite=fs.readFileSync('allowed.txt','utf8')==='ok';for(const [k,p] of ${JSON.stringify([['outsideDenied', path.join(root, 'outside.txt')], ['gitDenied', path.join(project, '.git', 'outside.txt')]])}){try{fs.writeFileSync(p,'escape');r[k]=false}catch(e){r[k]=e.code==='EACCES'||e.code==='EPERM'}}console.log(JSON.stringify(r));if(!Object.values(r).every(Boolean))process.exitCode=3;`],
+ cwd: `file://${virtual}`, env: { SystemRoot: process.env.SystemRoot, TEMP: project, TMP: project }, tty: false, sandbox,
+ };
+ try {
+ relay.handle({ t: 'ws', connId: 'sandbox', kind: 'open', path: '/ws/exec-server' });
+ send({ id: 1, method: 'initialize', params: { clientName: 'cindy-test', clientVersion: '1' } });
+ await expect.poll(() => messages.find(item => item.id === 1), { timeout: 5000 }).toBeDefined();
+ send({ method: 'initialized', params: {} });
+ send({ id: 2, method: 'process/start', params: { ...params, processId: 'workspace' } });
+ await expect.poll(() => messages.find(item => item.id === 2), { timeout: 5000 }).toBeDefined();
+ expect(messages.find(item => item.id === 2)?.error).toBeUndefined();
+ expect(messages.find(item => item.id === 2)?.result.sandboxType).toBe('windowsRestrictedToken');
+ await expect.poll(() => messages.find(item => item.method === 'process/exited'), { timeout: 5000 }).toBeDefined();
+ expect(messages.find(item => item.method === 'process/exited')?.params.exitCode).toBe(0);
+ const output = messages.filter(item => item.method === 'process/output').map(item => Buffer.from(item.params.chunk, 'base64').toString()).join('');
+ expect(JSON.parse(output)).toEqual({ workspaceWrite: true, outsideDenied: true, gitDenied: true });
+ expect(fs.existsSync(path.join(root, 'outside.txt'))).toBe(false);
+ expect(fs.existsSync(path.join(project, '.git', 'outside.txt'))).toBe(false);
+ // Agent 按 initialize 宣告的 Shell 启动命令,不能只测 Node 而漏掉 Store 版 PowerShell。
+ const shell = messages.find(item => item.id === 1)?.result.environmentInfo.shell;
+ expect(shell.name).toBe('powershell');
+ send({ id: 3, method: 'process/start', params: { ...params, processId: 'shell',
+ argv: [shell.path, '-NoLogo', '-NoProfile', '-Command', "[Console]::WriteLine('CINDY_SANDBOX_SHELL_OK')"],
+ } });
+ await expect.poll(() => messages.find(item => item.id === 3), { timeout: 5000 }).toBeDefined();
+ expect(messages.find(item => item.id === 3)?.error).toBeUndefined();
+ await expect.poll(() => messages.find(item => item.method === 'process/exited' && item.params.processId === 'shell'), { timeout: 5000 }).toBeDefined();
+ expect(messages.find(item => item.method === 'process/exited' && item.params.processId === 'shell')?.params.exitCode).toBe(0);
+ expect(messages.filter(item => item.method === 'process/output' && item.params.processId === 'shell')
+ .map(item => Buffer.from(item.params.chunk, 'base64').toString()).join('')).toContain('CINDY_SANDBOX_SHELL_OK');
+ send({ id: 4, method: 'process/start', params: { ...params, processId: 'deny-read', sandbox: {
+ ...sandbox, permissions: { ...sandbox.permissions, file_system: { ...sandbox.permissions.file_system, entries: [
+ ...sandbox.permissions.file_system.entries,
+ { path: { type: 'path', path: `file://${virtual}/denied.txt` }, access: 'deny' },
+ ] } },
+ } } });
+ await expect.poll(() => messages.find(item => item.id === 4), { timeout: 5000 }).toBeDefined();
+ expect(messages.find(item => item.id === 4)?.error.message).toContain('refusing to run unsandboxed');
+ send({ id: 5, method: 'process/start', params: { ...params, processId: 'background',
+ argv: [process.execPath, '-e', "console.log('CHILD_PID:'+process.pid);setInterval(()=>{},1000)"],
+ } });
+ await expect.poll(() => {
+ const output = messages.filter(item => item.method === 'process/output' && item.params.processId === 'background')
+ .map(item => Buffer.from(item.params.chunk, 'base64').toString()).join('');
+ const match = /CHILD_PID:(\d+)/.exec(output);
+ backgroundPid = match ? Number(match[1]) : undefined;
+ return backgroundPid;
+ }, { timeout: 5000 }).toBeGreaterThan(0);
+ relay.close();
+ await expect.poll(() => {
+ try { process.kill(backgroundPid!, 0); return false; } catch { return true; }
+ }, { timeout: 3000 }).toBe(true);
+ } finally {
+ relay.close();
+ if (backgroundPid) try { process.kill(backgroundPid); } catch { /* 已随中继结束。 */ }
+ await fsp.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+ }
+ });
+
// 测试价值:生产入口 ExecServerRelay → 原生 exec-server 必须能从含空格的别名目录
// 启动程序。#6743 的旧实现把 argv[0] 当 Shell 文本引用,Windows 实际报 os error 123;
// 现有 E2E 只使用未映射的 process.execPath。最小失败输入是一个程序目录别名,e2e tier。
diff --git a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
index 0f14628381..4f799b3dd8 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts
@@ -7,6 +7,7 @@
* - 删掉受邀者时请 M 清掉它留下的东西,M 只清调用方自己的 relay。
*/
import fs from 'node:fs';
+import { createHash } from 'node:crypto';
import os from 'node:os';
import path from 'node:path';
@@ -57,11 +58,14 @@ function fakeAgentHost(name: string, started: Started[], options: {
guestRelayCapable?: boolean;
purge?: (hostSessionIds: readonly string[], nativeIds: readonly string[]) => Promise<void>;
groupRelay?: RemoteAgentGroupRelayDeps;
+ directGuestExecution?: Parameters<typeof createRemoteAgentHost>[0]['directGuestExecution'];
+ captureOwner?: () => unknown;
isAgentAvailable?: Parameters<typeof createRemoteAgentHost>[0]['isAgentAvailable'];
prepareImageEvent?: Parameters<typeof createRemoteAgentHost>[0]['prepareImageEvent'];
imageArtifacts?: Parameters<typeof createRemoteAgentHost>[0]['imageArtifacts'];
/** 这台的 Agent 启动失败(启动前受邀者目录已经建好)。 */
failStart?: boolean;
+ beforeStart?: (input: HostedStartInput) => Promise<void>;
/** 这台的 Agent 一启动就结束。 */
endImmediately?: boolean;
onSend?: (record: Started) => void | Promise<void>;
@@ -78,6 +82,7 @@ function fakeAgentHost(name: string, started: Started[], options: {
isAgentAvailable: options.isAgentAvailable ?? (() => true),
startHosted: async (input) => {
if (options.failStart) throw new Error('the agent could not start');
+ await options.beforeStart?.(input);
const queue: AgentEvent[] = [];
let wake: (() => void) | null = null;
let ended = false;
@@ -139,8 +144,9 @@ function fakeAgentHost(name: string, started: Started[], options: {
}),
...(options.purge ? { purgeHostedTranscripts: options.purge } : {}),
...(options.groupRelay ? { groupRelay: options.groupRelay } : {}),
+ ...(options.directGuestExecution ? { directGuestExecution: options.directGuestExecution } : {}),
...(options.reshare ? { reshare: options.reshare } : {}),
- captureOwner: () => 'owner',
+ captureOwner: options.captureOwner ?? (() => 'owner'),
isOwnerCurrent: () => true,
runsRoot: path.join(root, name),
});
@@ -219,6 +225,7 @@ function setup(options: {
owner?: { failStart?: boolean; onSend?: (record: Started) => void | Promise<void>;
prepareImageEvent?: Parameters<typeof createRemoteAgentHost>[0]['prepareImageEvent'];
modelAccess?: Partial<NonNullable<Parameters<typeof createRemoteAgentHost>[0]['providerAccess']>>;
+ directGuestExecution?: Parameters<typeof createRemoteAgentHost>[0]['directGuestExecution'];
isAgentAvailable?: Parameters<typeof createRemoteAgentHost>[0]['isAgentAvailable'] };
/** 截住组所在电脑发给组内电脑的请求(模拟回包丢失、应答慢)。 */
intercept?: (agentDeviceId: string, request: Record<string, unknown>, forward: () => Promise<unknown>) => Promise<unknown>;
@@ -417,7 +424,6 @@ describe('provider group relay for shared users', () => {
expect(await allows('claude-opus')).toBe(true);
executorAllowed = false;
expect(await allows('claude-opus')).toBe(false);
- expect(check).toHaveBeenCalledWith('shared-provider', GUEST_A, 'claude-sonnet');
} finally { await client.close('close', 'navigation'); }
} finally {
await ledger.flush();
@@ -664,6 +670,411 @@ describe('provider group relay for shared users', () => {
void a;
});
+ // Unit / real host.handle: service-only tests cannot prove old O history
+ // bypasses allocation or that accepted fallback reaches the durable handoff.
+ it('locates only for guests, preserves legacy O tasks, and claims a fresh fallback', async () => {
+ const started: Started[] = [];
+ const locate = vi.fn(async () => null);
+ const allocate = vi.fn(async () => ({ deviceId: 'member', generation: runId() }));
+ const acceptRelay = vi.fn(async () => undefined);
+ const direct = {
+ ownerScope: () => 'account', locate, allocate, acceptRelay,
+ status: () => undefined, release: async () => undefined, switch: async () => ({}),
+ sessionAllowed: () => true, sessionDelegated: () => false,
+ usage: () => undefined, delegate: async () => true, forget: () => true,
+ };
+ const makeHost = () => fakeAgentHost('legacy-location', started, {
+ trust: (controller) => controller === OWNER_DEVICE ? 'owner' : 'guest', directGuestExecution: direct,
+ });
+ let host = makeHost();
+ try {
+ await expect(host.handle(OWNER_DEVICE, { op: 'direct-locate', sessionId: SESSION })).rejects.toThrow('REMOTE_AGENT_INVALID');
+ expect(locate).not.toHaveBeenCalled();
+ expect(await host.handle(GUEST_A, { op: 'direct-locate', sessionId: SESSION })).toBeNull();
+ await host.handle(GUEST_A, { op: 'open', runId: runId(), agentKind: 'claude-code',
+ payload: { json: openPayload(SESSION) } });
+ await waitFor(() => started.length === 1);
+ expect(acceptRelay).toHaveBeenCalledWith(GUEST_A, SESSION, false);
+ const request = { op: 'allocate', agentKind: 'claude-code', model: 'claude-opus', sessionId: SESSION };
+ expect(await host.handle(GUEST_A, request)).toBeNull();
+ expect(allocate).not.toHaveBeenCalled();
+ await host.abortAll();
+ host.dispose();
+ host = makeHost();
+ expect(await host.handle(GUEST_A, request)).toBeNull();
+ expect(allocate).not.toHaveBeenCalled();
+ // Equal task IDs under a different guest have their own route namespace.
+ expect(await host.handle(GUEST_B, request)).toMatchObject({ deviceId: 'member' });
+ expect(allocate).toHaveBeenCalledTimes(1);
+ } finally {
+ await host.abortAll();
+ host.dispose();
+ }
+ });
+
+ // Direct G→M has no relay key. The production host entry must persist O's
+ // authenticated grant before allowing a later, idempotent deletion (unit tier).
+ it('forgets only the direct guest delegated by this owner, including after the lease is gone', async () => {
+ const started: Started[] = [];
+ const purge = vi.fn(async () => undefined);
+ const peer = providerShareGuestPeer('share-a', 'member-a', 'guest-pc');
+ const other = providerShareGuestPeer('share-b', 'member-b', 'other-pc');
+ let ownerGeneration = 1;
+ const directSessions = new Map<string, Set<string>>();
+ const makeHost = () => fakeAgentHost('direct-member', started, {
+ trust: (controller) => isProviderSharePeer(controller) ? 'guest' : 'owner', purge,
+ captureOwner: () => ({ ownerScopeKey: `account-one:${ownerGeneration}` }),
+ directGuestExecution: {
+ ownerScope: () => 'account-one',
+ allocate: async () => null, status: () => undefined, release: async () => undefined,
+ switch: async () => ({}),
+ sessionAllowed: (controller, sessionId) => directSessions.get(controller)?.has(sessionId) === true,
+ sessionDelegated: (controller, sessionId) => directSessions.get(controller)?.has(sessionId) === true,
+ usage: () => undefined,
+ delegate: async (_owner, request) => {
+ const key = providerShareGuestPeer(request.shareId, request.memberId, request.guestDeviceId);
+ const sessions = directSessions.get(key) ?? new Set<string>();
+ sessions.add(request.sessionId);
+ directSessions.set(key, sessions);
+ return true;
+ },
+ forget: (_owner, controller) => { directSessions.delete(controller); return true; },
+ },
+ });
+ let host = makeHost();
+ const grant = (shareId: string, memberId: string, guestDeviceId: string, cleanupEpoch = 1,
+ sessionId = 'task-direct') => ({
+ op: 'delegate' as const, action: 'grant' as const, shareId, memberId, guestDeviceId,
+ sessionId, providerId: 'shared-provider', model: 'claude-opus',
+ generation: '11111111-1111-4111-8111-111111111111', cleanupEpoch,
+ });
+ const open = (controller: string, sessionId: string, extra: Record<string, unknown> = {}, id = runId()) =>
+ host.handle(controller, { op: 'open', runId: id, agentKind: 'claude-code',
+ payload: { json: openPayload(sessionId, extra) } });
+ try {
+ const directRunId = runId(), relayRunId = runId();
+ await host.handle(OWNER_DEVICE, grant('share-a', 'member-a', 'guest-pc'));
+ await host.handle(OWNER_DEVICE, grant('share-b', 'member-b', 'other-pc', 1, 'task-other'));
+ await open(peer, 'task-direct', {}, directRunId);
+ await open(other, 'task-other');
+ await open(peer, 'task-relay', { relay: relayKeyFor(peer) }, relayRunId);
+ await waitFor(() => started.length === 3);
+ const directHome = started.find((item) => item.input.hostSessionId === hostSessionIdFor(peer, 'task-direct'))!.input.guestHome!;
+ const otherHome = started.find((item) => item.input.hostSessionId === hostSessionIdFor(other, 'task-other'))!.input.guestHome!;
+ const relayScope = `${peer}\0relay:${relayKeyFor(peer)}`;
+ const relayHome = started.find((item) => item.input.hostSessionId === hostSessionIdFor(relayScope, 'task-relay'))!.input.guestHome!;
+ const peerHash = createHash('sha256').update(peer).digest('hex').slice(0, 16);
+ const base = path.join(root, 'direct-member');
+ const directWorkspace = path.join(base, 'workspaces', peerHash, hostSessionIdFor(peer, 'task-direct'));
+ const directAttachments = path.join(base, 'attachments', peerHash, directRunId);
+ const relayWorkspace = path.join(base, 'workspaces', peerHash, hostSessionIdFor(relayScope, 'task-relay'));
+ const relayAttachments = path.join(base, 'attachments', peerHash, relayRunId);
+ // A restarted M has no live Run to clean. Recreate failed shutdown
+ // residue under the real on-disk layout, alongside same-peer relay data.
+ host.dispose();
+ await waitFor(() => !fs.existsSync(directWorkspace) && !fs.existsSync(relayWorkspace)
+ && !fs.existsSync(directAttachments) && !fs.existsSync(relayAttachments));
+ directSessions.clear();
+ host = makeHost();
+ for (const dir of [directHome, otherHome, relayHome, directWorkspace, directAttachments,
+ relayWorkspace, relayAttachments]) fs.mkdirSync(dir, { recursive: true });
+ const forget = { op: 'forget', directGuest: { shareId: 'share-a', memberId: 'member-a',
+ guestDeviceId: 'guest-pc', forgetId: '22222222-2222-4222-8222-222222222222', cleanupEpoch: 1 } };
+ await expect(host.handle('other-owner', forget)).rejects.toThrow('REMOTE_AGENT_INVALID');
+ await expect(host.handle(peer, forget)).rejects.toThrow('REMOTE_AGENT_INVALID');
+ ownerGeneration = 2; // same account, a newer app-session generation
+ await host.handle(OWNER_DEVICE, forget);
+ expect(purge).toHaveBeenCalledTimes(1);
+ expect(fs.existsSync(directHome)).toBe(false);
+ expect(fs.existsSync(otherHome)).toBe(true);
+ expect(fs.existsSync(relayHome)).toBe(true);
+ expect(fs.existsSync(directWorkspace)).toBe(false);
+ expect(fs.existsSync(directAttachments)).toBe(false);
+ expect(fs.existsSync(relayWorkspace)).toBe(true);
+ expect(fs.existsSync(relayAttachments)).toBe(true);
+ expect(purge).toHaveBeenCalledWith(expect.arrayContaining([hostSessionIdFor(peer, 'task-direct')]),
+ expect.arrayContaining([expect.stringContaining('sdk-direct-member')]));
+ await host.handle(OWNER_DEVICE, forget); // lost ACK: no second purge
+ expect(purge).toHaveBeenCalledTimes(1);
+ // A delayed old deletion can arrive after the same member rejoins on M.
+ await host.handle(OWNER_DEVICE, grant('share-a', 'member-a', 'guest-pc', 2, 'task-new'));
+ await open(peer, 'task-new');
+ await waitFor(() => started.length === 4);
+ const newHome = started.find((item) => item.input.hostSessionId === hostSessionIdFor(peer, 'task-new'))!.input.guestHome!;
+ await host.handle(OWNER_DEVICE, forget);
+ expect(fs.existsSync(newHome)).toBe(true);
+ expect(purge).toHaveBeenCalledTimes(1);
+ } finally {
+ await host.dispose();
+ }
+ });
+
+ // Unit / real host.handle + disk index: transcript-failure tests did not fail
+ // the tombstone's atomic rename. A failed rename followed by the same forget
+ // ID must keep rejecting (O keeps it pending), then survive retry and restart
+ // with no old native IDs (provider-sharing-direct-execution, deletion rules).
+ it('acknowledges a repeated direct forget only after its tombstone is durable', async () => {
+ const started: Started[] = [];
+ const peer = providerShareGuestPeer('share-durable', 'member-durable', 'guest-pc');
+ const sessions = new Set<string>();
+ const purge = vi.fn(async () => undefined);
+ const makeHost = () => fakeAgentHost('direct-forget-durable', started, {
+ trust: (controller) => isProviderSharePeer(controller) ? 'guest' : 'owner', purge,
+ directGuestExecution: {
+ ownerScope: () => 'account-one',
+ allocate: async () => null, status: () => undefined, release: async () => undefined,
+ switch: async () => ({}), usage: () => undefined,
+ sessionAllowed: (_controller, sessionId) => sessions.has(sessionId),
+ sessionDelegated: (_controller, sessionId) => sessions.has(sessionId),
+ delegate: async (_owner, request) => { sessions.add(request.sessionId); return true; },
+ forget: () => { sessions.clear(); return true; },
+ },
+ });
+ let host = makeHost();
+ const grant = (sessionId: string, cleanupEpoch: number) => host.handle(OWNER_DEVICE, {
+ op: 'delegate', action: 'grant', shareId: 'share-durable', memberId: 'member-durable', guestDeviceId: 'guest-pc',
+ sessionId, cleanupEpoch, providerId: 'shared-provider', model: 'claude-opus',
+ generation: '11111111-1111-4111-8111-111111111111',
+ });
+ const open = (sessionId: string, extra = {}) => host.handle(peer, {
+ op: 'open', runId: runId(), agentKind: 'claude-code', payload: { json: openPayload(sessionId, extra) },
+ });
+ const indexFile = path.join(root, 'direct-forget-durable', 'guest-sessions.json');
+ const readRecord = () => Object.values(JSON.parse(fs.readFileSync(indexFile, 'utf8')) as Record<string,
+ { controller: string; nativeIds: string[]; hostSessionIds: string[]; cleanupEpoch: number; lastDirectForgetId?: string }>)
+ .find((record) => record.controller === peer)!;
+ const request = { op: 'forget', directGuest: { shareId: 'share-durable', memberId: 'member-durable',
+ guestDeviceId: 'guest-pc', forgetId: '22222222-2222-4222-8222-222222222222', cleanupEpoch: 1 } };
+ let acknowledgements = 0;
+ const forget = () => host.handle(OWNER_DEVICE, request).then(() => { acknowledgements += 1; });
+ const originalRename = fs.promises.rename.bind(fs.promises);
+ let failRename = false;
+ let failedWrites = 0;
+ const rename = vi.spyOn(fs.promises, 'rename').mockImplementation(async (from, to) => {
+ if (String(to) === indexFile && failRename) {
+ failedWrites += 1;
+ throw Object.assign(new Error('injected guest index rename failure'), { code: 'EIO' });
+ }
+ return originalRename(from, to);
+ });
+ try {
+ await grant('old-task', 1);
+ await open('old-task');
+ await waitFor(() => started.length === 1 && readRecord().nativeIds.length === 1);
+ const oldNative = readRecord().nativeIds[0];
+ failRename = true;
+ await expect(forget()).rejects.toThrow('injected guest index rename failure');
+ await expect(forget()).rejects.toThrow('injected guest index rename failure');
+ expect(acknowledgements).toBe(0);
+ expect(failedWrites).toBe(2);
+ expect(readRecord().nativeIds).toEqual([oldNative]);
+ expect(readRecord().lastDirectForgetId).toBeUndefined();
+ failRename = false;
+ await forget();
+ expect(acknowledgements).toBe(1);
+ expect(readRecord()).toMatchObject({ hostSessionIds: [], nativeIds: [], cleanupEpoch: 1,
+ lastDirectForgetId: request.directGuest.forgetId });
+ const purges = purge.mock.calls.length;
+ host.dispose();
+ host = makeHost();
+ await forget();
+ expect(purge).toHaveBeenCalledTimes(purges);
+ expect(readRecord().nativeIds).toEqual([]);
+ await grant('new-task', 2);
+ await expect(open('new-task', { options: { resumeSessionId: oldNative } })).rejects.toThrow('REMOTE_AGENT_INVALID');
+ await open('new-task');
+ await waitFor(() => started.length === 2 && readRecord().nativeIds.length === 1);
+ await forget(); // old epoch must not delete the newly granted task
+ expect(readRecord().cleanupEpoch).toBe(2);
+ expect(readRecord().nativeIds).toEqual([`sdk-direct-forget-durable-${started[1].input.hostSessionId}`]);
+ expect(fs.existsSync(started[1].input.guestHome!)).toBe(true);
+ } finally {
+ rename.mockRestore();
+ await host.abortAll();
+ host.dispose();
+ }
+ });
+
+ // Host.handle regression (unit): sequential forget coverage missed F1/F2
+ // sharing an ID while F1 is still deleting transcripts. An early F2 ACK let
+ // a new epoch open before F1 overwrote its native IDs and cleanup epoch.
+ it.each([false, true])('joins duplicate direct forgets until cleanup settles (failure=%s)', async (failFirst) => {
+ const started: Started[] = [];
+ const peer = providerShareGuestPeer('share-race', 'member-race', 'guest-pc');
+ const sessions = new Set<string>();
+ let releasePurge!: () => void;
+ let enteredPurge!: () => void;
+ const purging = new Promise<void>((resolve) => { enteredPurge = resolve; });
+ const barrier = new Promise<void>((resolve) => { releasePurge = resolve; });
+ const purge = vi.fn(async () => undefined).mockImplementationOnce(async () => {
+ enteredPurge();
+ await barrier;
+ if (failFirst) throw new Error('transcript cleanup failed');
+ });
+ const host = fakeAgentHost('direct-forget-race', started, {
+ trust: (controller) => isProviderSharePeer(controller) ? 'guest' : 'owner', purge,
+ directGuestExecution: {
+ ownerScope: () => 'account-one',
+ allocate: async () => null, status: () => undefined, release: async () => undefined,
+ switch: async () => ({}), usage: () => undefined,
+ sessionAllowed: (_controller, sessionId) => sessions.has(sessionId),
+ sessionDelegated: (_controller, sessionId) => sessions.has(sessionId),
+ delegate: async (_owner, request) => { sessions.add(request.sessionId); return true; },
+ forget: () => { sessions.clear(); return true; },
+ },
+ });
+ const grant = (sessionId: string, cleanupEpoch: number) => host.handle(OWNER_DEVICE, {
+ op: 'delegate', action: 'grant', shareId: 'share-race', memberId: 'member-race', guestDeviceId: 'guest-pc',
+ sessionId, cleanupEpoch, providerId: 'shared-provider', model: 'claude-opus',
+ generation: '11111111-1111-4111-8111-111111111111',
+ });
+ const open = (sessionId: string) => host.handle(peer, { op: 'open', runId: runId(), agentKind: 'claude-code',
+ payload: { json: openPayload(sessionId, { projectFiles: [{ path: 'AGENTS.md', data: Buffer.from('new task').toString('base64') }] }) } });
+ const forget = { op: 'forget', directGuest: { shareId: 'share-race', memberId: 'member-race',
+ guestDeviceId: 'guest-pc', forgetId: '22222222-2222-4222-8222-222222222222', cleanupEpoch: 1 } };
+ const results: string[] = [];
+ const capture = (label: string, work: Promise<unknown>) => work.then(() => { results.push(`${label}:ok`); },
+ () => { results.push(`${label}:failed`); });
+ try {
+ await grant('old-task', 1);
+ await open('old-task');
+ await waitFor(() => started.length === 1);
+ const first = capture('F1', host.handle(OWNER_DEVICE, forget));
+ await purging;
+ const second = host.handle(OWNER_DEVICE, forget);
+ const secondResult = capture('F2', second);
+ const reopened = second.then(async () => {
+ await grant('new-task', 2);
+ await open('new-task');
+ }, () => undefined);
+ // Give the duplicate real file I/O a short scheduling window. F1 is held
+ // by an explicit barrier; no wall-clock timeout releases the deletion.
+ await new Promise((resolve) => setTimeout(resolve, 30));
+ const earlyResults = [...results];
+ releasePurge();
+ await Promise.all([first, secondResult, reopened]);
+ expect(earlyResults).toEqual([]);
+ expect(results.sort()).toEqual(failFirst ? ['F1:failed', 'F2:failed'] : ['F1:ok', 'F2:ok']);
+ expect(purge).toHaveBeenCalledTimes(1);
+ if (failFirst) {
+ // Failed cleanup must release its queue and dedupe entry for retry.
+ await host.handle(OWNER_DEVICE, forget);
+ await grant('new-task', 2);
+ await open('new-task');
+ }
+ await waitFor(() => started.length === 2);
+ const session = started[1].input;
+ const indexFile = path.join(root, 'direct-forget-race', 'guest-sessions.json');
+ await waitFor(() => fs.readFileSync(indexFile, 'utf8').includes(`sdk-direct-forget-race-${session.hostSessionId}`));
+ // Also reject a delayed older epoch with a different ID, after persistence.
+ await host.handle(OWNER_DEVICE, { ...forget, directGuest: { ...forget.directGuest,
+ forgetId: '33333333-3333-4333-8333-333333333333' } });
+ const records = JSON.parse(fs.readFileSync(indexFile, 'utf8')) as Record<string,
+ { controller: string; cleanupEpoch: number; nativeIds: string[] }>;
+ const record = Object.values(records).find((item) => item.controller === peer)!;
+ expect(record.cleanupEpoch).toBe(2);
+ expect(record.nativeIds).toContain(`sdk-direct-forget-race-${session.hostSessionId}`);
+ expect(fs.existsSync(session.guestHome!)).toBe(true);
+ expect(fs.readFileSync(path.join(session.shadowDir, 'AGENTS.md'), 'utf8')).toContain('new task');
+ } finally {
+ releasePurge();
+ host.dispose();
+ }
+ });
+
+ // Host.handle(open/forget/delegate), unit: forgetting during native startup
+ // must drain its late file writes before a newer grant/open. Sequential tests
+ // miss this; a same-peer relay and poll must still progress while it drains.
+ it('drains direct startup before forgetting and queues a newer grant/open without blocking relay or poll', async () => {
+ const started: Started[] = [];
+ const peer = providerShareGuestPeer('share-start', 'member-start', 'guest-pc');
+ const sessions = new Set<string>();
+ let releaseStart!: () => void;
+ let enteredStart!: () => void;
+ let revoked!: () => void;
+ const starting = new Promise<void>((resolve) => { enteredStart = resolve; });
+ const barrier = new Promise<void>((resolve) => { releaseStart = resolve; });
+ const revoking = new Promise<void>((resolve) => { revoked = resolve; });
+ const oldSessionId = hostSessionIdFor(peer, 'old-task');
+ const purge = vi.fn(async () => undefined);
+ const host = fakeAgentHost('direct-start-race', started, {
+ trust: (controller) => isProviderSharePeer(controller) ? 'guest' : 'owner', purge,
+ beforeStart: async (input) => {
+ if (input.hostSessionId !== oldSessionId) return;
+ enteredStart();
+ await barrier;
+ // A native startup already in progress may still create its files
+ // after finishRun has marked the Run closing.
+ fs.mkdirSync(input.guestHome!, { recursive: true });
+ fs.writeFileSync(path.join(input.guestHome!, 'late-native.txt'), 'old history');
+ },
+ directGuestExecution: {
+ ownerScope: () => 'account-one',
+ allocate: async () => null, status: () => undefined, release: async () => undefined,
+ switch: async () => ({}), usage: () => undefined,
+ sessionAllowed: (_controller, sessionId) => sessions.has(sessionId),
+ sessionDelegated: (_controller, sessionId) => sessions.has(sessionId),
+ delegate: async (_owner, request) => { sessions.add(request.sessionId); return true; },
+ forget: () => { sessions.clear(); revoked(); return true; },
+ },
+ });
+ const grant = (sessionId: string, cleanupEpoch: number) => host.handle(OWNER_DEVICE, {
+ op: 'delegate', action: 'grant', shareId: 'share-start', memberId: 'member-start', guestDeviceId: 'guest-pc',
+ sessionId, cleanupEpoch, providerId: 'shared-provider', model: 'claude-opus',
+ generation: '11111111-1111-4111-8111-111111111111',
+ });
+ const oldRunId = runId();
+ const open = (sessionId: string, extra = {}, id = runId()) => host.handle(peer, { op: 'open', runId: id, agentKind: 'claude-code',
+ payload: { json: openPayload(sessionId, extra) } });
+ let pending: Promise<unknown> | undefined;
+ try {
+ await grant('old-task', 1);
+ await open('old-task', {}, oldRunId);
+ await starting;
+ let forgetAcknowledged = false;
+ const forget = host.handle(OWNER_DEVICE, { op: 'forget', directGuest: {
+ shareId: 'share-start', memberId: 'member-start', guestDeviceId: 'guest-pc',
+ forgetId: '22222222-2222-4222-8222-222222222222', cleanupEpoch: 1,
+ } }).then(() => { forgetAcknowledged = true; });
+ await revoking;
+ const newGrant = grant('new-task', 2);
+ const newOpen = open('new-task');
+ pending = Promise.all([forget, newGrant, newOpen]);
+ await open('relay-task', { relay: relayKeyFor(peer) });
+ await waitFor(() => started.some((item) => item.input.hostSessionId !== oldSessionId));
+ await host.handle(peer, { op: 'poll', runs: [{ runId: oldRunId, cursor: 0 }], waitMs: 0 });
+ await host.handle(OWNER_DEVICE, { op: 'delegate', action: 'grant',
+ shareId: 'other-share', memberId: 'other-member', guestDeviceId: 'other-pc',
+ sessionId: 'other-task', cleanupEpoch: 1, providerId: 'shared-provider', model: 'claude-opus',
+ generation: '11111111-1111-4111-8111-111111111111' });
+ expect(forgetAcknowledged).toBe(false);
+ expect(purge).not.toHaveBeenCalled();
+ expect(sessions.has('new-task')).toBe(false);
+ expect(sessions.has('other-task')).toBe(true);
+ releaseStart();
+ await pending;
+ await waitFor(() => started.length === 3);
+ const newSession = started.find((item) => item.input.hostSessionId === hostSessionIdFor(peer, 'new-task'))!.input;
+ expect(fs.existsSync(newSession.guestHome!)).toBe(true);
+ expect(fs.existsSync(path.join(newSession.guestHome!, 'late-native.txt'))).toBe(false);
+ const relaySession = started.find((item) => item.input.hostSessionId !== oldSessionId && item.input !== newSession)!.input;
+ expect(fs.existsSync(relaySession.guestHome!)).toBe(true);
+ expect(purge).toHaveBeenCalledTimes(1);
+ expect(purge).toHaveBeenCalledWith([oldSessionId], []);
+ const indexFile = path.join(root, 'direct-start-race', 'guest-sessions.json');
+ await waitFor(() => fs.readFileSync(indexFile, 'utf8').includes(`sdk-direct-start-race-${newSession.hostSessionId}`));
+ const records = JSON.parse(fs.readFileSync(indexFile, 'utf8')) as Record<string,
+ { controller: string; relay?: string; cleanupEpoch: number; nativeIds: string[] }>;
+ const record = Object.values(records).find((item) => item.controller === peer && !item.relay)!;
+ expect(record.cleanupEpoch).toBe(2);
+ expect(record.nativeIds).toEqual([`sdk-direct-start-race-${newSession.hostSessionId}`]);
+ } finally {
+ releaseStart();
+ await pending?.catch(() => undefined);
+ host.dispose();
+ }
+ });
+
it('runs a relayed task from a same-account computer as a shared user, never with owner trust', async () => {
const started: Started[] = [];
const member = fakeAgentHost('member', started, { trust: () => 'owner' });
@@ -706,6 +1117,57 @@ describe('provider group relay for shared users', () => {
await host.dispose();
}
});
+
+ // Direct routing regression (provider-sharing-direct-execution.md): Host.handle(open)
+ // must use M's server-checked task grant. Earlier cases all supplied groupAssigned,
+ // so a G omitting that untrusted hint made M forward to its own group (unit tier).
+ it('runs a delegated guest locally when G omits groupAssigned while ordinary guests still use the group', async () => {
+ const env = setup();
+ const started: Started[] = [];
+ const delegated = new Set<string>();
+ const directPeer = providerShareGuestPeer('share-a', 'member-a', 'guest-pc');
+ const ordinaryPeer = providerShareGuestPeer('share-b', 'member-b', 'guest-pc');
+ const grantKey = (controller: string, sessionId: string) => JSON.stringify([controller, sessionId]);
+ const host = fakeAgentHost('assigned-member', started, {
+ trust: (controller) => controller === OWNER_DEVICE ? 'owner' : 'guest',
+ groupRelay: env.relay,
+ directGuestExecution: {
+ ownerScope: () => 'account-one',
+ allocate: async () => null, status: () => undefined, release: async () => undefined,
+ switch: async () => ({}),
+ // Production sessionAllowed also permits an ordinary guest with no lease.
+ sessionAllowed: () => true,
+ sessionDelegated: (controller, sessionId) => delegated.has(grantKey(controller, sessionId)),
+ usage: () => undefined,
+ delegate: async (_owner, request) => {
+ delegated.add(grantKey(providerShareGuestPeer(request.shareId, request.memberId,
+ request.guestDeviceId), request.sessionId));
+ return false;
+ },
+ forget: () => true,
+ },
+ });
+ try {
+ await host.handle(OWNER_DEVICE, { op: 'delegate', action: 'grant',
+ shareId: 'share-a', memberId: 'member-a', guestDeviceId: 'guest-pc',
+ sessionId: 'direct-task', providerId: 'shared-provider', model: 'claude-opus',
+ generation: '11111111-1111-4111-8111-111111111111', cleanupEpoch: 1 });
+ await host.handle(directPeer, { op: 'open', runId: runId(), agentKind: 'claude-code',
+ payload: { json: openPayload('direct-task') } });
+ expect(env.relay.plan).not.toHaveBeenCalled();
+ await waitFor(() => started.length === 1);
+ expect(started[0].input.guest).toBe(true);
+ await host.handle(ordinaryPeer, { op: 'open', runId: runId(), agentKind: 'claude-code',
+ payload: { json: openPayload('ordinary-task') } });
+ await waitFor(() => env.memberStarted.mini.length === 1);
+ expect(env.relay.plan).toHaveBeenCalledTimes(1);
+ } finally {
+ for (const item of [host, env.owner, ...Object.values(env.members)]) {
+ await item.abortAll();
+ item.dispose();
+ }
+ }
+ });
});
describe('provider group relay: starting, load and cleanup', () => {
@@ -1233,8 +1695,15 @@ describe('provider group "switch to another computer" for shared users', () => {
}
});
- it('accepts a token only once, and only from the shared user and task it was sent to', async () => {
+ it('accepts a retried token only from the shared user and task it was sent to', async () => {
+ const switched = vi.fn(async () => undefined);
const env = setup({
+ owner: { directGuestExecution: {
+ ownerScope: () => 'owner', allocate: async () => null,
+ status: () => undefined, release: async () => undefined, switch: async () => ({}),
+ switched, sessionAllowed: () => true, sessionDelegated: () => false,
+ usage: () => undefined, delegate: async () => false, forget: () => false,
+ } },
plans: [
{ kind: 'member', ...MEMBER_MINI },
{ kind: 'member', ...MEMBER_STUDIO },
@@ -1255,12 +1724,14 @@ describe('provider group "switch to another computer" for shared users', () => {
const otherTask = await openAsGuest(env, GUEST_A, openPayload('task-2', { groupSwitchToken: token }));
expect(env.relay.plan).toHaveBeenLastCalledWith(expect.objectContaining({ exclude: new Set() }));
await otherTask.client.close('close', 'navigation');
+ expect(switched).not.toHaveBeenCalled();
const used = await openAsGuest(env, GUEST_A, openPayload(SESSION, { groupSwitchToken: token }));
expect(env.relay.plan).toHaveBeenLastCalledWith(expect.objectContaining({ exclude: new Set([MEMBER_MINI.memberKey]) }));
+ expect(switched).toHaveBeenCalledWith(GUEST_A, SESSION, token);
await used.client.close('close', 'navigation');
const again = await openAsGuest(env, GUEST_A, openPayload(SESSION, { groupSwitchToken: token }));
- expect(env.relay.plan).toHaveBeenLastCalledWith(expect.objectContaining({ exclude: new Set() }));
+ expect(env.relay.plan).toHaveBeenLastCalledWith(expect.objectContaining({ exclude: new Set([MEMBER_MINI.memberKey]) }));
await again.client.close('close', 'navigation');
});
@@ -1593,3 +2064,164 @@ describe('provider group reshare consent', () => {
await env.owner.abortAll();
});
});
+
+// Unit: real Host.handle and the existing disk/agent boundary fixture. F3 was
+// missed by write-only tombstone tests: one failed initial read, malformed tail,
+// or failed strict rename must not erase ownership or acknowledge cached state.
+describe('guest index failure recovery', () => {
+ const peer = providerShareGuestPeer('share-index', 'member-index', 'guest-pc');
+ const otherPeer = providerShareGuestPeer('share-other', 'member-other', 'other-pc');
+ const digest = (controller: string) => createHash('sha256').update(controller).digest('hex').slice(0, 32);
+ const forgetId = '22222222-2222-4222-8222-222222222222';
+ function setupIndex() {
+ const started: Started[] = [];
+ const leases = new Set<string>();
+ const host = fakeAgentHost('index-recovery', started, {
+ trust: (controller) => isProviderSharePeer(controller) ? 'guest' : 'owner',
+ directGuestExecution: {
+ ownerScope: () => 'account-one', allocate: async () => null,
+ status() {}, release: async () => {}, switch: async () => ({}), usage() {},
+ sessionAllowed: (_controller, sessionId) => leases.has(sessionId),
+ sessionDelegated: (_controller, sessionId) => leases.has(sessionId),
+ delegate: async (_owner, request) => {
+ if (request.action === 'grant') leases.add(request.sessionId);
+ else leases.delete(request.sessionId);
+ return true;
+ },
+ forget: () => true,
+ },
+ });
+ const file = path.join(root, 'index-recovery', 'guest-sessions.json');
+ fs.mkdirSync(path.dirname(file), { recursive: true });
+ const record = { controller: peer, hostSessionIds: [hostSessionIdFor(peer, 'old')], nativeIds: ['native-old'],
+ directOwnerDeviceId: OWNER_DEVICE, directOwnerScopeKey: 'account-one', cleanupEpoch: 9,
+ lastDirectForgetId: forgetId, attachmentRunIds: [forgetId], forkWorkspaces: { 'native-old': [forgetId] } };
+ const old = { [digest(peer)]: record, [digest(otherPeer)]: { controller: otherPeer, nativeIds: ['native-other'],
+ members: { 'native-other': { memberKey: 'device:old:provider', agentDeviceId: 'old-device', providerId: 'provider' } } } };
+ const grant = (owner = OWNER_DEVICE) => host.handle(owner, {
+ op: 'delegate', action: 'grant', shareId: 'share-index', memberId: 'member-index', guestDeviceId: 'guest-pc',
+ sessionId: 'old', cleanupEpoch: 9, providerId: 'shared-provider', model: 'claude-opus',
+ generation: '11111111-1111-4111-8111-111111111111',
+ });
+ const fork = (controller = peer, nativeId = 'native-old') => host.handle(controller, {
+ op: 'fork', agentKind: 'claude-code', sourceSessionId: 'old', sourceSdkSessionId: nativeId,
+ newSessionId: 'forked', providerId: 'shared-provider', model: 'claude-opus',
+ });
+ return { host, file, record, old, grant, fork, leases };
+ }
+ it.each(['EBUSY', 'EIO'])('retries an initial %s in the same host without replacing old safety records', async (code) => {
+ const env = setupIndex();
+ const original = JSON.stringify(env.old, null, 2);
+ fs.writeFileSync(env.file, original);
+ const read = fs.promises.readFile.bind(fs.promises);
+ let injected = false;
+ const spy = vi.spyOn(fs.promises, 'readFile').mockImplementation((async (...args: Parameters<typeof read>) => {
+ if (String(args[0]) === env.file && !injected) {
+ injected = true;
+ throw Object.assign(new Error(`injected ${code}`), { code });
+ }
+ return read(...args);
+ }) as typeof read);
+ try {
+ await expect(env.grant()).rejects.toThrow(`injected ${code}`);
+ expect(env.leases.size).toBe(0);
+ expect(fs.readFileSync(env.file, 'utf8')).toBe(original);
+ await env.grant();
+ const saved = JSON.parse(fs.readFileSync(env.file, 'utf8'));
+ expect(saved[digest(peer)]).toEqual(env.record);
+ expect(saved[digest(otherPeer)].nativeIds).toEqual(['native-other']);
+ expect(saved[digest(otherPeer)].members['native-other'].sameAccount).toBe(false);
+ await expect(env.fork(otherPeer)).rejects.toThrow('REMOTE_AGENT_INVALID');
+ await expect(env.fork()).resolves.toMatchObject({ newSdkSessionId: 'native-old-fork' });
+ // A same-account caller does not acquire the guest index boundary.
+ await expect(env.host.handle(OWNER_DEVICE, { op: 'caps' })).resolves.toMatchObject({ version: 1 });
+ } finally { spy.mockRestore(); await env.host.dispose(); }
+ });
+ it.each([
+ ['root', []], ['json', '{'], ['record', null], ['controller', 7], ['relay', []],
+ ['nativeIds', ['native', 1]], ['hostSessionIds', ['../unsafe']], ['attachmentRunIds', ['unsafe-path']],
+ ['forkWorkspaces', { native: ['unsafe-path'] }], ['members', { native: { memberKey: 'm', agentDeviceId: 'd' } }],
+ ['relayDevices', ['ok', null]], ['forgetPending', {}], ['directOwnerDeviceId', ''],
+ ['directOwnerScopeKey', false], ['cleanupEpoch', -1], ['lastDirectForgetId', 'bad'],
+ ['identity', 'different-controller'],
+ ])('rejects a corrupt %s without publishing a partial cache, then accepts a repaired file', async (field, value) => {
+ const env = setupIndex();
+ const tail = { ...env.record, controller: otherPeer };
+ const invalid = field === 'root' ? JSON.stringify(value) : field === 'json' ? String(value)
+ : JSON.stringify({ [digest(peer)]: env.record, [digest(otherPeer)]: field === 'record' ? value
+ : { ...tail, [field === 'identity' ? 'controller' : String(field)]: value } });
+ fs.writeFileSync(env.file, invalid);
+ try {
+ await expect(env.grant()).rejects.toThrow();
+ await expect(env.grant()).rejects.toThrow();
+ expect(env.leases.size).toBe(0);
+ expect(fs.readFileSync(env.file, 'utf8')).toBe(invalid);
+ fs.writeFileSync(env.file, JSON.stringify(env.old));
+ await env.grant();
+ expect(JSON.parse(fs.readFileSync(env.file, 'utf8'))[digest(peer)]).toEqual(env.record);
+ } finally { await env.host.dispose(); }
+ });
+ it('retains omitted legacy fields and all native ownership entries during migration', async () => {
+ const env = setupIndex();
+ const nativeIds = Array.from({ length: 20_001 }, (_, i) => `native-${i}`);
+ fs.writeFileSync(env.file, JSON.stringify({ [digest(peer)]: { controller: peer, nativeIds } }));
+ try {
+ await env.grant();
+ expect(JSON.parse(fs.readFileSync(env.file, 'utf8'))[digest(peer)].nativeIds).toEqual(nativeIds);
+ await expect(env.fork(peer, nativeIds.at(-1))).resolves.toMatchObject({ newSdkSessionId: 'native-20000-fork' });
+ } finally { await env.host.dispose(); }
+ });
+ it('does not cache an owner whose grant failed to persist', async () => {
+ const env = setupIndex();
+ fs.writeFileSync(env.file, JSON.stringify({}));
+ const rename = fs.promises.rename.bind(fs.promises);
+ const spy = vi.spyOn(fs.promises, 'rename').mockImplementation(async (from, to) => {
+ if (String(to) === env.file) throw new Error('injected rename failure');
+ return rename(from, to);
+ });
+ try {
+ await expect(env.grant()).rejects.toThrow('injected rename failure');
+ expect(env.leases.size).toBe(0);
+ expect(fs.readFileSync(env.file, 'utf8')).toBe('{}');
+ spy.mockRestore();
+ await expect(env.grant('replacement-owner')).resolves.toEqual({});
+ expect(JSON.parse(fs.readFileSync(env.file, 'utf8'))[digest(peer)].directOwnerDeviceId).toBe('replacement-owner');
+ } finally { spy.mockRestore(); await env.host.dispose(); }
+ });
+});
+
+// Strict session writes must remain retryable as well as initial owner writes.
+it('does not acknowledge a repeated direct fork whose native index write failed', async () => {
+ const peer = providerShareGuestPeer('share-write', 'member-write', 'guest-pc');
+ const host = fakeAgentHost('index-fork-write', [], {
+ trust: (controller) => isProviderSharePeer(controller) ? 'guest' : 'owner',
+ directGuestExecution: {
+ ownerScope: () => 'account-one', allocate: async () => null,
+ status() {}, release: async () => {}, switch: async () => ({}), usage() {},
+ sessionAllowed: () => true, sessionDelegated: () => true,
+ delegate: async () => true, forget: () => true,
+ },
+ });
+ const file = path.join(root, 'index-fork-write', 'guest-sessions.json');
+ const digest = createHash('sha256').update(peer).digest('hex').slice(0, 32);
+ const record = { controller: peer, nativeIds: ['native-old'], hostSessionIds: [],
+ directOwnerDeviceId: OWNER_DEVICE, directOwnerScopeKey: 'account-one', cleanupEpoch: 1 };
+ const original = JSON.stringify({ [digest]: record });
+ fs.mkdirSync(path.dirname(file), { recursive: true });
+ fs.writeFileSync(file, original);
+ const rename = fs.promises.rename.bind(fs.promises);
+ const spy = vi.spyOn(fs.promises, 'rename').mockImplementation(async (from, to) => {
+ if (String(to) === file) throw new Error('injected session index failure');
+ return rename(from, to);
+ });
+ const fork = () => host.handle(peer, { op: 'fork', agentKind: 'claude-code', sourceSessionId: 'old',
+ sourceSdkSessionId: 'native-old', newSessionId: 'forked', providerId: 'shared-provider', model: 'claude-opus' });
+ try {
+ await expect(fork()).rejects.toThrow('injected session index failure');
+ await expect(fork()).rejects.toThrow('injected session index failure');
+ expect(fs.readFileSync(file, 'utf8')).toBe(original);
+ spy.mockRestore();
+ await expect(fork()).resolves.toMatchObject({ newSdkSessionId: 'native-old-fork' });
+ expect(JSON.parse(fs.readFileSync(file, 'utf8'))[digest].nativeIds).toEqual(['native-old', 'native-old-fork']);
+ } finally { spy.mockRestore(); await host.dispose(); }
+});
diff --git a/apps/desktop/src/main/remote-agent/__tests__/groupRelayClaudeFork.e2e.test.ts b/apps/desktop/src/main/remote-agent/__tests__/groupRelayClaudeFork.e2e.test.ts
index bf51f3cad7..15ca089283 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/groupRelayClaudeFork.e2e.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/groupRelayClaudeFork.e2e.test.ts
@@ -80,7 +80,9 @@ describe.skipIf(!available)('a shared user forks a real Claude Code task through
await fs.promises.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
});
- it('forks on the member that ran it, and reports a failed native fork as such instead of an unavailable computer', { timeout: 180_000 }, async () => {
+ // Direct history lives only on M; the existing relay-only scenario cannot catch
+ // accidentally sending that native ID to O. Both routes use the real CLI (e2e).
+ it.each(['relay', 'direct'] as const)('forks native history on M with %s routing and preserves native failures', { timeout: 180_000 }, async route => {
const deps: AgentDeps = {
auth: {
getState: async () => ({ authenticated: true, identity: 'test', authSource: 'api-key' as const }),
@@ -100,7 +102,7 @@ describe.skipIf(!available)('a shared user forks a real Claude Code task through
startHosted: (input) => agent.startSession(hostedStartOptions(input)),
forkHosted: (_kind, opts) => agent.forkSdkSession(opts),
isControllerAuthorized: () => true,
- controllerTrust: () => 'owner',
+ controllerTrust: controller => controller === OWNER_DEVICE ? 'owner' : 'guest',
providerAccess: { resolve: async (_kind, _model, providerId) => providerId ?? MEMBER.providerId, isAllowed: () => true },
bindGuestProviderRoute: async () => ({ routeToken: 'route', modelIds: [MODEL], release: () => {} }),
captureOwner: () => 'owner',
@@ -145,7 +147,8 @@ describe.skipIf(!available)('a shared user forks a real Claude Code task through
log: { info: () => {}, warn: (msg, data) => { ownerWarnings.push({ msg, data }); } },
});
- const guestPoller = new RemoteAgentPoller(async (args) => roundTrip(await owner.handle(GUEST, roundTrip(args[0]))));
+ const executionHost = route === 'direct' ? member : owner;
+ const guestPoller = new RemoteAgentPoller(async (args) => roundTrip(await executionHost.handle(GUEST, roundTrip(args[0]))));
const events: AgentEvent[] = [];
let turnDone: () => void = () => {};
const turn = new Promise<void>((resolve) => { turnDone = resolve; });
@@ -181,13 +184,20 @@ describe.skipIf(!available)('a shared user forks a real Claude Code task through
const anchor = events.filter((event) => event.type === 'text').map((event) => event.agentMeta?.uuid)
.find((uuid): uuid is string => typeof uuid === 'string');
expect(anchor).toBeDefined();
- const fork = (upToMessageId: string, newSessionId: string, acceptsForkFailed = true) => owner.handle(GUEST, roundTrip({
+ const forkRequest = (upToMessageId: string, newSessionId: string, acceptsForkFailed = true) => roundTrip({
op: 'fork', sourceSessionId: 'guest-task', newSessionId, agentKind: 'claude-code',
sourceSdkSessionId: started.id, model: MODEL, upToMessageId,
...(acceptsForkFailed ? { acceptsForkFailed: true } : {}),
- }));
+ });
+ const fork = (upToMessageId: string, newSessionId: string, acceptsForkFailed = true) =>
+ executionHost.handle(GUEST, forkRequest(upToMessageId, newSessionId, acceptsForkFailed));
await expect(fork(anchor!, 'guest-child')).resolves.toMatchObject({ newSdkSessionId: expect.any(String) });
+ if (route === 'direct') {
+ await expect(owner.handle(GUEST, forkRequest(anchor!, 'wrong-owner-child'))).rejects.toThrow('REMOTE_AGENT_INVALID');
+ await expect(member.handle('share-other-guest', forkRequest(anchor!, 'wrong-guest-child'))).rejects.toThrow('REMOTE_AGENT_INVALID');
+ expect(relay.plan).not.toHaveBeenCalled();
+ }
const missing = '00000000-0000-4000-8000-000000000000';
const failure = await fork(missing, 'guest-child-2').then(() => null, (error: unknown) => error as Error);
@@ -197,7 +207,7 @@ describe.skipIf(!available)('a shared user forks a real Claude Code task through
msg: 'remote agent: native fork failed',
data: expect.objectContaining({ error: expect.objectContaining({ message: expect.stringContaining(missing) }) }),
})]);
- expect(ownerWarnings).toEqual([expect.objectContaining({
+ expect(ownerWarnings).toEqual(route === 'direct' ? [] : [expect.objectContaining({
msg: 'remote agent: a computer in the provider group could not fork the shared task',
data: expect.objectContaining({ error: expect.objectContaining({ code: 'REMOTE_AGENT_FORK_FAILED' }) }),
})]);
@@ -206,7 +216,7 @@ describe.skipIf(!available)('a shared user forks a real Claude Code task through
const legacy = await fork(missing, 'guest-child-3', false).then(() => null, (error: unknown) => error as Error);
expect(legacy?.message).toMatch(/^\[REMOTE_AGENT_UNAVAILABLE\]/);
} finally {
- for (const host of [owner, member]) { await host.abortAll(); host.dispose(); }
+ for (const host of [owner, member]) { await host.abortAll(); await host.purgeControllers(() => true); host.dispose(); }
}
});
});
diff --git a/apps/desktop/src/main/remote-agent/__tests__/guestHost.test.ts b/apps/desktop/src/main/remote-agent/__tests__/guestHost.test.ts
index 71b32fcbe8..bc52d54862 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/guestHost.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/guestHost.test.ts
@@ -647,9 +647,9 @@ describe('guest provider access and usage', () => {
samples: [{ model: 'claude-opus', turns: 1, inputTokens: 12, outputTokens: 3, cacheReadTokens: 0, cacheCreateTokens: 0, sdkCostUsd: 0.02 }],
};
expect(recordGuestUsage).toHaveBeenCalledTimes(1);
- expect(recordGuestUsage).toHaveBeenCalledWith(GUEST, usage);
+ expect(recordGuestUsage).toHaveBeenCalledWith(GUEST, usage, 'task-1');
expect(recordOwnerUsage).toHaveBeenCalledTimes(1);
- expect(recordOwnerUsage).toHaveBeenCalledWith(OWNER, usage);
+ expect(recordOwnerUsage).toHaveBeenCalledWith(OWNER, usage, 'task-2');
expect(host.activeControllers().sort()).toEqual([GUEST, OWNER].sort());
host.dispose();
});
diff --git a/apps/desktop/src/main/remote-agent/__tests__/mirror.test.ts b/apps/desktop/src/main/remote-agent/__tests__/mirror.test.ts
index 342f57426d..1aab4dd6bc 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/mirror.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/mirror.test.ts
@@ -3,9 +3,10 @@
* (Claude Code 的 ~/.claude、Codex 的 CODEX_HOME)随任务同步到那台;那台给出的影子路径逐级
* 映射回你这台的真实路径。
*/
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
import { once } from 'node:events';
import fs from 'node:fs';
+import fsp from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { pathToFileURL } from 'node:url';
@@ -13,6 +14,8 @@ import { pathToFileURL } from 'node:url';
import { LOCAL_AGENT_CLIENT, type AgentEvent, type AgentSessionHandle } from '@cindy/maker-core';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import WebSocket from 'ws';
+import { providerShareGuestPeer } from '@cindy/device-link';
+import { createProviderShareUsageStore } from '../../device-link/providerShareUsageStore';
import {
collectAncestorInstructionFiles,
@@ -24,7 +27,7 @@ import {
import { shadowAliases, startRemoteAgentSession } from '../controller/startRemote';
import { EXEC_SERVER_NOT_FOUND_CODE } from '../host/execServerShortcut';
import { createRemoteAgentHost, mirrorSegments, type HostedStartInput } from '../host/runHost';
-import { hostedStartOptions } from '../host/service';
+import { createProviderShareMemberPurger, hostedStartOptions } from '../host/service';
import { ExecutorWorkspace } from '../executor/workspace';
import { MAX_ANCESTOR_LEVELS } from '../wire';
@@ -45,6 +48,103 @@ function write(file: string, content: string): void {
fs.writeFileSync(file, content);
}
+// Unit tier: real membership ledger, host cleanup adapter and disk index. Controlled
+// legacy purge models its documented best-effort failure, which previously let a
+// reapproved member revive old native IDs / pending relay tombstones after restart.
+describe('reapproved member cleanup admission', () => {
+ it('cannot fork an old native session after a reused member ID is admitted again', async () => {
+ const ledger = path.join(root, 'usage.json');
+ let usage = createProviderShareUsageStore(ledger);
+ const controller = providerShareGuestPeer('s', 'm', 'G');
+ const identity = { ownerScope: 'owner', ownerDeviceId: 'O', shareId: 's', memberId: 'm' };
+ let joinedAt = 'g1';
+ const snapshot = () => [{ shareId: 's', members: [{ memberId: 'm', joinedAt }] }];
+ const forkHosted = vi.fn(async () => ({ newSdkSessionId: 'native-child', uuidMap: new Map() }));
+ const makeHost = () => createRemoteAgentHost({
+ isAgentAvailable: () => true, startHosted: async (input) => idleHandle(input), forkHosted,
+ isControllerAuthorized: () => usage.memberGenerationReady(identity, joinedAt), controllerTrust: () => 'guest',
+ providerAccess: { resolve: async () => 'shared', isAllowed: () => true },
+ bindGuestProviderRoute: async () => ({ routeToken: 'route-token', modelIds: ['claude-opus'], release() {} }),
+ purgeHostedTranscripts: async () => undefined,
+ captureOwner: () => 'owner', isOwnerCurrent: () => true, runsRoot: path.join(root, 'remote-agent'),
+ });
+ await usage.reconcileMemberGenerations('owner', 'O', snapshot());
+ let current = makeHost();
+ const fork = { op: 'fork', sourceSessionId: 'task-1', newSessionId: 'task-2', agentKind: 'claude-code',
+ sourceSdkSessionId: 'sdk-1', model: 'claude-opus', upToMessageId: 'message-1' };
+ try {
+ const runId = randomUUID();
+ await current.handle(controller, { op: 'open', runId, agentKind: 'claude-code', payload: { json: {
+ sessionId: 'task-1', virtualWorkspace: true, options: { model: 'claude-opus' },
+ workspace: { workingDir: '/guest/project', platform: 'darwin', shell: 'zsh' },
+ projectFiles: [], ancestorFiles: [], personal: { files: [] }, mcpServers: [],
+ } } });
+ await vi.waitFor(() => expect(fs.readFileSync(path.join(root, 'remote-agent', 'guest-sessions.json'), 'utf8')).toContain('sdk-1'));
+ await expect(current.handle(controller, fork)).resolves.toMatchObject({ newSdkSessionId: 'native-child' });
+ await current.handle(controller, { op: 'close', runId, mode: 'close', reason: 'navigation' });
+ current.dispose();
+ usage = createProviderShareUsageStore(ledger);
+ joinedAt = 'g2';
+ await usage.reconcileMemberGenerations('owner', 'O', snapshot());
+ current = makeHost();
+ await expect(current.handle(controller, fork)).rejects.toThrow();
+ const purge = createProviderShareMemberPurger({ userDataDir: root, usage, current,
+ ownerScope: () => 'owner', ownerDeviceId: () => 'O', isCurrent: () => true,
+ hasAccess: () => usage.memberGenerationReady(identity, joinedAt) });
+ await purge(() => true);
+ expect(usage.memberGenerationReady(identity, joinedAt)).toBe(true);
+ await expect(current.handle(controller, fork)).rejects.toThrow('REMOTE_AGENT_INVALID');
+ expect(forkHosted).toHaveBeenCalledTimes(1);
+ } finally { current.dispose(); }
+ });
+
+ it('waits for legacy relay forgets and preserves directory cleanup receipts after an index deletion failure', async () => {
+ const ledger = path.join(root, 'usage.json');
+ let usage = createProviderShareUsageStore(ledger);
+ const controller = providerShareGuestPeer('s', 'm', 'G');
+ const index = path.join(root, 'remote-agent', 'guest-sessions.json');
+ const home = path.join(root, 'remote-agent', 'guest-homes', createHash('sha256').update(controller).digest('hex').slice(0, 16));
+ const member = { ownerScope: 'owner', ownerDeviceId: 'O', shareId: 's', memberId: 'm' };
+ const snapshot = (joinedAt: string) => [{ shareId: 's', members: [{ memberId: 'm', joinedAt }] }];
+ await usage.reconcileMemberGenerations('owner', 'O', snapshot('g1'));
+ write(index, JSON.stringify({ old: { controller, nativeIds: ['old-native'], hostSessionIds: ['old-task'], relayDevices: ['M'] } }));
+ write(path.join(home, 'native-history'), 'private g1 data');
+ usage = createProviderShareUsageStore(ledger);
+ await usage.reconcileMemberGenerations('owner', 'O', snapshot('g2'));
+ const purgeControllers = vi.fn(async (match: (peer: string) => boolean) => {
+ expect(match(controller)).toBe(true);
+ write(index, JSON.stringify({ old: { controller, nativeIds: [], forgetPending: ['M'] } }));
+ });
+ const makePurger = () => createProviderShareMemberPurger({ userDataDir: root, usage,
+ current: { purgeControllers, activeControllers: () => [] }, ownerScope: () => 'owner', ownerDeviceId: () => 'O',
+ isCurrent: () => true, hasAccess: () => usage.memberGenerationReady(member, 'g2') });
+ await expect(makePurger()(() => true)).rejects.toThrow('legacy history cleanup is still pending');
+ expect(usage.memberGenerationReady(member, 'g2')).toBe(false);
+ // A pending relay forget must not be converted back to a live relayDevices entry.
+ expect(JSON.parse(fs.readFileSync(index, 'utf8')).old.forgetPending).toEqual(['M']);
+ write(path.join(home, 'native-history'), 'failed legacy directory deletion');
+ purgeControllers.mockImplementation(async () => { fs.rmSync(index); });
+ const originalRm = fsp.rm.bind(fsp);
+ const rm = vi.spyOn(fsp, 'rm').mockImplementation(async (target, options) => {
+ if (path.resolve(String(target)) === path.resolve(home)) throw new Error('guest home busy');
+ await originalRm(target, options);
+ });
+ await expect(makePurger()(() => true)).rejects.toThrow('guest home busy');
+ rm.mockRestore();
+ usage = createProviderShareUsageStore(ledger);
+ expect(usage.listPendingMemberCleanup('owner', 'O')[0]?.cleanupScopes).toContainEqual({ controller });
+ expect(usage.memberGenerationReady(member, 'g2')).toBe(false);
+ purgeControllers.mockImplementation(async () => undefined);
+ await makePurger()(() => true);
+ expect(fs.existsSync(home)).toBe(false);
+ expect(fs.existsSync(index)).toBe(false);
+ expect(usage.memberGenerationReady(member, 'g2')).toBe(true);
+ const purger = makePurger();
+ purgeControllers.mockImplementation(async (match) => { expect(match(controller)).toBe(false); });
+ await purger(() => true); // delayed duplicate must not delete a new g2 task
+ });
+});
+
describe('mirrorSegments', () => {
it('keeps each path level and replaces names the other computer cannot store', () => {
expect(mirrorSegments('/Users/me/my proj')).toEqual(['Users', 'me', 'my proj']);
diff --git a/apps/desktop/src/main/remote-agent/__tests__/providerAccess.test.ts b/apps/desktop/src/main/remote-agent/__tests__/providerAccess.test.ts
index 46a9c46b3e..46004c9bca 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/providerAccess.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/providerAccess.test.ts
@@ -15,7 +15,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { startRemoteAgentSession } from '../controller/startRemote';
import { createGuestProviderRouteBinder, guestProviderModelIds, resolveGuestProviderId, resolveSharedProviderId } from '../host/providerAccess';
import { createRemoteAgentHost, type HostedStartInput } from '../host/runHost';
-import { guestProviderModelAllowed, guestProviderRouteForToken, resetGuestProviderRoutesForTest } from '../../maker-host/guest-provider-route-store';
+import { captureGuestRequestUsage, guestProviderModelAllowed, guestProviderRouteForToken, resetGuestProviderRoutesForTest } from '../../maker-host/guest-provider-route-store';
const RG = path.resolve(__dirname, '../../../../../ripgrep-bin', `${process.platform}-${process.arch}`, process.platform === 'win32' ? 'rg.exe' : 'rg');
@@ -131,6 +131,26 @@ describe('guest proxy binding for direct shares and same-account group relays',
binding?.release();
}
});
+ // Unit integration: native receipt metering zeroes terminal counters. A
+ // delegated M must retain turn metering until its receipts can reach O.
+ it.each([false, true])('keeps the native usage owner correct for delegated=%s', async delegated => {
+ const provider = { ...view('openai', []), auth: { method: 'oauth', native: 'codex' },
+ models: { codex: [{ id: 'gpt', name: 'gpt', efforts: [], defaultEffort: null }] } } as unknown as ProviderView;
+ const record = vi.fn();
+ const binder = createGuestProviderRouteBinder({
+ readProviders: async () => [provider], recordRequestUsage: record,
+ receiptMeteringAllowed: () => !delegated,
+ guestAccess: () => ({ providerId: 'openai', memberId: 'alice' }),
+ ownerAllowed: () => true, providerAllowed: () => true,
+ modelAccess: { allows: () => true, read: () => ({ models: null, providerModels: null }) },
+ });
+ const route = await binder({ kind: 'codex', hostSessionId: 'metered-host', sessionId: 'metered-task',
+ providerId: 'openai', controller: providerShareGuestPeer('share', 'alice', 'phone'), isCurrent: () => true });
+ expect(route?.receiptMetering).toBe(!delegated);
+ expect(typeof captureGuestRequestUsage('metered-host', 'gpt')).toBe(delegated ? 'undefined' : 'function');
+ route?.release();
+ });
+
it('enforces a changed member budget on the next request and exempts same-account callers', async () => {
let blocked = true;
const checks: Array<string | undefined> = [];
@@ -140,8 +160,8 @@ describe('guest proxy binding for direct shares and same-account group relays',
modelAccess: { allows: () => true, read: () => ({ models: null, providerModels: null, memberBudget: { enabled: true, rules: [{}] } }) },
memberBudgetAllows: async (_provider, model, member) => { checks.push(member); return !member || !blocked || model === 'sonnet'; },
});
- const guest = await binder({ kind: 'claude-code', hostSessionId: 'guest-budget', providerId: 'spark', controller: providerShareGuestPeer('share', 'alice', 'phone'), isCurrent: () => true });
- const owner = await binder({ kind: 'claude-code', hostSessionId: 'owner-budget', providerId: 'spark', controller: 'owner-device', isCurrent: () => true });
+ const guest = await binder({ kind: 'claude-code', hostSessionId: 'guest-budget', sessionId: 'guest-task', providerId: 'spark', controller: providerShareGuestPeer('share', 'alice', 'phone'), isCurrent: () => true });
+ const owner = await binder({ kind: 'claude-code', hostSessionId: 'owner-budget', sessionId: 'owner-task', providerId: 'spark', controller: 'owner-device', isCurrent: () => true });
expect(guest!.modelIds).toEqual(['opus', 'sonnet']);
blocked = false;
checks.length = 0;
@@ -152,6 +172,63 @@ describe('guest proxy binding for direct shares and same-account group relays',
expect(await owner!.allowsModel!('opus')).toBe(true);
expect(checks).toEqual(['alice', 'alice', 'alice', undefined]);
});
+
+ // Provider groups may route concurrent tasks from one guest device to two
+ // local providers on the same M. The real proxy binding must use the task ID (unit tier).
+ it('pins each concurrent delegated task to its own local provider and model', async () => {
+ const peer = providerShareGuestPeer('share-1', 'member-1', 'guest-device');
+ const taskProviders = new Map([['task-spark', 'spark'], ['task-xd', 'xd']]);
+ const binder = createGuestProviderRouteBinder({
+ readProviders: async () => [view('spark', ['opus']), view('xd', ['haiku'])],
+ guestAccess: (_controller, sessionId) => {
+ const providerId = taskProviders.get(sessionId);
+ return providerId ? { providerId, memberId: 'member-1' } : null;
+ },
+ ownerAllowed: () => true, providerAllowed: () => true,
+ modelAllowed: (_controller, model, sessionId) =>
+ (sessionId === 'task-spark' && model === 'opus') || (sessionId === 'task-xd' && model === 'haiku'),
+ modelRestricted: () => true,
+ modelAccess: { allows: () => true, read: () => ({ models: null, providerModels: null }) },
+ });
+ const base = { kind: 'claude-code' as const, controller: peer, isCurrent: () => true };
+ const spark = await binder({ ...base, sessionId: 'task-spark', hostSessionId: 'host-spark', providerId: 'spark' });
+ const xd = await binder({ ...base, sessionId: 'task-xd', hostSessionId: 'host-xd', providerId: 'xd' });
+ expect(spark).not.toBeNull();
+ expect(xd).not.toBeNull();
+ expect(await spark!.allowsModel?.('opus')).toBe(true);
+ expect(await spark!.allowsModel?.('haiku')).toBe(false);
+ expect(await xd!.allowsModel?.('haiku')).toBe(true);
+ expect(await xd!.allowsModel?.('opus')).toBe(false);
+ expect(await binder({ ...base, sessionId: 'task-spark', hostSessionId: 'wrong-source', providerId: 'xd' }))
+ .toBeNull();
+ taskProviders.set('task-spark', 'xd');
+ expect(await spark!.allowsModel?.('opus')).toBe(false);
+ expect(await xd!.allowsModel?.('haiku')).toBe(true);
+ spark!.release();
+ xd!.release();
+ });
+
+ it('lists future switch models while the delegated task executes only its currently granted model', async () => {
+ const peer = providerShareGuestPeer('share-1', 'member-1', 'guest-device');
+ let grantedModel = 'opus';
+ const binder = createGuestProviderRouteBinder({
+ readProviders: async () => [view('spark', ['opus', 'sonnet'])],
+ guestAccess: () => ({ providerId: 'spark', memberId: 'member-1' }),
+ ownerAllowed: () => true, providerAllowed: () => true,
+ modelAllowed: (_controller, model, sessionId) => sessionId === 'task-1' && model === grantedModel,
+ modelRestricted: () => true,
+ modelAccess: { allows: () => true, read: () => ({ models: ['opus', 'sonnet'], providerModels: ['opus', 'sonnet'] }) },
+ });
+ const binding = await binder({ kind: 'claude-code', hostSessionId: 'host-task-1', sessionId: 'task-1',
+ providerId: 'spark', controller: peer, isCurrent: () => true });
+ expect(binding?.modelIds).toEqual(['opus', 'sonnet']);
+ expect(await binding?.allowsModel?.('opus')).toBe(true);
+ expect(await binding?.allowsModel?.('sonnet')).toBe(false);
+ grantedModel = 'sonnet';
+ expect(await binding?.allowsModel?.('opus')).toBe(false);
+ expect(await binding?.allowsModel?.('sonnet')).toBe(true);
+ binding?.release();
+ });
// Unit: an async authorization response must not resurrect a replaced binding.
it('rejects a failed grant query or one arriving after the task binding was released', async () => {
let finish!: (allowed: boolean) => void;
@@ -161,7 +238,7 @@ describe('guest proxy binding for direct shares and same-account group relays',
guestAccess: () => null, ownerAllowed: () => true, providerAllowed: () => true,
modelAccess: { allows: () => true, read: () => ({ models: null, providerModels: null }) },
});
- const binding = await binder({ kind: 'claude-code', hostSessionId: 'late', providerId: 'spark', controller: 'owner', isCurrent: () => true,
+ const binding = await binder({ kind: 'claude-code', hostSessionId: 'late', sessionId: 'source-late', providerId: 'spark', controller: 'owner', isCurrent: () => true,
relayModelAccess: { models: ['opus'], allows: () => unavailable ? Promise.reject(new Error('link unavailable')) : new Promise(resolve => { finish = resolve; }) } });
expect(binding!.modelIds).toEqual(['opus']);
expect(await guestProviderModelAllowed('spark', 'opus', 'late')).toBe(false);
@@ -187,7 +264,7 @@ describe('guest proxy binding for direct shares and same-account group relays',
read: (_providerId, memberId) => ({ models: [...(memberId ? memberModels : providerModels)], providerModels: [...providerModels] }),
},
});
- const input = { kind: 'claude-code' as const, hostSessionId: 'bound-guest', providerId: 'spark', controller, isCurrent: () => true };
+ const input = { kind: 'claude-code' as const, hostSessionId: 'bound-guest', sessionId: 'source-guest', providerId: 'spark', controller, isCurrent: () => true };
const binding = await binder(input);
expect(binding).not.toBeNull();
expect(binding!.modelIds).toEqual(['opus']);
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 2aa45ec230..f8a1afee5a 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts
@@ -1,3 +1,4 @@
+import { runSessionCreationAttempt, captureSessionCreationCancellation } from '../../localDb/sessionRuntimeCleanup';
/**
* 远程 Agent 端到端往返(两端同进程,经 JSON 序列化模拟设备互联):
* 控制端 startRemoteAgentSession ⇄ 被控端 createRemoteAgentHost ⇄ 假 Agent(经隧道回到控制端
@@ -19,9 +20,13 @@ import type {
} from '@cindy/maker-core';
import { LOCAL_AGENT_CLIENT, MAIN_OWNED_SEND_CONTEXT, Session } from '@cindy/maker-core';
import { createServer } from 'node:http';
+import { providerShareHostPeer } from '@cindy/device-link';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { RemoteAgentPoller } from '../controller/poller';
+import { RemoteAgentRunClient } from '../controller/runClient';
+import { RemoteExecutor } from '../executor/executor';
+import { ExecServerRelay } from '../controller/execServerRelay';
import { createDeviceAgentStarter } from '../controller/service';
import { credentialGrantFor, forgetCredentialGrants } from '../executor/credentialGrants';
import { cancelPendingRemoteStart, startRemoteAgentSession, type StartRemoteAgentDeps } from '../controller/startRemote';
@@ -29,6 +34,49 @@ import { createRemoteAgentHost, type HostedStartInput } from '../host/runHost';
import { PROVIDER_SHARE_CREDENTIAL_SESSION_APPROVAL } from '../../../shared/providerShareCredentialConsent';
import { DEFAULT_REMOTE_AGENT_LIMITS, type RemoteAgentLimits } from '../../../shared/remoteAgentLimits';
import { installDesktopInteractionHandler } from '../../maker-ipc/interactionRouter';
+import { authorizeSharedTaskExecutor, authorizeSharedTaskHistory, liveSharedTaskTarget } from '../controller/providerShareTaskLocation';
+
+const payloadCompression = vi.hoisted(() => ({ enabled: false, paused: false, calls: 0, finish: undefined as (() => void) | undefined }));
+// Controlled gzip completion exercises production payload cancellation without compression load or sockets.
+vi.mock('node:zlib', async importOriginal => {
+ const actual = await importOriginal<typeof import('node:zlib')>();
+ return { ...actual, gzip: (...args: unknown[]) => {
+ if (!payloadCompression.enabled) return (actual.gzip as (...values: unknown[]) => unknown)(...args);
+ payloadCompression.calls++;
+ const done = args.at(-1) as (error: Error | null, data: Buffer) => void;
+ const finish = () => done(null, Buffer.alloc(512 * 1024 + 1, 42));
+ payloadCompression.finish = finish;
+ if (!payloadCompression.paused) finish();
+ } };
+});
+
+const { historyInvoke, historyOpenLink, historyCloseEpoch, historyCrossRegion, historyLogger } = vi.hoisted(() => {
+ const noop = () => undefined;
+ const logger = { trace: noop, debug: noop, info: noop, warn: noop, error: noop, fatal: noop,
+ child: () => logger };
+ return { historyInvoke: vi.fn(), historyOpenLink: vi.fn(), historyCloseEpoch: vi.fn(() => 0),
+ historyCrossRegion: vi.fn(() => false), historyLogger: logger };
+});
+vi.mock('../../device-link/index.js', () => ({
+ remoteBackgroundInvoke: (...args: unknown[]) => historyInvoke(...args),
+ openRemoteLink: (...args: unknown[]) => historyOpenLink(...args),
+ getRemoteLinkCloseEpoch: () => historyCloseEpoch(),
+}));
+vi.mock('../../device-link/providerShareCrossRegion.js', () => ({
+ isCrossRegionProviderShareTarget: () => historyCrossRegion(),
+ renewCrossRegionProviderShareLink: (...args: unknown[]) => historyOpenLink(...args),
+}));
+vi.mock('../../device-link/providerShareGuest.js', () => ({
+ parseProviderShareAgentDeviceId: (device: string) => device.startsWith('share:') ? device.slice(6) : null,
+ findReceivedShare: () => ({ status: 'active' }),
+}));
+vi.mock('../../logger.js', () => ({ createLogger: () => historyLogger }));
+// The production starter collects only this fixture's supplied project, never the user's home.
+vi.mock('../controller/projectFiles', () => ({
+ collectAncestorInstructionFiles: async () => [], collectAncestorMarkers: async () => [],
+ collectInstructionImports: async () => [], collectPersonalConfig: async () => [],
+ collectProjectInstructionFiles: async () => [],
+}));
const RG = path.resolve(__dirname, '../../../../../ripgrep-bin', `${process.platform}-${process.arch}`, process.platform === 'win32' ? 'rg.exe' : 'rg');
const CONTROLLER = 'controller-device-1';
@@ -270,6 +318,204 @@ describe('remote agent round trip', () => {
expect(hostInputs).toEqual([]);
} finally { await host.dispose(); }
});
+ // 真机到期后控制端命令继续运行:unit 用真实 starter/host,验证本地资源不等已拒绝的远端 close。
+ // 新增结果:确切期限清理、续权重置期限、同执行端的另一任务保持可用;原测试只验证下一次请求被拒。
+ it.each(['expires', 'renewed', 'late-renewal'] as const)('releases only the expired shared task before an unavailable close RPC: %s', async mode => {
+ vi.useFakeTimers({ toFake: ['Date', 'performance', 'setTimeout', 'clearTimeout', 'setInterval', 'clearInterval'] });
+ const ownerRoute = 'share:lease-share';
+ const target = providerShareHostPeer('lease-share', 'executor-m');
+ let allowClose!: () => void;
+ const closeReady = new Promise<void>(resolve => { allowClose = resolve; });
+ let allowRenewal!: () => void;
+ const renewalReady = new Promise<void>(resolve => { allowRenewal = resolve; });
+ let lateGrantActive = false;
+ const disposed: string[] = [];
+ const member = createRemoteAgentHost({
+ readLimits: () => DEFAULT_REMOTE_AGENT_LIMITS, isAgentAvailable: () => true,
+ startHosted: async input => fakeHostedAgent(input), controllerTrust: () => 'guest',
+ isControllerAuthorized: () => true, providerAccess: { resolve: async () => 'shared-provider', isAllowed: () => true },
+ bindGuestProviderRoute: async () => ({ providerId: 'shared-provider', routeToken: 'fixture', modelIds: ['m', 'm2'], release() {} }),
+ captureOwner: () => 'owner', isOwnerCurrent: () => true, runsRoot: hostRoot,
+ });
+ historyInvoke.mockImplementation(async (device, _channel, [request]) => {
+ if (device === ownerRoute) {
+ if (request.op === 'allocate') {
+ if (mode === 'late-renewal' && request.model === 'm2') { await renewalReady; lateGrantActive = true; }
+ return { ok: true, result: { deviceId: 'executor-m',
+ generation: request.model === 'm2' ? '22222222-2222-4222-8222-222222222222' : '11111111-1111-4111-8111-111111111111',
+ leaseDurationMs: request.sessionId === 'sibling-task' ? 20_000 : 2_000 } };
+ }
+ if (request.op === 'direct-release' && request.sessionId === 'lease-task' && request.generation === '22222222-2222-4222-8222-222222222222') lateGrantActive = false;
+ return { ok: true, result: {} };
+ }
+ if (request.op === 'close') await closeReady;
+ const result = await member.handle(CONTROLLER, JSON.parse(JSON.stringify(request)));
+ return { ok: true, result: request.op === 'caps' ? { ...result as object, directGuestExecution: true } : result };
+ });
+ historyOpenLink.mockResolvedValue(undefined);
+ const start = createDeviceAgentStarter({
+ remoteInvoke: historyInvoke, rgPath: () => RG, mcpProviders: () => [],
+ prepareMcpBridge: async (_providers, _logger, ctx) => ({ disposeSessionCtx: () => { disposed.push(ctx.sessionId!); } }),
+ makerMemory: () => undefined, captureKnownFileBefore: async () => undefined, noteOpaqueTurnChange() {},
+ isSharedProviderDevice: () => true, logger: historyLogger, renewSharedProviderLink: peer => historyOpenLink(peer),
+ });
+ let handle: AgentSessionHandle | undefined;
+ let sibling: AgentSessionHandle | undefined;
+ try {
+ handle = await start({ agentKind: 'claude-code', deviceId: ownerRoute, options: { sessionId: 'lease-task', workingDir: project, model: 'm' } });
+ sibling = await start({ agentKind: 'claude-code', deviceId: ownerRoute, options: { sessionId: 'sibling-task', workingDir: project, model: 'm' } });
+ await vi.advanceTimersByTimeAsync(1000);
+ const lateChange = mode === 'late-renewal' ? handle.setModel!('m2') : undefined;
+ void lateChange?.catch(() => undefined);
+ if (mode === 'renewed') await handle.setModel?.('m2');
+ await vi.advanceTimersByTimeAsync(1001);
+ if (mode === 'renewed') {
+ expect(disposed).not.toContain('lease-task');
+ expect(liveSharedTaskTarget('lease-task', ownerRoute)).toBe(target);
+ await vi.advanceTimersByTimeAsync(1000);
+ }
+ expect(disposed).toContain('lease-task');
+ expect(liveSharedTaskTarget('lease-task', ownerRoute)).toBeNull();
+ expect(disposed).not.toContain('sibling-task');
+ expect(liveSharedTaskTarget('sibling-task', ownerRoute)).toBe(target);
+ if (lateChange) {
+ allowRenewal();
+ await expect(lateChange).rejects.toThrow(/closed/);
+ expect(lateGrantActive).toBe(false);
+ }
+ await expect(handle.send({ type: 'user', content: 'must not execute' })).rejects.toThrow(/closed|expired|authoriz/i);
+ } finally {
+ allowClose();
+ allowRenewal();
+ await handle?.close({ reason: 'account-boundary' });
+ await sibling?.close({ reason: 'account-boundary' });
+ await member.dispose();
+ vi.useRealTimers();
+ historyInvoke.mockReset(); historyOpenLink.mockReset();
+ }
+ });
+
+ // Production starter -> real M host regression (unit): after the 30-minute lease,
+ // G must locate native history and renew M instead of selecting a new machine.
+ // Existing startRemote tests bypass createDeviceAgentStarter and cannot catch that routing error.
+ // Real Mac restart left G's cached link ready but M's transport unconfirmed.
+ // Unit: the production starter and M host must resume after a fresh per-peer
+ // handshake; a close during allocation must cancel rather than reopen it.
+ it.each(['resume', 'new-task-transport-restarted', 'transport-restarted', 'cross-region-restarted', 'link-closed', 'unavailable', 'wrong-executor', 'open-failed', 'member-denied', 'timeout', 'invalid-lifetime'] as const)(
+ 'keeps a 31-minute shared native resume on its original executor: %s', async mode => {
+ const ownerRoute = 'share:history-share';
+ const target = providerShareHostPeer('history-share', 'executor-m');
+ let now = Date.now();
+ const date = vi.spyOn(Date, 'now').mockImplementation(() => now);
+ let leaseUntil = 0;
+ let historical = false;
+ let linkRefreshed = false;
+ let closeEpoch = 0;
+ historyCloseEpoch.mockImplementation(() => closeEpoch);
+ historyCrossRegion.mockReturnValue(mode === 'cross-region-restarted');
+ historyOpenLink.mockImplementation(async (peer: string) => {
+ expect(peer).toBe(target);
+ expect(now).toBeLessThan(leaseUntil);
+ linkRefreshed = true;
+ });
+ const calls: Array<{ device: string; request: Record<string, unknown> }> = [];
+ const member = createRemoteAgentHost({
+ readLimits: () => DEFAULT_REMOTE_AGENT_LIMITS,
+ isAgentAvailable: () => true,
+ startHosted: async input => { hostInputs.push(input); return fakeHostedAgent(input); },
+ controllerTrust: () => 'guest',
+ isControllerAuthorized: () => now < leaseUntil,
+ providerAccess: { resolve: async () => 'shared-provider', isAllowed: () => now < leaseUntil },
+ bindGuestProviderRoute: async () => ({ providerId: 'shared-provider', routeToken: 'fixture', modelIds: ['m'], release() {} }),
+ captureOwner: () => 'owner', isOwnerCurrent: () => true, runsRoot: hostRoot,
+ });
+ historyInvoke.mockImplementation(async (device, _channel, [request]) => {
+ calls.push({ device, request });
+ if (device === ownerRoute) {
+ if (request.op === 'direct-locate') {
+ if (mode === 'member-denied' || mode === 'timeout') return { ok: false,
+ error: { code: mode === 'timeout' ? 'TIMEOUT' : 'REMOTE_AGENT_UNAVAILABLE', message: mode } };
+ return { ok: true, result: { deviceId: 'executor-m' } };
+ }
+ if (request.op === 'allocate') {
+ if (historical && mode === 'unavailable') return { ok: true, result: null };
+ if (historical && mode === 'link-closed') closeEpoch++;
+ leaseUntil = now + 30 * 60_000;
+ return { ok: true, result: {
+ deviceId: historical && (mode === 'wrong-executor' || request.preferredExecutorDeviceId !== 'executor-m')
+ ? 'executor-other' : 'executor-m', generation: '11111111-1111-4111-8111-111111111111',
+ leaseDurationMs: historical && mode === 'invalid-lifetime' ? -1 : 30 * 60_000,
+ } };
+ }
+ if (request.op === 'direct-status' || request.op === 'direct-release') return { ok: true, result: {} };
+ return { ok: false, error: { code: 'REMOTE_AGENT_INVALID', message: 'O cannot use M native history' } };
+ }
+ if (device !== target) return { ok: false, error: { code: 'DEVICE_OFFLINE', message: 'another executor' } };
+ if (((historical && (mode === 'transport-restarted' || mode === 'cross-region-restarted'))
+ || mode === 'new-task-transport-restarted') && !linkRefreshed) {
+ return { ok: false, error: { code: 'TIMEOUT', message: 'executor transport was not reconfirmed' } };
+ }
+ if (historical && mode === 'open-failed' && request.op === 'open') {
+ return { ok: false, error: { code: 'REMOTE_AGENT_UNAVAILABLE', message: 'M disappeared after caps' } };
+ }
+ try {
+ const result = await member.handle(CONTROLLER, JSON.parse(JSON.stringify(request)));
+ return { ok: true, result: request.op === 'caps' ? { ...result as object, directGuestExecution: true } : result };
+ } catch (error) {
+ return { ok: false, error: { message: String(error) } };
+ }
+ });
+ const start = createDeviceAgentStarter({
+ remoteInvoke: historyInvoke, rgPath: () => RG, mcpProviders: () => [],
+ prepareMcpBridge: async () => null, makerMemory: () => undefined,
+ captureKnownFileBefore: async () => undefined, noteOpaqueTurnChange() {},
+ isSharedProviderDevice: () => true, logger: historyLogger,
+ renewSharedProviderLink: peer => historyOpenLink(peer),
+ });
+ const options = { sessionId: 'history-task', workingDir: project, model: 'm' };
+ let handle: AgentSessionHandle | undefined;
+ try {
+ handle = await start({ agentKind: 'claude-code', deviceId: ownerRoute, options });
+ const nativeId = handle.id;
+ expect(liveSharedTaskTarget(options.sessionId, ownerRoute)).toBe(target);
+ expect(liveSharedTaskTarget(options.sessionId, 'share:another-share')).toBeNull();
+ await handle.close();
+ handle = undefined;
+ expect(liveSharedTaskTarget(options.sessionId, ownerRoute)).toBeNull();
+ historical = true;
+ now += 31 * 60_000;
+ calls.length = 0;
+ const opening = start({ agentKind: 'claude-code', deviceId: ownerRoute,
+ options: { ...options, resumeSessionId: nativeId } });
+ if (mode === 'resume' || mode === 'new-task-transport-restarted' || mode === 'transport-restarted' || mode === 'cross-region-restarted') {
+ handle = await opening;
+ expect(handle.id).toBe(nativeId);
+ expect(hostInputs[1].options.resumeSessionId).toBe(nativeId);
+ expect(calls.find(({ request }) => request.op === 'allocate')?.request)
+ .toMatchObject({ sessionId: options.sessionId, preferredExecutorDeviceId: 'executor-m' });
+ // Even knowing this native ID cannot resume it under another guest identity.
+ const open = calls.find(({ request }) => request.op === 'open')!;
+ await expect(member.handle('other-guest', { ...open.request, runId: randomUUID() }))
+ .rejects.toThrow('REMOTE_AGENT_INVALID');
+ } else {
+ await expect(opening).rejects.toThrow();
+ expect(hostInputs).toHaveLength(1);
+ }
+ expect(calls[0]).toMatchObject({ device: ownerRoute, request: { op: 'direct-locate', sessionId: options.sessionId } });
+ expect(calls.filter(({ device }) => device === ownerRoute).some(({ request }) => JSON.stringify(request).includes(nativeId))).toBe(false);
+ expect(calls.filter(({ request }) => request.op === 'open').every(({ device }) => device === target)).toBe(true);
+ } finally {
+ await handle?.close();
+ await member.dispose();
+ date.mockRestore();
+ historyInvoke.mockReset();
+ historyOpenLink.mockReset();
+ historyCloseEpoch.mockReset().mockReturnValue(0);
+ historyCrossRegion.mockReset().mockReturnValue(false);
+ }
+ },
+ );
+
// 测试价值:真实两端启动入口的诊断协议;此前 24 秒创建等待无阶段记录。
// 原覆盖只验证执行结果,未保护成功/失败计时及内容不入日志。最小输入:一次启动或 MCP 拒绝。
// tier: unit,沿用本文件 loopback fixture,不启动真实 Agent、不做真实等待。
@@ -790,6 +1036,30 @@ describe('remote agent round trip', () => {
host.dispose();
});
+ // Direct G→M startup can fail after M has already opened a run. The failed
+ // controller must close that run before a G→O fallback can open another one.
+ it('closes a started remote run when its session descriptor is invalid', async () => {
+ const remoteClosed = vi.fn();
+ const host = createRemoteAgentHost({
+ isAgentAvailable: () => true,
+ startHosted: async (input) => {
+ const agent = fakeHostedAgent(input);
+ return { ...agent, id: '', async close() { remoteClosed(); await agent.close(); } };
+ },
+ isControllerAuthorized: () => true,
+ captureOwner: () => 'o',
+ isOwnerCurrent: () => true,
+ runsRoot: hostRoot,
+ });
+ try {
+ await expect(startRemoteAgentSession('claude-code',
+ { sessionId: 'failed-direct-open', workingDir: project, model: 'm' }, makeDeps(host)))
+ .rejects.toThrow('invalid session');
+ expect(remoteClosed).toHaveBeenCalledTimes(1);
+ expect(host.runCount()).toBe(0);
+ } finally { host.dispose(); }
+ });
+
// 2026-10-22 远程供应商调查:慢启动期间任务被删除,控制端不再等了,对方却在几分钟后仍启动 Agent 并跑完
// 这一轮(供应商组还会换电脑接着启动)。删除或归档时要让对方结束这个任务,迟到完成的启动也立刻关掉。
// #6844 review:旧用例只覆盖远端已开始启动;MCP 准备是更早的异步等待,删除后不得发出 open,已准备资源要释放。
@@ -818,7 +1088,7 @@ describe('remote agent round trip', () => {
expect(result).toBeInstanceOf(Error);
expect(String(result)).toContain('[REMOTE_AGENT_EXPIRED]');
expect(invoke).not.toHaveBeenCalled();
- expect(dispose).toHaveBeenCalledTimes(1);
+ await vi.waitFor(() => expect(dispose).toHaveBeenCalledTimes(1), { interval: 1, timeout: 1000 });
expect(host.limitUsage().total).toBe(0);
} finally {
finishPrepare();
@@ -852,7 +1122,7 @@ describe('remote agent round trip', () => {
expect(host.limitUsage().total).toBe(1);
cancelPendingRemoteStart(sessionId);
await expect(starting).rejects.toThrow('[REMOTE_AGENT_EXPIRED]');
- expect(host.limitUsage().total).toBe(0);
+ await vi.waitFor(() => expect(host.limitUsage().total).toBe(0), { interval: 1, timeout: 1000 });
finishStart();
await vi.waitFor(() => expect(closed).toHaveBeenCalledTimes(1));
expect(hostSends).toEqual([]);
@@ -918,3 +1188,417 @@ describe('remote agent round trip', () => {
host.dispose();
});
});
+
+// Unit: provider-sharing direct-execution lease boundary (runtime review F1/F2).
+// Existing roundtrips cover already-started handles. These inputs stop at MCP/started,
+// or spend the entire 2s allocation in caps, through the real service/startRemote/runClient.
+// Only transport delivery and native-process boundaries are fixtures; no sockets or agents.
+describe('shared startup lease budget', () => {
+ type Run = Parameters<RemoteAgentPoller['register']>[0];
+ const flush = async () => { for (let i = 0; i < 100; i++) await Promise.resolve(); };
+ const deferred = () => {
+ let resolve!: () => void;
+ const promise = new Promise<void>(done => { resolve = done; });
+ return { promise, resolve };
+ };
+ function fixture() {
+ const owner = 'share:startup-budget';
+ const target = providerShareHostPeer('startup-budget', 'executor-m');
+ const generation = '11111111-1111-4111-8111-111111111111';
+ const calls: Array<{ device: string; op: string; sessionId?: string; generation?: string; runId?: string }> = [];
+ const runs = new Map<string, Run>();
+ const sessions = new Map<string, string>();
+ const disposed: string[] = [];
+ const pendingClose = deferred();
+ const prepare = deferred();
+ const allocation = deferred();
+ let allocations = 0;
+ const state = { device: 'executor-m' as unknown, duration: 2000 as unknown, delayCaps: 0, ready: false, blockClose: false, blockPrepare: false, blockAllocation: false };
+ const emit = (run: Run, value: unknown) => run.onData(Buffer.from(JSON.stringify(value) + '\n'), false);
+ const started = (run: Run) => emit(run, { t: 'started', handle: { id: 'sdk-' + run.runId, model: 'm', shadowDir: '', methods: ['setModel'], state: {} } });
+ vi.spyOn(RemoteAgentPoller.prototype, 'register').mockImplementation(run => {
+ runs.set(run.runId, run);
+ if (state.ready || sessions.get(run.runId) === 'sibling') started(run);
+ });
+ vi.spyOn(RemoteAgentPoller.prototype, 'unregister').mockImplementation(() => {});
+ const remoteInvoke = vi.fn(async (device: string, _channel: string, args: unknown[]) => {
+ const request = args[0] as { op: string; sessionId?: string; generation?: string; runId?: string; callId?: string; payload?: { json?: { sessionId: string } } };
+ calls.push({ device, ...request });
+ if (request.op === 'direct-locate') return { ok: true, result: { deviceId: 'executor-m', agentKind: 'codex' } };
+ if (request.op === 'allocate') {
+ const grant = ++allocations === 1 ? generation : '22222222-2222-4222-8222-222222222222';
+ if (state.blockAllocation) await allocation.promise;
+ return { ok: true, result: { deviceId: state.device, generation: grant,
+ ...(state.duration === undefined ? {} : { leaseDurationMs: request.sessionId === 'sibling' ? 20000 : state.duration }) } };
+ }
+ if (request.op === 'caps') {
+ if (state.delayCaps) { const ms = state.delayCaps; state.delayCaps = 0; await vi.advanceTimersByTimeAsync(ms); }
+ return { ok: true, result: { version: 1, maxRuns: 10, uploadChunkBytes: 65536, maxPayloadBytes: 1000000,
+ virtualWorkspace: true, directGuestExecution: true, agents: [{ kind: 'codex', available: true }] } };
+ }
+ if (request.op === 'open') sessions.set(request.runId!, request.payload!.json!.sessionId);
+ if (request.op === 'close') {
+ if (state.blockClose) await pendingClose.promise;
+ const run = runs.get(request.runId!);
+ if (run) emit(run, { t: 'closed', reason: 'closed' });
+ }
+ if (request.op === 'call') {
+ const run = runs.get(request.runId!);
+ if (run) emit(run, { t: 'result', callId: request.callId, ok: true, value: null });
+ }
+ return { ok: true, result: {} };
+ });
+ const start = createDeviceAgentStarter({
+ remoteInvoke, renewSharedProviderLink: async () => undefined,
+ rgPath: () => RG, codexPath: () => 'fixture-never-spawned', mcpProviders: () => [],
+ prepareMcpBridge: async (_providers, _logger, ctx) => {
+ if (state.blockPrepare) await prepare.promise;
+ return { mcpBridge: { servers: [{ name: 'fixture', url: 'http://fixture.invalid/' }] },
+ disposeSessionCtx: () => { disposed.push(ctx.sessionId!); } } as never;
+ },
+ makerMemory: () => undefined, captureKnownFileBefore: async () => undefined, noteOpaqueTurnChange() {},
+ logger: historyLogger,
+ });
+ historyInvoke.mockImplementation(remoteInvoke);
+ historyOpenLink.mockResolvedValue(undefined);
+ historyCloseEpoch.mockReturnValue(0);
+ historyCrossRegion.mockReturnValue(false);
+ return { owner, target, generation, state, calls, runs, disposed, pendingClose, prepare, allocation, emit, started,
+ open: (sessionId = 'pending', deviceId = owner, model = 'm', resumeSessionId?: string) => start({ agentKind: 'codex', deviceId,
+ options: { sessionId, workingDir: project, model, ...(resumeSessionId ? { resumeSessionId } : {}) } }) };
+ }
+ beforeEach(() => {
+ vi.useFakeTimers({ toFake: ['Date', 'performance', 'setTimeout', 'clearTimeout', 'setInterval', 'clearInterval'] });
+ });
+ afterEach(() => { vi.restoreAllMocks(); vi.unstubAllGlobals(); vi.useRealTimers(); historyInvoke.mockReset(); historyOpenLink.mockReset(); });
+
+ // Unit, F6: terminal cancellation must cross the create -> starter composition boundary.
+ // Real starter + startRemote + runClient; native and transport IO use the existing fixture.
+ it.each(['allocate', 'MCP', 'started', 'ordinary'] as const)('cancels the exact creation during %s without late fallback/open', async stage => {
+ const f = fixture(), owner = {};
+ f.state.blockAllocation = stage === 'allocate';
+ f.state.blockPrepare = stage === 'MCP' || stage === 'ordinary';
+ let rejected: unknown;
+ let live: Awaited<ReturnType<typeof f.open>> | undefined;
+ const pending = runSessionCreationAttempt('pending', () => owner,
+ async () => (live = await f.open('pending', stage === 'ordinary' ? 'same-account-m' : f.owner)))
+ .catch(error => { rejected = error; });
+ try {
+ await flush();
+ if (stage === 'started') await vi.waitFor(() => expect(f.runs.size).toBe(1), { interval: 1 });
+ captureSessionCreationCancellation(owner, 'pending')(); await flush();
+ expect(String(rejected)).toContain('REMOTE_AGENT_EXPIRED');
+ const openCount = f.calls.filter(call => call.op === 'open').length;
+ const callsAtCancel = f.calls.length;
+ f.allocation.resolve(); f.prepare.resolve();
+ for (const run of f.runs.values()) f.started(run);
+ await pending; await flush();
+ expect(f.calls.filter(call => call.op === 'open')).toHaveLength(openCount);
+ expect(f.calls.slice(callsAtCancel).filter(call => ['open', 'upload', 'caps'].includes(call.op))).toEqual([]);
+ if (stage !== 'ordinary') expect(f.calls).toContainEqual(expect.objectContaining({
+ device: f.owner, op: 'direct-release', sessionId: 'pending', generation: f.generation,
+ }));
+ if (stage === 'MCP' || stage === 'started' || stage === 'ordinary') expect(f.disposed).toEqual(['pending']);
+ expect(f.calls.filter(call => call.device === f.owner && call.op === 'open')).toEqual([]);
+ } finally {
+ // Keep the regression isolated even when a broken parent bridge leaks its child startup.
+ cancelPendingRemoteStart('pending');
+ f.allocation.resolve(); f.prepare.resolve(); await flush();
+ for (const run of f.runs.values()) f.emit(run, { t: 'closed', reason: 'closed' });
+ await flush(); await live?.close({ reason: 'account-boundary' });
+ }
+ });
+
+ it('rejects pending startup and closes reverse HTTP/WS and local tools at the deadline, before remote close', async () => {
+ const f = fixture(); f.state.blockClose = true;
+ const executorClose = vi.spyOn(RemoteExecutor.prototype, 'close');
+ const relayClose = vi.spyOn(ExecServerRelay.prototype, 'close');
+ const relayFrame = vi.spyOn(ExecServerRelay.prototype, 'handle').mockImplementation(() => {});
+ let requestSignal: AbortSignal | undefined;
+ vi.stubGlobal('fetch', vi.fn((_url: unknown, init: RequestInit) => new Promise((_resolve, reject) => {
+ requestSignal = init.signal!;
+ requestSignal.addEventListener('abort', () => reject(new Error('fixture request aborted')), { once: true });
+ })));
+ let rejected: unknown;
+ const pending = f.open().catch(error => { rejected = error; });
+ await flush();
+ // isGitRepo uses asynchronous fs; drive that boundary, not fake elapsed lease time.
+ await vi.waitFor(() => expect(f.runs.size).toBe(1), { interval: 1 });
+ const run = [...f.runs.values()][0]!;
+ f.emit(run, { t: 'request', requestId: '33333333-3333-4333-8333-333333333333', request: { type: 'http', method: 'POST', path: '/mcp/fixture', headers: [], body: Buffer.from('{}').toString('base64') } });
+ f.emit(run, { t: 'ws', connId: 'ws-1', kind: 'open' });
+ await flush();
+ expect(requestSignal?.aborted).toBe(false);
+ expect(relayFrame).toHaveBeenCalledTimes(1);
+ await vi.advanceTimersByTimeAsync(2001);
+ expect(String(rejected)).toContain('REMOTE_AGENT_EXPIRED');
+ expect(requestSignal?.aborted).toBe(true);
+ expect(f.disposed).toEqual(['pending']);
+ expect(executorClose).toHaveBeenCalledTimes(1);
+ expect(relayClose).toHaveBeenCalledTimes(1);
+ f.started(run);
+ f.emit(run, { t: 'ws', connId: 'ws-late', kind: 'open' });
+ await flush();
+ expect(relayFrame).toHaveBeenCalledTimes(1);
+ expect(liveSharedTaskTarget('pending', f.owner)).toBeNull();
+ expect(f.calls.filter(call => call.op === 'open')).toHaveLength(1);
+ f.pendingClose.resolve(); await pending; await flush();
+ });
+
+ it('rejects during MCP preparation, closes the executor immediately, and disposes late preparation without opening M', async () => {
+ const f = fixture(); f.state.blockPrepare = true;
+ const closed = vi.spyOn(RemoteExecutor.prototype, 'close');
+ let rejected: unknown;
+ const pending = f.open().catch(error => { rejected = error; });
+ await flush();
+ await vi.advanceTimersByTimeAsync(2001);
+ expect(String(rejected)).toContain('REMOTE_AGENT_EXPIRED');
+ expect(closed).toHaveBeenCalledTimes(1);
+ expect(f.disposed).toEqual([]);
+ f.prepare.resolve(); await pending; await flush();
+ expect(f.disposed).toEqual(['pending']);
+ expect(closed).toHaveBeenCalledTimes(1);
+ expect(f.calls.filter(call => call.op === 'open')).toEqual([]);
+ });
+
+ it.each([0, null, Number.NaN, 1800001, 'spent-in-caps', 'bad-device'])('never opens M for an invalid or exhausted allocation: %s', async lifetime => {
+ const f = fixture(); f.state.ready = true;
+ if (lifetime === 'spent-in-caps') f.state.delayCaps = 3000;
+ else if (lifetime === 'bad-device') f.state.device = '';
+ else f.state.duration = lifetime;
+ const handle = await f.open();
+ expect(f.calls.filter(call => call.op === 'open').map(call => call.device)).toEqual([f.owner]);
+ expect(f.calls.filter(call => call.op === 'direct-release')).toEqual([
+ expect.objectContaining({ device: f.owner, sessionId: 'pending', generation: f.generation }),
+ ]);
+ await handle.close();
+ });
+
+ it.each([2000, undefined])('hands off one active lease and rearms on successful renewal, including legacy O: %s', async duration => {
+ const f = fixture(); f.state.ready = true; f.state.duration = duration;
+ const handle = await f.open();
+ const sibling = await f.open('sibling');
+ if (duration === undefined) {
+ await vi.advanceTimersByTimeAsync(2001);
+ expect(f.disposed).toEqual([]);
+ } else {
+ await vi.advanceTimersByTimeAsync(1000);
+ await handle.setModel!('m2');
+ await vi.advanceTimersByTimeAsync(1001);
+ expect(f.disposed).not.toContain('pending');
+ await vi.advanceTimersByTimeAsync(1000);
+ expect(f.disposed).toContain('pending');
+ expect(f.disposed).not.toContain('sibling');
+ }
+ await handle.close(); await sibling.close();
+ });
+
+ it('cancels allocation before any M probe, releases only the late generation, and preserves a replacement attempt', async () => {
+ const f = fixture(); f.state.blockAllocation = true;
+ let rejected: unknown;
+ const old = f.open().catch(error => { rejected = error; });
+ await flush(); cancelPendingRemoteStart('pending'); await flush();
+ expect(String(rejected)).toContain('REMOTE_AGENT_EXPIRED');
+ expect(f.calls.filter(call => call.device === f.target)).toEqual([]);
+ f.state.blockAllocation = false; f.state.ready = true;
+ const replacement = await f.open();
+ const before = f.calls.filter(call => call.device === f.target).length;
+ f.allocation.resolve(); await old; await flush();
+ expect(f.calls.filter(call => call.device === f.target)).toHaveLength(before);
+ expect(f.calls.filter(call => call.op === 'direct-release')).toEqual([
+ expect.objectContaining({ sessionId: 'pending', generation: f.generation }),
+ ]);
+ expect(f.disposed).toEqual([]);
+ expect(liveSharedTaskTarget('pending', f.owner)).toBe(f.target);
+ await replacement.close();
+ });
+
+ it('does not retry a deleted direct task through O after MCP preparation completes late', async () => {
+ const f = fixture(); f.state.blockPrepare = true;
+ let rejected: unknown;
+ const pending = f.open().catch(error => { rejected = error; });
+ await flush(); cancelPendingRemoteStart('pending'); await flush();
+ expect(String(rejected)).toContain('REMOTE_AGENT_EXPIRED');
+ f.state.blockPrepare = false; f.state.ready = true;
+ f.prepare.resolve(); await pending; await flush();
+ expect(f.calls.filter(call => call.op === 'open')).toEqual([]);
+ expect(f.disposed).toEqual(['pending']);
+ expect(f.calls.filter(call => call.op === 'direct-release')).toEqual([
+ expect.objectContaining({ sessionId: 'pending', generation: f.generation }),
+ ]);
+ });
+
+ it('keeps a newer same-session start alive when only the old pending attempt reaches its deadline', async () => {
+ const f = fixture();
+ let rejected: unknown;
+ const old = f.open().catch(error => { rejected = error; });
+ await vi.waitFor(() => expect(f.runs.size).toBe(1), { interval: 1 });
+ f.state.ready = true; f.state.duration = 20000;
+ const replacement = await f.open('pending', f.owner, 'm2');
+ await vi.advanceTimersByTimeAsync(2001);
+ expect(String(rejected)).toContain('REMOTE_AGENT_EXPIRED');
+ expect(f.disposed).toEqual(['pending']);
+ expect(liveSharedTaskTarget('pending', f.owner)).toBe(f.target);
+ await old; await replacement.close();
+ expect(f.disposed).toEqual(['pending', 'pending']);
+ });
+
+ it('fails a historical M startup at expiry without sending its native resume ID to O', async () => {
+ const f = fixture();
+ let rejected: unknown;
+ const pending = f.open('historical', f.owner, 'm', 'native-only-on-m').catch(error => { rejected = error; });
+ await vi.waitFor(() => expect(f.runs.size).toBe(1), { interval: 1 });
+ await vi.advanceTimersByTimeAsync(2001);
+ expect(String(rejected)).toContain('REMOTE_AGENT_EXPIRED');
+ expect(f.calls.filter(call => call.op === 'open').map(call => call.device)).toEqual([f.target]);
+ expect(f.disposed).toEqual(['historical']);
+ await pending;
+ });
+
+ it('cleans a prepared handle when archive cancels the early renewal before starter handoff', async () => {
+ const f = fixture(); f.state.duration = undefined; f.state.blockClose = true;
+ let rejected: unknown;
+ const pending = f.open().catch(error => { rejected = error; });
+ await vi.waitFor(() => expect(f.runs.size).toBe(1), { interval: 1 });
+ await vi.advanceTimersByTimeAsync(20 * 60000 + 1);
+ f.state.blockAllocation = true;
+ f.started([...f.runs.values()][0]!); await flush();
+ expect(f.calls.filter(call => call.op === 'allocate')).toHaveLength(2);
+ cancelPendingRemoteStart('pending'); await flush();
+ expect(String(rejected)).toContain('REMOTE_AGENT_EXPIRED');
+ expect(f.disposed).toEqual(['pending']);
+ f.allocation.resolve(); await flush();
+ expect(f.calls.filter(call => call.op === 'direct-release')).toContainEqual(
+ expect.objectContaining({ sessionId: 'pending', generation: '22222222-2222-4222-8222-222222222222' }),
+ );
+ f.pendingClose.resolve(); await pending; await flush();
+ expect(f.calls.filter(call => call.op === 'open')).toHaveLength(1);
+ });
+
+ it('does not contact O or M for an already-aborted history or pinned executor attempt', async () => {
+ const f = fixture();
+ const abort = new AbortController();
+ const reason = new Error('[REMOTE_AGENT_EXPIRED] archived'); abort.abort(reason);
+ await expect(authorizeSharedTaskHistory(f.owner, 'history', 'codex', 'm', abort.signal)).rejects.toBe(reason);
+ await expect(authorizeSharedTaskExecutor(f.owner, 'history', 'codex', 'm', 'executor-m', false, abort.signal)).rejects.toBe(reason);
+ expect(f.calls).toEqual([]); expect(historyOpenLink).not.toHaveBeenCalled();
+ });
+
+ it.each(['locate', 'allocate', 'link', 'caps-success', 'caps-failure'] as const)('keeps history cancellation terminal through %s and releases only the returned generation', async stage => {
+ const f = fixture(), gate = deferred(), abort = new AbortController();
+ const reason = new Error('[REMOTE_AGENT_EXPIRED] archived history');
+ const requests: Array<{ op: string; sessionId?: string; generation?: string }> = [];
+ const caps = { version: 1, maxRuns: 10, uploadChunkBytes: 65536, maxPayloadBytes: 1000000,
+ virtualWorkspace: true, directGuestExecution: true, agents: [{ kind: 'codex', available: true }] };
+ historyInvoke.mockImplementation(async (_device, _channel, [request]) => {
+ requests.push(request);
+ if (request.op === 'direct-locate') {
+ if (stage === 'locate') { await gate.promise; throw new Error('[REMOTE_AGENT_PEER_TOO_OLD] late old O response'); }
+ return { ok: true, result: { deviceId: 'executor-m' } };
+ }
+ if (request.op === 'allocate') {
+ if (stage === 'allocate') await gate.promise;
+ return { ok: true, result: { deviceId: 'executor-m', generation: f.generation, leaseDurationMs: 2000 } };
+ }
+ if (request.op === 'caps') {
+ await gate.promise;
+ if (stage === 'caps-failure') throw new Error('late caps transport failure');
+ return { ok: true, result: caps };
+ }
+ return { ok: true, result: {} };
+ });
+ if (stage === 'link') historyOpenLink.mockImplementation(() => gate.promise);
+ const pending = authorizeSharedTaskHistory(f.owner, 'history', 'codex', 'm', abort.signal);
+ void pending.catch(() => undefined);
+ await flush(); abort.abort(reason); gate.resolve();
+ await expect(pending).rejects.toBe(reason); await flush();
+ expect(requests.filter(request => request.op === 'direct-release')).toEqual(stage === 'locate' ? [] : [
+ { op: 'direct-release', sessionId: 'history', generation: f.generation },
+ ]);
+ expect(requests.filter(request => request.op === 'caps')).toHaveLength(stage.startsWith('caps-') ? 1 : 0);
+ if (stage === 'locate') expect(requests.filter(request => request.op === 'allocate')).toEqual([]);
+ if (stage === 'allocate') expect(historyOpenLink).not.toHaveBeenCalled();
+ });
+
+ it('preserves legacy O lookup fallback and missing lifetime, but never substitutes another historical M', async () => {
+ const f = fixture();
+ historyInvoke.mockRejectedValueOnce(new Error('[REMOTE_AGENT_PEER_TOO_OLD] old O'));
+ await expect(authorizeSharedTaskHistory(f.owner, 'legacy', 'codex', 'm')).resolves.toEqual({ target: f.owner, direct: false });
+ f.state.duration = undefined;
+ await expect(authorizeSharedTaskExecutor(f.owner, 'legacy', 'codex', 'm', 'executor-m')).resolves.toMatchObject({ target: f.target, direct: true });
+ historyInvoke.mockResolvedValueOnce({ ok: true, result: { deviceId: 'different-m', generation: f.generation, leaseDurationMs: 2000 } });
+ await expect(authorizeSharedTaskExecutor(f.owner, 'history', 'codex', 'm', 'executor-m')).rejects.toThrow('holding this shared task');
+ });
+
+ it('keeps ordinary archive cancellation attempt-local when a replacement with the same session is starting', async () => {
+ const f = fixture(); f.state.blockPrepare = true;
+ let rejected: unknown;
+ const pending = f.open('ordinary', 'same-account-m').catch(error => { rejected = error; });
+ await flush(); cancelPendingRemoteStart('ordinary'); await flush();
+ // The new attempt is registered after the archive event and must not inherit it.
+ f.state.blockPrepare = false; f.state.ready = true;
+ const next = await f.open('ordinary', 'same-account-m');
+ f.prepare.resolve(); await pending; await flush();
+ expect(String(rejected)).toContain('REMOTE_AGENT_EXPIRED');
+ expect(f.calls.filter(call => call.op === 'open')).toHaveLength(1);
+ expect(f.disposed).toEqual(['ordinary']);
+ await next.close();
+ expect(f.disposed).toEqual(['ordinary', 'ordinary']);
+ });
+});
+
+// Unit, F5: cancellation between compression/upload awaits must stop further payload delivery.
+// Real RemoteAgentRunClient.payload/open; only gzip timing/output and transport replies are fixtures.
+describe('shared startup lease budget upload cancellation', () => {
+ const flush = async () => { for (let i = 0; i < 30; i++) await Promise.resolve(); };
+ function fixture() {
+ let reply!: () => void;
+ const held = new Promise<void>(resolve => { reply = resolve; });
+ const requests: Array<{ op: string; index?: number }> = [];
+ let hold = false;
+ const invoke = async (args: unknown[]) => {
+ const request = args[0] as { op: string; index?: number };
+ requests.push(request);
+ if (hold && request.op === 'upload') await held;
+ return {};
+ };
+ const client = new RemoteAgentRunClient(randomUUID(), { invoke, unregister() {} } as unknown as RemoteAgentPoller, {
+ onEvent() {}, onState() {}, onWs() {}, onClosed() {},
+ onRequest: async () => ({ type: 'error', error: { code: 'UNUSED', message: 'fixture' } }),
+ }, randomUUID);
+ // Just crosses the inline threshold; gzip is a bounded two-chunk fixture above.
+ const payload = { sessionId: 'upload-task', text: 'x'.repeat(1024 * 1024) };
+ return { client, payload, requests, reply, hold: () => { hold = true; } };
+ }
+ beforeEach(() => { payloadCompression.enabled = true; payloadCompression.paused = false; payloadCompression.calls = 0; payloadCompression.finish = undefined; });
+ afterEach(() => { payloadCompression.enabled = false; payloadCompression.finish = undefined; });
+
+ it('allows the in-flight first chunk to return but sends no later upload or open after cancellation', async () => {
+ const f = fixture(); f.hold();
+ const starting = f.client.open('codex', f.payload); void starting.catch(() => undefined);
+ await flush(); expect(f.requests.map(request => request.op)).toEqual(['upload']);
+ f.client.abandon('start-cancelled'); f.reply();
+ await expect(starting).rejects.toThrow('REMOTE_AGENT_EXPIRED');
+ expect(f.requests.map(request => request.op)).toEqual(['upload']);
+ expect(f.requests[0]?.index).toBe(0);
+ });
+
+ it('sends no first chunk if cancellation happens while gzip is pending', async () => {
+ const f = fixture(); payloadCompression.paused = true;
+ const starting = f.client.open('codex', f.payload); void starting.catch(() => undefined);
+ await flush(); expect(payloadCompression.calls).toBe(1);
+ f.client.abandon('start-cancelled'); payloadCompression.finish!();
+ await expect(starting).rejects.toThrow('REMOTE_AGENT_EXPIRED');
+ expect(f.requests).toEqual([]);
+ });
+
+ it('completes both chunks when not cancelled and rejects an already-closed payload before compression', async () => {
+ const f = fixture();
+ await expect(f.client.payload(f.payload)).resolves.toMatchObject({ chunks: 2, bytes: 512 * 1024 + 1 });
+ expect(f.requests.map(request => request.index)).toEqual([0, 1]);
+ f.client.abandon('closed');
+ await expect(f.client.payload(f.payload)).rejects.toThrow('REMOTE_AGENT_EXPIRED');
+ expect(payloadCompression.calls).toBe(1);
+ expect(f.requests).toHaveLength(2);
+ });
+});
diff --git a/apps/desktop/src/main/remote-agent/controller/execServerRelay.ts b/apps/desktop/src/main/remote-agent/controller/execServerRelay.ts
index ac5b1435e6..7c20134dd0 100644
--- a/apps/desktop/src/main/remote-agent/controller/execServerRelay.ts
+++ b/apps/desktop/src/main/remote-agent/controller/execServerRelay.ts
@@ -10,6 +10,7 @@
* 受邀者任务里,凭证类操作没有批准时先在本机弹确认卡,等待期间这条连接后面的消息排在它后面。
*/
import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import fsp from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -272,6 +273,13 @@ function mapExecServerSandbox(value: unknown, workspace: ExecutorWorkspace): unk
const policyContext = asJsonRecord(sandbox.policyContext);
if (policyContext) sandbox.policyContext = mapSandboxDirs(policyContext, mapping);
const permissions = asJsonRecord(sandbox.permissions);
+ // POSIX Codex 没有 Windows 沙箱,发来的 disabled 不是执行端的可用实现。
+ // 仅为受限权限选择 Windows 原生受限令牌;不改权限、显式 Windows 选择或非受限请求。
+ // 不能落实的规则(如 deny-read)仍由原生 exec-server 拒绝,不能删规则或重试无沙箱。
+ if (process.platform === 'win32' && !mapping.windowsAgent
+ && sandbox.windowsSandboxLevel === 'disabled' && permissions?.type === 'managed') {
+ sandbox.windowsSandboxLevel = 'restricted-token';
+ }
const fileSystem = asJsonRecord(permissions?.file_system);
if (permissions && fileSystem && Array.isArray(fileSystem.entries)) {
const entries = fileSystem.entries.flatMap((entry) => mapSandboxEntry(entry, mapping));
@@ -306,6 +314,32 @@ function existingTextFor(target: unknown, workspace: ExecutorWorkspace): string
/** 一条结果只解析一次目录;磁盘 realpath 走异步文件系统,不阻塞 Electron 主线程。 */
export async function mapExecServerResult(value: unknown, workspace: ExecutorWorkspace, method?: string): Promise<unknown> {
+ // Store/MSIX 的 PowerShell 不能用 Windows 受限令牌启动。只为使用上述 Windows
+ // 适配的 POSIX Agent 宣告一份实际存在的非 Store Shell;不改 PATH、不改显式命令。
+ const root = asJsonRecord(value);
+ const result = asJsonRecord(root?.result);
+ const info = asJsonRecord(result?.environmentInfo);
+ const shell = asJsonRecord(info?.shell);
+ const agentPrefixes = workspace.agentPathPrefixes();
+ if (process.platform === 'win32' && agentPrefixes.length > 0
+ && !/^(?:[A-Za-z]:|[\\/]{2})/.test(agentPrefixes[0])
+ && info?.platformOs === 'windows' && shell?.name === 'powershell'
+ && typeof shell.path === 'string' && /[\\/]WindowsApps[\\/]/i.test(shell.path)
+ && /[\\/]pwsh\.exe$/i.test(shell.path)) {
+ const candidates = [
+ process.env.ProgramFiles && path.join(process.env.ProgramFiles, 'PowerShell', '7', 'pwsh.exe'),
+ process.env.SystemRoot && path.join(process.env.SystemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+ ];
+ for (const candidate of candidates) {
+ if (!candidate) continue;
+ try {
+ const executable = await fsp.realpath(candidate);
+ if (/[\\/]WindowsApps[\\/]/i.test(executable) || !(await fsp.stat(executable)).isFile()) continue;
+ value = { ...root, result: { ...result, environmentInfo: { ...info, shell: { ...shell, path: executable } } } };
+ break;
+ } catch { /* 不存在可用替代时保留原生声明,由执行端拒绝,不扩大权限。 */ }
+ }
+ }
const directories: string[] = [];
const collect = (item: unknown): void => {
if (!item || typeof item !== 'object') return;
diff --git a/apps/desktop/src/main/remote-agent/controller/providerShareTaskLocation.ts b/apps/desktop/src/main/remote-agent/controller/providerShareTaskLocation.ts
new file mode 100644
index 0000000000..f1a7f61196
--- /dev/null
+++ b/apps/desktop/src/main/remote-agent/controller/providerShareTaskLocation.ts
@@ -0,0 +1,128 @@
+import { providerShareHostPeer, type RemoteAgentKind } from '@cindy/device-link';
+
+import { getRemoteLinkCloseEpoch, openRemoteLink, remoteBackgroundInvoke } from '../../device-link/index.js';
+import { isCrossRegionProviderShareTarget, renewCrossRegionProviderShareLink } from '../../device-link/providerShareCrossRegion.js';
+import { parseProviderShareAgentDeviceId } from '../../device-link/providerShareGuest.js';
+import { RemoteAgentRunClient, remoteAgentInvoker } from './runClient.js';
+
+type SharedTaskAuthorization = { target: string; direct: boolean; generation?: string; leaseDeadline?: number };
+const GRANT_ID = /^[0-9a-f-]{36}$/;
+
+/** O reports remaining time, so G never compares clocks on different computers. Missing means legacy O. */
+export function sharedTaskLeaseDeadline(value: unknown, requestedAt: number): number | undefined {
+ const duration = value && typeof value === 'object' ? (value as { leaseDurationMs?: unknown }).leaseDurationMs : undefined;
+ if (duration === undefined) return undefined;
+ if (typeof duration !== 'number' || !Number.isFinite(duration) || duration <= 0 || duration > 30 * 60_000) {
+ throw new Error('[REMOTE_AGENT_INVALID] shared task authorization has an invalid lifetime');
+ }
+ const deadline = requestedAt + duration;
+ if (deadline <= performance.now()) throw new Error('[REMOTE_AGENT_UNAVAILABLE] shared task authorization has expired');
+ return deadline;
+}
+
+/** Release only this task's allocation generation; a source/sibling lease is never selected. */
+export async function releaseSharedTaskAuthorization(ownerRoute: string, sessionId: string, generation?: string): Promise<void> {
+ if (generation) await remoteAgentInvoker(ownerRoute, remoteBackgroundInvoke)([{
+ op: 'direct-release', sessionId, generation,
+ }]);
+}
+
+/** Pinned allocation: neither a null response nor another executor can accept existing native history. */
+export async function authorizeSharedTaskExecutor(
+ ownerRoute: string, sessionId: string, agentKind: RemoteAgentKind, model: string,
+ deviceId: string, releaseOnFailure = false, signal?: AbortSignal,
+): Promise<SharedTaskAuthorization> {
+ signal?.throwIfAborted();
+ const shareId = parseProviderShareAgentDeviceId(ownerRoute);
+ if (!shareId) throw new Error('[REMOTE_AGENT_INVALID] a shared task owner is required');
+ const target = providerShareHostPeer(shareId, deviceId);
+ const closeEpoch = getRemoteLinkCloseEpoch(target);
+ const requestedAt = performance.now();
+ const value = await remoteAgentInvoker(ownerRoute, remoteBackgroundInvoke)([{
+ op: 'allocate', sessionId, agentKind, model, preferredExecutorDeviceId: deviceId,
+ }]).catch(error => { signal?.throwIfAborted(); throw error; });
+ const row = value && typeof value === 'object' ? value as { deviceId?: unknown; generation?: unknown } : null;
+ const generation = typeof row?.generation === 'string' && GRANT_ID.test(row.generation) ? row.generation : undefined;
+ try {
+ signal?.throwIfAborted();
+ if (row?.deviceId !== deviceId) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] the computer holding this shared task is unavailable');
+ }
+ const requireCurrentLink = (): void => {
+ signal?.throwIfAborted();
+ if (getRemoteLinkCloseEpoch(target) !== closeEpoch) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] shared executor link was closed during authorization');
+ }
+ };
+ requireCurrentLink();
+ // A restarted M can lose its transport while G still considers the peer
+ // ready. Reconfirm only this peer after its fresh grant, before native IDs
+ // or task contents are sent. Preserve the share's existing regional relay.
+ if (isCrossRegionProviderShareTarget(target)) await renewCrossRegionProviderShareLink(target);
+ else await openRemoteLink(target);
+ requireCurrentLink();
+ const caps = await RemoteAgentRunClient.caps(remoteAgentInvoker(target, remoteBackgroundInvoke));
+ requireCurrentLink();
+ if (!caps.directGuestExecution || !caps.agents.some(agent => agent.kind === agentKind && agent.available)) {
+ throw new Error('[REMOTE_AGENT_PEER_TOO_OLD] the computer holding this shared task cannot accept it');
+ }
+ const leaseDeadline = sharedTaskLeaseDeadline(value, requestedAt);
+ return { target, direct: true, ...(generation ? { generation } : {}), ...(leaseDeadline !== undefined ? { leaseDeadline } : {}) };
+ } catch (error) {
+ // Terminal cancellation owns only this attempt's returned generation, including
+ // a late allocation/caps failure. Never wait for the expired route to release it.
+ if (signal?.aborted) {
+ void releaseSharedTaskAuthorization(ownerRoute, sessionId, generation).catch(() => undefined);
+ signal.throwIfAborted();
+ }
+ // Only a newly authorized child opts into other failure cleanup; source history can still be live.
+ if (releaseOnFailure) await releaseSharedTaskAuthorization(ownerRoute, sessionId, generation).catch(() => undefined);
+ throw error;
+ }
+}
+
+/** Location is durable affinity, never authorization. Every historical use obtains a fresh M/server lease. */
+export async function authorizeSharedTaskHistory(
+ agentDeviceId: string, sessionId: string, agentKind: RemoteAgentKind, model: string, signal?: AbortSignal,
+): Promise<SharedTaskAuthorization> {
+ signal?.throwIfAborted();
+ if (!parseProviderShareAgentDeviceId(agentDeviceId)) return { target: agentDeviceId, direct: false };
+ let location: unknown;
+ try {
+ location = await remoteAgentInvoker(agentDeviceId, remoteBackgroundInvoke)([{ op: 'direct-locate', sessionId }]);
+ signal?.throwIfAborted();
+ } catch (error) {
+ // An aborted lookup is never the legacy-server fallback, whatever its late error.
+ signal?.throwIfAborted();
+ const transportCode = (error as { code?: unknown })?.code;
+ // Desktop dispatch wraps explicit domain codes in IPC_ERROR. A transport
+ // timeout/denial must still outrank any message text and must never fall back.
+ const code = transportCode === undefined || transportCode === 'IPC_ERROR'
+ ? (error instanceof Error ? /^\[([A-Z_]+)\]/.exec(error.message)?.[1] : undefined)
+ : transportCode;
+ if (code === 'REMOTE_AGENT_INVALID' || code === 'REMOTE_AGENT_PEER_TOO_OLD' || code === 'PEER_TOO_OLD') {
+ return { target: agentDeviceId, direct: false };
+ }
+ throw error;
+ }
+ if (location === null) return { target: agentDeviceId, direct: false };
+ const deviceId = location && typeof location === 'object' ? (location as { deviceId?: unknown }).deviceId : undefined;
+ if (typeof deviceId !== 'string') throw new Error('[REMOTE_AGENT_INVALID] invalid shared task location');
+ return authorizeSharedTaskExecutor(agentDeviceId, sessionId, agentKind, model, deviceId, false, signal);
+}
+
+const liveTargets = new Map<string, { target: string; authorized(): boolean }>();
+
+/** A live handle owns this entry; late close cannot clear a replacement handle. */
+export function trackLiveSharedTaskTarget(sessionId: string, ownerRoute: string, target: string, authorized: () => boolean): () => void {
+ const key = JSON.stringify([ownerRoute, sessionId]);
+ const entry = { target, authorized };
+ liveTargets.set(key, entry);
+ return () => { if (liveTargets.get(key) === entry) liveTargets.delete(key); };
+}
+
+/** Only an open, unexpired handle can reuse its current lease for live artifact delivery. */
+export function liveSharedTaskTarget(sessionId: string, ownerRoute: string): string | null {
+ const entry = liveTargets.get(JSON.stringify([ownerRoute, sessionId]));
+ return entry?.authorized() ? entry.target : null;
+}
diff --git a/apps/desktop/src/main/remote-agent/controller/runClient.ts b/apps/desktop/src/main/remote-agent/controller/runClient.ts
index 8f5dd05c6b..5feedb4f63 100644
--- a/apps/desktop/src/main/remote-agent/controller/runClient.ts
+++ b/apps/desktop/src/main/remote-agent/controller/runClient.ts
@@ -109,14 +109,22 @@ export class RemoteAgentRunClient implements PolledRun {
/** 把一个 JSON 值做成载荷:小的内联,大的 gzip 后分段上传。 */
async payload(value: unknown, uploadId = this.newId()): Promise<RemoteAgentPayload> {
+ const requireOpen = () => {
+ if (this.closed) throw new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.');
+ };
+ requireOpen();
const text = JSON.stringify(value ?? null);
if (text.length <= REMOTE_AGENT_MAX_INLINE_PAYLOAD_CHARS) return { json: JSON.parse(text) as unknown };
const gz = await gzipAsync(Buffer.from(text, 'utf8'));
+ requireOpen();
if (gz.length > REMOTE_AGENT_MAX_PAYLOAD_BYTES) throw new Error('The request is too large to send to the other computer.');
const chunks = Math.max(1, Math.ceil(gz.length / REMOTE_AGENT_UPLOAD_CHUNK_BYTES));
for (let index = 0; index < chunks; index += 1) {
+ requireOpen();
const data = gz.subarray(index * REMOTE_AGENT_UPLOAD_CHUNK_BYTES, (index + 1) * REMOTE_AGENT_UPLOAD_CHUNK_BYTES);
await this.invoke([{ op: 'upload', uploadId, index, data: data.toString('base64') }]);
+ // An in-flight chunk can finish after cancellation, but no next chunk or open may start.
+ requireOpen();
}
return { uploadId, chunks, bytes: gz.length };
}
diff --git a/apps/desktop/src/main/remote-agent/controller/service.ts b/apps/desktop/src/main/remote-agent/controller/service.ts
index a016da49ad..b5998f2a31 100644
--- a/apps/desktop/src/main/remote-agent/controller/service.ts
+++ b/apps/desktop/src/main/remote-agent/controller/service.ts
@@ -23,7 +23,9 @@ import type {
StartSessionOptions,
} from '@cindy/maker-core';
import { LOCAL_AGENT_CLIENT, resolveMemoryScopeKey } from '@cindy/maker-core';
+import { parseProviderSharePeer, providerShareHostPeer } from '@cindy/device-link';
import { createLogger } from '../../logger.js';
+import { findReceivedShare, parseProviderShareAgentDeviceId } from '../../device-link/providerShareGuest.js';
import { credentialGrantFor } from '../executor/credentialGrants';
import type { ExecutorCaptureHooks } from '../executor/executor';
@@ -40,11 +42,14 @@ import {
} from './projectFiles';
import type { LocalMcpTarget } from './router';
import { RemoteAgentPoller, RemoteAgentRunClient, remoteAgentInvoker } from './runClient';
-import { startRemoteAgentSession, type PreparedRemoteMcp } from './startRemote';
+import { registerPendingRemoteStart, startRemoteAgentSession, type PreparedRemoteMcp } from './startRemote';
+import { authorizeSharedTaskHistory, sharedTaskLeaseDeadline, trackLiveSharedTaskTarget } from './providerShareTaskLocation.js';
export interface DeviceAgentServiceDeps {
readImageDeliveryEpoch?(sessionId: string): Promise<number>;
remoteInvoke(deviceId: string, channel: string, args: unknown[]): Promise<{ ok: boolean; result?: unknown; error?: { code?: string; message?: string } }>;
+ /** Re-open the authenticated share link after a successful lease renewal. */
+ renewSharedProviderLink?(peer: string): Promise<unknown>;
rgPath(): string;
/** 本机 codex 程序(给对方的 Codex 提供 exec-server 执行环境)。 */
codexPath?(): string | undefined;
@@ -70,6 +75,7 @@ export interface DeviceAgentServiceDeps {
*/
groupSwitch?: {
takeForOpen(sessionId: string): string | undefined;
+ release?(sessionId: string): void;
offer(sessionId: string, token: string): void;
/** 用户亲自接手后的这次发送开始新的一轮(取走即用掉)。 */
takeNewRound?(sessionId: string): boolean;
@@ -134,6 +140,23 @@ async function isGitRepo(workingDir: string): Promise<boolean> {
*/
const sharedPollers = new WeakMap<DeviceAgentServiceDeps['remoteInvoke'], Map<string, RemoteAgentPoller>>();
+// A live direct handle, rather than an allocation cache entry, owns the right to
+// request a group switch. The identity prevents an old handle from clearing a
+// newly opened task with the same session ID.
+const liveDirectGuestSessions = new Map<string, {
+ identity: object;
+ ownerRoute: string;
+ requestSwitch(): Promise<string | undefined>;
+}>();
+const DIRECT_GRANT_ID = /^[0-9a-f-]{36}$/;
+
+export function liveDirectGuestSession(sessionId: string): Readonly<{
+ ownerRoute: string;
+ requestSwitch(): Promise<string | undefined>;
+}> | null {
+ return liveDirectGuestSessions.get(sessionId) ?? null;
+}
+
export function remoteAgentPollerFor(
deviceId: string,
remoteInvoke: DeviceAgentServiceDeps['remoteInvoke'],
@@ -161,6 +184,8 @@ export function createDeviceAgentStarter(deps: DeviceAgentServiceDeps) {
// 每台运行 Agent 的电脑一个连接池:对方按这台设备计名额,池里算的是本机在那台上开着的连接;
// 闲置多久可以让出按那台主人设置的闲置收回时长(打开前与主动让出前从 caps 读)。
const pools = new Map<string, RemoteConnectionPool>();
+ const directTasks = new Map<string, { target: string; agentKind: AgentKind; model: string;
+ until: number; authorizedUntil: number; leaseDeadline: number; generation?: string }>();
const poolFor = (deviceId: string): RemoteConnectionPool => {
let pool = pools.get(deviceId);
if (!pool) {
@@ -170,40 +195,202 @@ export function createDeviceAgentStarter(deps: DeviceAgentServiceDeps) {
}
return pool;
};
- return async (input: { agentKind: AgentKind; deviceId: string; options: StartSessionOptions }): Promise<AgentSessionHandle> => {
+ type StartInput = { agentKind: AgentKind; deviceId: string; options: StartSessionOptions };
+ const startAttempt = async (input: StartInput, skipDirect: boolean, attempt: ReturnType<typeof registerPendingRemoteStart>): Promise<AgentSessionHandle> => {
+ const requireCurrent = () => attempt.signal.throwIfAborted();
+ requireCurrent();
const opts: StartSessionOptions = { ...input.options };
- const poller = pollerFor(input.deviceId);
// 记忆在本机:对方只用这里给的索引快照,工具读写也回到本机记忆库。
if (opts.makerMemoryEnabled === true) {
const scopeKey = opts.makerMemoryScopeKey ?? await resolveMemoryScopeKey(opts.workingDir, undefined);
+ requireCurrent();
opts.makerMemoryScopeKey = scopeKey;
if (opts.makerMemoryIndexSnapshot === undefined) {
try {
- opts.makerMemoryIndexSnapshot = await (await deps.makerMemory()?.getStore(scopeKey))?.getIndex() ?? '';
+ const store = await deps.makerMemory()?.getStore(scopeKey);
+ requireCurrent();
+ opts.makerMemoryIndexSnapshot = await store?.getIndex() ?? '';
} catch (error) {
+ requireCurrent();
log.warn('remote agent: memory index unavailable; starting without it', { error: String(error) });
opts.makerMemoryIndexSnapshot = '';
}
}
}
+ requireCurrent();
const sessionId = opts.sessionId;
const groupSwitch = sessionId && deps.groupSwitch ? deps.groupSwitch : null;
const switchToken = groupSwitch && sessionId ? groupSwitch.takeForOpen(sessionId) : undefined;
- // 受邀者任务(分享来的供应商):内容会经过分享者的电脑。
+ if (switchToken && sessionId) directTasks.delete(`${parseProviderShareAgentDeviceId(input.deviceId) ?? ''}:${sessionId}`);
+ // 受邀者任务(分享来的供应商):可直连组内执行电脑;不可达时由分享者的电脑中转。
// - Agent 自带的 WebFetch 在分享者电脑上已关闭,改由本机抓取;
// - 凭证类文件不随启动同步,任务中读写凭证类文件、执行读取凭证的命令不论权限档都要本机确认。
// 同账号任务都不提供。
- const shared = deps.isSharedProviderDevice?.(input.deviceId) === true;
+ const shared = deps.isSharedProviderDevice?.(input.deviceId) === true || !!parseProviderShareAgentDeviceId(input.deviceId);
+ const shareId = shared ? parseProviderShareAgentDeviceId(input.deviceId) : null;
+ let target = input.deviceId;
+ let selectedDirectRoute: ReturnType<typeof directTasks.get>;
+ const releaseFailedDirectAllocation = async (generation: string | undefined): Promise<void> => {
+ if (!sessionId || !generation) return;
+ // A late failure from an old open must never revoke a newer allocation.
+ try {
+ await remoteAgentInvoker(input.deviceId, deps.remoteInvoke)([{
+ op: 'direct-release', sessionId, generation,
+ }]);
+ } catch (error) {
+ log.warn('shared provider failed direct allocation release will expire', { error: String(error) });
+ }
+ };
+ if (shareId && opts.resumeSessionId) {
+ if (!sessionId) throw new Error('[REMOTE_AGENT_INVALID] shared history requires its task identity');
+ const owner = findReceivedShare(shareId);
+ if (owner?.hostDeviceId) {
+ await deps.renewSharedProviderLink?.(providerShareHostPeer(shareId, owner.hostDeviceId));
+ }
+ const allocationStartedAt = Date.now();
+ const allocationStartedMonotonic = performance.now();
+ requireCurrent();
+ const history = await authorizeSharedTaskHistory(input.deviceId, sessionId, input.agentKind, opts.model, attempt.signal);
+ if (attempt.signal.aborted) void releaseFailedDirectAllocation(history.generation);
+ requireCurrent();
+ target = history.target;
+ const taskKey = `${shareId}:${sessionId}`;
+ directTasks.delete(taskKey);
+ if (history.direct) directTasks.set(taskKey, { target, agentKind: input.agentKind, model: opts.model,
+ until: allocationStartedAt + 25 * 60_000, authorizedUntil: allocationStartedAt + 29 * 60_000,
+ leaseDeadline: history.leaseDeadline ?? allocationStartedMonotonic + 30 * 60_000,
+ ...(history.generation ? { generation: history.generation } : {}) });
+ selectedDirectRoute = directTasks.get(taskKey);
+ } else if (!skipDirect && shareId && sessionId && !deps.isGroupAssigned?.(sessionId) && !switchToken
+ && findReceivedShare(shareId)?.status === 'active') {
+ const taskKey = `${shareId}:${sessionId}`;
+ const cached = directTasks.get(taskKey);
+ if (cached && cached.until > Date.now() && cached.leaseDeadline > performance.now() && cached.agentKind === input.agentKind && cached.model === opts.model) {
+ try {
+ // M's grant is memory-only. A process restart can invalidate it even
+ // while G's cached route still has time left.
+ await RemoteAgentRunClient.caps(remoteAgentInvoker(cached.target, deps.remoteInvoke));
+ requireCurrent();
+ if (cached.leaseDeadline <= performance.now()) throw new Error('[REMOTE_AGENT_UNAVAILABLE] shared task authorization has expired');
+ selectedDirectRoute = cached;
+ target = cached.target;
+ } catch {
+ requireCurrent();
+ directTasks.delete(taskKey);
+ }
+ }
+ if (target === input.deviceId) {
+ directTasks.delete(taskKey);
+ try {
+ const owner = findReceivedShare(shareId);
+ if (owner?.hostDeviceId) {
+ await deps.renewSharedProviderLink?.(providerShareHostPeer(shareId, owner.hostDeviceId));
+ }
+ requireCurrent();
+ const allocationStartedAt = Date.now();
+ const allocationStartedMonotonic = performance.now();
+ const allocation = await remoteAgentInvoker(input.deviceId, deps.remoteInvoke)([{
+ op: 'allocate', agentKind: input.agentKind, model: opts.model, sessionId,
+ }]);
+ const row = allocation && typeof allocation === 'object'
+ ? allocation as { deviceId?: unknown; generation?: unknown } : null;
+ if (attempt.signal.aborted) {
+ const generation = typeof row?.generation === 'string' && DIRECT_GRANT_ID.test(row.generation) ? row.generation : undefined;
+ void releaseFailedDirectAllocation(generation);
+ requireCurrent();
+ }
+ if (row) {
+ let proposed: string;
+ const generation = typeof row.generation === 'string' && DIRECT_GRANT_ID.test(row.generation)
+ ? row.generation : undefined;
+ // Validate before publishing any route; the handshake also consumes this lease.
+ let leaseDeadline: number;
+ try {
+ if (typeof row.deviceId !== 'string') throw new Error('[REMOTE_AGENT_INVALID] invalid shared executor');
+ proposed = providerShareHostPeer(shareId, row.deviceId);
+ leaseDeadline = sharedTaskLeaseDeadline(allocation, allocationStartedMonotonic) ?? allocationStartedMonotonic + 30 * 60_000;
+ // A fresh task grant does not refresh G's cached transport state.
+ // Confirm only this executor, using the share's existing relay.
+ await deps.renewSharedProviderLink?.(proposed);
+ requireCurrent();
+ const caps = await RemoteAgentRunClient.caps(remoteAgentInvoker(proposed, deps.remoteInvoke));
+ requireCurrent();
+ if (!caps.directGuestExecution || !caps.agents.some(agent => agent.kind === input.agentKind && agent.available)) {
+ throw new Error('[REMOTE_AGENT_PEER_TOO_OLD] shared executor cannot accept this task');
+ }
+ if (leaseDeadline <= performance.now()) throw new Error('[REMOTE_AGENT_UNAVAILABLE] shared task authorization has expired');
+ }
+ catch (error) {
+ void releaseFailedDirectAllocation(generation);
+ throw error;
+ }
+ target = proposed;
+ for (const [key, route] of directTasks) if (route.until <= Date.now()) directTasks.delete(key);
+ if (directTasks.size >= 512) directTasks.delete(directTasks.keys().next().value!);
+ directTasks.set(taskKey, { target, agentKind: input.agentKind, model: opts.model,
+ until: allocationStartedAt + 25 * 60_000,
+ authorizedUntil: allocationStartedAt + 29 * 60_000,
+ leaseDeadline,
+ ...(generation ? { generation } : {}) });
+ selectedDirectRoute = directTasks.get(taskKey);
+ }
+ } catch (error) {
+ requireCurrent();
+ log.warn('shared provider direct executor unavailable; using group owner', { error: String(error) });
+ }
+ }
+ }
+ requireCurrent();
+ const poller = pollerFor(target);
+ const directIdentity = {};
+ if (shareId && sessionId && target !== input.deviceId) {
+ liveDirectGuestSessions.set(sessionId, {
+ identity: directIdentity,
+ ownerRoute: input.deviceId,
+ async requestSwitch() {
+ const result = await remoteAgentInvoker(input.deviceId, deps.remoteInvoke)([{ op: 'direct-switch', sessionId }]);
+ const token = result && typeof result === 'object' ? (result as { token?: unknown }).token : undefined;
+ return typeof token === 'string' ? token : undefined;
+ },
+ });
+ }
+ const clearDirectIdentity = () => {
+ if (sessionId && liveDirectGuestSessions.get(sessionId)?.identity === directIdentity) {
+ liveDirectGuestSessions.delete(sessionId);
+ }
+ };
+ const openingDirectGeneration = selectedDirectRoute?.generation;
+ // Keep this attempt's grant even if another start replaces the task's route cache.
+ const openingDirectRoute = selectedDirectRoute;
+ let leaseDeadline = openingDirectRoute?.leaseDeadline ?? performance.now();
+ let expiryTimer: ReturnType<typeof setTimeout> | undefined;
+ const startupAbort = attempt;
+ let expireLive: (() => void) | undefined;
+ function armLeaseExpiry(): void {
+ if (expiryTimer) clearTimeout(expiryTimer);
+ const expire = () => {
+ if (performance.now() < leaseDeadline) { armLeaseExpiry(); return; }
+ startupAbort.abort(new Error('[REMOTE_AGENT_EXPIRED] shared task authorization has expired'));
+ expireLive?.();
+ };
+ const remaining = leaseDeadline - performance.now();
+ if (remaining <= 0) { expire(); return; }
+ expiryTimer = setTimeout(expire, remaining);
+ (expiryTimer as { unref?: () => void }).unref?.();
+ }
+ if (openingDirectRoute) armLeaseExpiry();
const webFetch = deps.webFetch && shared ? deps.webFetch : undefined;
const collect = { skipCredentials: shared };
- return startRemoteAgentSession(input.agentKind, opts, {
+ let cancelPreparedHandle: (() => void) | undefined;
+ const handle = await startRemoteAgentSession(input.agentKind, opts, {
+ startupSignal: attempt.signal,
readImageDeliveryEpoch: deps.readImageDeliveryEpoch,
invoke: poller.invoke,
poller,
- pool: poolFor(input.deviceId),
+ pool: poolFor(target),
rgPath: deps.rgPath(),
codexPath: () => deps.codexPath?.(),
- ...(opts[LOCAL_AGENT_CLIENT]?.groupAssigned || (sessionId && deps.isGroupAssigned?.(sessionId))
+ ...(target !== input.deviceId || opts[LOCAL_AGENT_CLIENT]?.groupAssigned || (sessionId && deps.isGroupAssigned?.(sessionId))
? { groupAssigned: true } : {}),
...(groupSwitch && sessionId
? {
@@ -277,6 +464,240 @@ export function createDeviceAgentStarter(deps: DeviceAgentServiceDeps) {
info: (message, fields) => log.info(message, fields),
warn: (message, fields) => log.warn(message, fields),
},
+ }).then(handle => {
+ // Keep cancellation attached until the service finishes its optional early renewal.
+ cancelPreparedHandle = () => { void handle.close({ reason: 'account-boundary' }).catch(() => undefined); };
+ attempt.signal.addEventListener('abort', cancelPreparedHandle, { once: true });
+ if (startupAbort.signal.aborted) {
+ cancelPreparedHandle();
+ throw startupAbort.signal.reason;
+ }
+ return handle;
+ }).catch(async (error: unknown) => {
+ if (cancelPreparedHandle) attempt.signal.removeEventListener('abort', cancelPreparedHandle);
+ if (expiryTimer) clearTimeout(expiryTimer);
+ const ownsDirectIdentity = !!sessionId
+ && liveDirectGuestSessions.get(sessionId)?.identity === directIdentity;
+ clearDirectIdentity();
+ if (target !== input.deviceId && shareId && sessionId) {
+ const taskKey = `${shareId}:${sessionId}`;
+ const failed = directTasks.get(taskKey);
+ if (ownsDirectIdentity && failed?.target === target && failed.generation === openingDirectGeneration) {
+ directTasks.delete(taskKey);
+ if (startupAbort.signal.aborted) void releaseFailedDirectAllocation(openingDirectGeneration);
+ else await releaseFailedDirectAllocation(openingDirectGeneration);
+ }
+ // A native resume ID belongs only to M, including failure after caps.
+ if (opts.resumeSessionId || startupAbort.signal.aborted
+ || (error instanceof Error && error.message.startsWith('[REMOTE_AGENT_EXPIRED]'))) throw error;
+ // M can disappear after caps succeeds. O's established relay path may
+ // still reach another group member, so retry that same share route once.
+ requireCurrent();
+ const fallback = await startAttempt(input, true, attempt);
+ target = input.deviceId;
+ return fallback;
+ }
+ throw error;
});
+ if (attempt.signal.aborted) {
+ if (expiryTimer) clearTimeout(expiryTimer);
+ if (cancelPreparedHandle) attempt.signal.removeEventListener('abort', cancelPreparedHandle);
+ const ownsIdentity = !!sessionId && liveDirectGuestSessions.get(sessionId)?.identity === directIdentity;
+ clearDirectIdentity();
+ if (ownsIdentity && shareId && sessionId && directTasks.get(shareId + ':' + sessionId) === openingDirectRoute) {
+ directTasks.delete(shareId + ':' + sessionId);
+ void releaseFailedDirectAllocation(openingDirectGeneration);
+ }
+ void handle.close({ reason: 'account-boundary' }).catch(() => undefined);
+ throw attempt.signal.reason;
+ }
+ if (shareId && sessionId && target !== input.deviceId) {
+ const taskKey = `${shareId}:${sessionId}`;
+ const targetDeviceId = parseProviderSharePeer(target)?.deviceId;
+ const report = (running: boolean) => {
+ void remoteAgentInvoker(input.deviceId, deps.remoteInvoke)([{
+ op: 'direct-status', sessionId, running,
+ }]).catch(() => undefined);
+ };
+ const statusTimer = setInterval(() => report(handle.isTurnRunning?.() === true), 30_000);
+ (statusTimer as { unref?: () => void }).unref?.();
+ let authorizedUntil = openingDirectRoute?.authorizedUntil ?? Date.now();
+ // The same monotonic budget has been active throughout local preparation and M startup.
+ let nextRenewAt = Math.min(Date.now() + 20 * 60_000, authorizedUntil - 9 * 60_000);
+ // The proxy's model snapshot can lag behind a successful setModel RPC.
+ let authorizedModel = handle.model;
+ let renewing = false;
+ let stopped = false;
+ const clearLiveTarget = trackLiveSharedTaskTarget(sessionId, input.deviceId, target,
+ () => !stopped && Date.now() < authorizedUntil && performance.now() < leaseDeadline);
+ let awaitingTurnEnd = false;
+ let authorizationTurn = Promise.resolve();
+ const serializeAuthorization = <T>(work: () => Promise<T>): Promise<T> => {
+ const result = authorizationTurn.then(work);
+ authorizationTurn = result.then(() => undefined, () => undefined);
+ return result;
+ };
+ const authorizeCurrentExecutor = async (model: string): Promise<void> => {
+ if (stopped || !targetDeviceId || !deps.renewSharedProviderLink) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] shared executor authorization cannot be renewed');
+ }
+ const allocationStartedAt = Date.now();
+ const allocationStartedMonotonic = performance.now();
+ const value = await remoteAgentInvoker(input.deviceId, deps.remoteInvoke)([{
+ op: 'allocate', agentKind: input.agentKind, model, sessionId,
+ preferredExecutorDeviceId: targetDeviceId,
+ }]);
+ const row = value && typeof value === 'object'
+ ? value as { deviceId?: unknown; generation?: unknown } : null;
+ if (row?.deviceId !== targetDeviceId) {
+ directTasks.delete(taskKey);
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] current shared executor cannot accept this model');
+ }
+ const releaseStoppedGrant = async (): Promise<never> => {
+ const generation = typeof row.generation === 'string' && DIRECT_GRANT_ID.test(row.generation) ? row.generation : undefined;
+ await releaseFailedDirectAllocation(generation);
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] shared task has closed');
+ };
+ if (stopped) return releaseStoppedGrant();
+ await deps.renewSharedProviderLink(target);
+ if (stopped) return releaseStoppedGrant();
+ const nextLeaseDeadline = sharedTaskLeaseDeadline(value, allocationStartedMonotonic) ?? allocationStartedMonotonic + 30 * 60_000;
+ directTasks.set(taskKey, { target, agentKind: input.agentKind, model,
+ until: allocationStartedAt + 25 * 60_000,
+ authorizedUntil: allocationStartedAt + 29 * 60_000,
+ leaseDeadline: nextLeaseDeadline,
+ ...(typeof row.generation === 'string' && DIRECT_GRANT_ID.test(row.generation)
+ ? { generation: row.generation } : {}) });
+ authorizedUntil = allocationStartedAt + 29 * 60_000;
+ leaseDeadline = nextLeaseDeadline;
+ armLeaseExpiry();
+ nextRenewAt = Math.min(Date.now() + 20 * 60_000, authorizedUntil - 9 * 60_000);
+ };
+ const renewTimer = deps.renewSharedProviderLink ? setInterval(() => {
+ if (renewing || Date.now() < nextRenewAt) return;
+ renewing = true;
+ void serializeAuthorization(() => authorizeCurrentExecutor(authorizedModel)).catch((error: unknown) => {
+ log.warn('shared provider direct authorization renewal failed', { error: String(error) });
+ }).finally(() => {
+ renewing = false;
+ // After a failed renewal, retry while the existing 30-minute lease is still alive.
+ if (nextRenewAt <= Date.now()) nextRenewAt = Date.now() + 60_000;
+ });
+ }, 60_000) : null;
+ (renewTimer as { unref?: () => void } | null)?.unref?.();
+ if (handle.setModel) {
+ const setModel = handle.setModel.bind(handle);
+ handle.setModel = (model, options) => serializeAuthorization(async () => {
+ const previousModel = authorizedModel;
+ if (model === previousModel) return setModel(model, options);
+ if (awaitingTurnEnd || handle.isTurnRunning?.() === true || handle.isPreparingUserTurn?.() === true) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] wait for the shared task turn to finish before changing models');
+ }
+ // The executor's lease pins one model. Reauthorize the same M before
+ // asking its live Agent to switch, then restore the old model on failure.
+ try {
+ await authorizeCurrentExecutor(model);
+ await setModel(model, options);
+ authorizedModel = model;
+ } catch (error) {
+ if (stopped) throw error;
+ // The allocate response can be lost after O has already changed M's
+ // lease. Reconfirm A even when B's outcome is ambiguous.
+ try {
+ await authorizeCurrentExecutor(previousModel);
+ await setModel(previousModel, { providerId: null });
+ } catch (restoreError) {
+ directTasks.delete(taskKey);
+ log.warn('shared provider previous model could not be restored', { error: String(restoreError) });
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] previous shared model authorization could not be confirmed');
+ }
+ throw error;
+ }
+ });
+ }
+ const events = handle.events.bind(handle);
+ handle.events = () => ({
+ async *[Symbol.asyncIterator]() {
+ for await (const event of events()) {
+ if (event.type === 'done' || (event.type === 'error' && event.data
+ && typeof event.data === 'object' && 'isTerminal' in event.data && event.data.isTerminal === true)) {
+ awaitingTurnEnd = false;
+ }
+ yield event;
+ }
+ },
+ });
+ const send = handle.send.bind(handle);
+ handle.send = (message, options) => serializeAuthorization(async () => {
+ if (stopped) throw new Error('[REMOTE_AGENT_UNAVAILABLE] shared task authorization has ended');
+ // A failed background renewal must become a visible error before a
+ // later turn uses an expired grant on the old executor.
+ if (Date.now() >= authorizedUntil) await authorizeCurrentExecutor(authorizedModel);
+ report(true);
+ awaitingTurnEnd = true;
+ try { await send(message, options); }
+ catch (error) { awaitingTurnEnd = false; throw error; }
+ finally { report(handle.isTurnRunning?.() === true); }
+ });
+ const close = handle.close.bind(handle);
+ const stop = () => {
+ stopped = true;
+ if (cancelPreparedHandle) attempt.signal.removeEventListener('abort', cancelPreparedHandle);
+ clearLiveTarget();
+ clearDirectIdentity();
+ clearInterval(statusTimer);
+ if (renewTimer) clearInterval(renewTimer);
+ if (expiryTimer) clearTimeout(expiryTimer);
+ report(false);
+ };
+ expireLive = () => {
+ if (stopped) return;
+ stop();
+ // Local teardown does not wait for the expired remote route to accept close.
+ void close({ reason: 'account-boundary' }).catch((error: unknown) => {
+ log.warn('shared provider expired task close notification failed', { error: String(error) });
+ });
+ };
+ handle.close = async (options) => { stop(); await close(options); };
+ if (handle.detach) {
+ const detach = handle.detach.bind(handle);
+ handle.detach = async (options) => { stop(); await detach(options); };
+ }
+ // Opening a resumed task can take longer than the early-renewal window.
+ // Refresh before handing it back if that window has already passed.
+ if (nextRenewAt <= Date.now()) {
+ try { await serializeAuthorization(() => authorizeCurrentExecutor(authorizedModel)); }
+ catch (error) {
+ stop();
+ await close().catch(() => undefined);
+ throw error;
+ }
+ }
+ }
+ // Keep the switch intent across a failed open. O binds the token to this
+ // guest and task; release it only after a usable session is returned.
+ if (cancelPreparedHandle) attempt.signal.removeEventListener('abort', cancelPreparedHandle);
+ if (switchToken && sessionId) groupSwitch?.release?.(sessionId);
+ return handle;
+ };
+ return async (input: StartInput): Promise<AgentSessionHandle> => {
+ if (!input.options.sessionId) throw new Error('remote agent sessions require a session id');
+ const attempt = registerPendingRemoteStart(input.options.sessionId);
+ let ready: AgentSessionHandle | undefined;
+ let rejectCancelled!: (error: unknown) => void;
+ const cancelled = new Promise<never>((_, reject) => { rejectCancelled = reject; });
+ const closeCancelled = () => { void ready?.close({ reason: 'account-boundary' }).catch(() => undefined); };
+ const onCancel = () => { closeCancelled(); rejectCancelled(attempt.signal.reason); };
+ attempt.signal.addEventListener('abort', onCancel, { once: true });
+ try {
+ return await Promise.race([startAttempt(input, false, attempt).then(handle => {
+ ready = handle;
+ if (attempt.signal.aborted) { closeCancelled(); throw attempt.signal.reason; }
+ return handle;
+ }), cancelled]);
+ } finally {
+ attempt.signal.removeEventListener('abort', onCancel);
+ attempt.dispose();
+ }
};
}
diff --git a/apps/desktop/src/main/remote-agent/controller/startRemote.ts b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
index 218c7a3fca..498ef7a9cd 100644
--- a/apps/desktop/src/main/remote-agent/controller/startRemote.ts
+++ b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
@@ -1,3 +1,4 @@
+import { currentSessionCreationSignal } from '../../localDb/sessionRuntimeCleanup.js';
/**
* 在另一台电脑上启动 Agent、任务留在本机(控制端入口)。
*
@@ -65,6 +66,8 @@ export interface PreparedRemoteMcp {
}
export interface StartRemoteAgentDeps {
+ /** Cancellation for this startup attempt only; never cancels other starts of the task. */
+ startupSignal?: AbortSignal;
readImageDeliveryEpoch?(sessionId: string): Promise<number>;
invoke: RemoteAgentInvoke;
/** 这台电脑的共享拉取器(同一台电脑上的任务共用一个 poll);缺省时本任务单独一个。 */
@@ -298,6 +301,27 @@ export function cancelPendingRemoteStart(sessionId: string): void {
for (const cancel of [...pendingStarts.get(sessionId) ?? []]) cancel();
}
+/** Reuse terminal cancellation from allocation through preparation, without a permanent task tombstone. */
+export function registerPendingRemoteStart(sessionId: string, parent = currentSessionCreationSignal(sessionId)) {
+ const controller = new AbortController();
+ const abort = (reason = new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.')) => controller.abort(reason);
+ const cancel = () => abort();
+ const cancelParent = () => abort(parent?.reason);
+ const cancels = pendingStarts.get(sessionId) ?? new Set<() => void>();
+ pendingStarts.set(sessionId, cancels);
+ cancels.add(cancel);
+ parent?.addEventListener('abort', cancelParent, { once: true });
+ if (parent?.aborted) cancelParent();
+ return {
+ signal: controller.signal, abort,
+ dispose() {
+ parent?.removeEventListener('abort', cancelParent);
+ cancels.delete(cancel);
+ if (!cancels.size && pendingStarts.get(sessionId) === cancels) pendingStarts.delete(sessionId);
+ },
+ };
+}
+
export async function startRemoteAgentSession(
kind: RemoteAgentKind,
opts: StartSessionOptions,
@@ -306,21 +330,38 @@ export async function startRemoteAgentSession(
if (!opts.sessionId) throw new Error('remote agent sessions require a session id');
// 第一处异步准备之前登记,MCP 启动期间的删除/归档也不能漏掉。
const sessionId = opts.sessionId;
- const abort = new AbortController();
- const cancel = () => abort.abort();
- const cancels = pendingStarts.get(sessionId) ?? new Set<() => void>();
- pendingStarts.set(sessionId, cancels);
- cancels.add(cancel);
+ const abort = registerPendingRemoteStart(sessionId, deps.startupSignal);
+ const expired = () => new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.');
+ let rejectCancelled!: (error: unknown) => void;
+ const cancelled = new Promise<never>((_, reject) => { rejectCancelled = reject; });
+ let preparedHandle: AgentSessionHandle | undefined;
+ const closeCancelledHandle = () => {
+ void preparedHandle?.close({ reason: 'account-boundary' }).catch(() => undefined);
+ };
+ const onCancelled = () => {
+ closeCancelledHandle();
+ rejectCancelled(abort.signal.reason ?? expired());
+ };
+ abort.signal.addEventListener('abort', onCancelled, { once: true });
const timing = remoteAgentStartupTiming(deps.log, { side: 'controller', kind, sessionId });
let status: 'ok' | 'failed' = 'failed';
try {
- const handle = await prepareAndStartRemoteAgentSession(kind, opts, deps, abort.signal, timing);
+ if (abort.signal.aborted) throw abort.signal.reason ?? expired();
+ // Reject promptly even when MCP preparation or a remote RPC ignores cancellation.
+ // The preparation path still owns cleanup of any late result.
+ const handle = await Promise.race([
+ prepareAndStartRemoteAgentSession(kind, opts, deps, abort.signal, timing).then(handle => {
+ preparedHandle = handle;
+ if (abort.signal.aborted) { closeCancelledHandle(); throw abort.signal.reason ?? expired(); }
+ return handle;
+ }), cancelled,
+ ]);
status = 'ok';
return handle;
} finally {
+ abort.signal.removeEventListener('abort', onCancelled);
+ abort.dispose();
timing.finish(status);
- cancels.delete(cancel);
- if (!cancels.size && pendingStarts.get(sessionId) === cancels) pendingStarts.delete(sessionId);
}
}
@@ -380,16 +421,35 @@ async function prepareAndStartRemoteAgentSession(
}
: {}),
});
+ let preparedMcp: PreparedRemoteMcp | undefined;
+ let executorDisposal: Promise<void> | undefined;
+ const disposePreparation = async (): Promise<void> => {
+ const prepared = preparedMcp;
+ preparedMcp = undefined;
+ executorDisposal ??= Promise.resolve().then(() => executor.close());
+ const results = await Promise.allSettled([
+ executorDisposal, Promise.resolve().then(() => prepared?.dispose()),
+ ]);
+ const failures = results.flatMap(result => result.status === 'rejected' ? [result.reason] : []);
+ if (failures.length) throw new AggregateError(failures, 'Remote agent preparation cleanup failed');
+ };
+ const cancelPreparation = () => { void disposePreparation().catch(error => {
+ deps.log?.warn('remote agent: cancelled preparation cleanup failed', { error: String(error) });
+ }); };
+ signal.addEventListener('abort', cancelPreparation, { once: true });
const vendorOptions: Record<string, unknown> = { ...(opts.vendorOptions ?? {}) };
- const mcp = await startupTiming
- .measure('mcp-prepare', () => deps.prepareMcp({ kind, opts, vendorOptions }))
- .catch((error) => {
- void executor.close();
- throw error;
- });
- if (signal.aborted) {
- try { mcp.dispose(); } finally { await executor.close(); }
- throw new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.');
+ let mcp: PreparedRemoteMcp;
+ try {
+ if (signal.aborted) throw signal.reason;
+ mcp = await startupTiming.measure('mcp-prepare', () => deps.prepareMcp({ kind, opts, vendorOptions }));
+ preparedMcp = mcp;
+ if (signal.aborted) throw signal.reason;
+ } catch (error) {
+ // A late MCP result is disposed here even though the caller already rejected.
+ await disposePreparation();
+ throw error;
+ } finally {
+ signal.removeEventListener('abort', cancelPreparation);
}
const router = createReverseHttpRouter({ executor, mcpTarget: (name) => mcp.servers.get(name), hostToolsOnly });
@@ -430,6 +490,10 @@ async function prepareAndStartRemoteAgentSession(
};
// 其它回调会改这两个值:读的时候不让 TypeScript 按局部赋值收窄。
const stateNow = (): LinkState => linkState;
+ const requireOpen = () => {
+ signal.throwIfAborted();
+ if (stateNow() === 'closed') throw new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.');
+ };
const activeNow = (): RemoteAgentRunClient | null => active;
// Codex:对方的 Codex 把本机当作 exec-server 执行环境。
const codexPath = kind === 'codex' && !hostToolsOnly ? deps.codexPath?.() : undefined;
@@ -513,8 +577,7 @@ async function prepareAndStartRemoteAgentSession(
localDisposal = Promise.allSettled([
Promise.resolve().then(() => leavePool?.()),
Promise.resolve().then(() => relay?.close()),
- Promise.resolve().then(() => mcp.dispose()),
- Promise.resolve().then(() => executor.close()),
+ Promise.resolve().then(() => disposePreparation()),
]).then((results) => {
const failures = results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
if (failures.length) throw new AggregateError(failures, 'Remote agent local resource cleanup failed');
@@ -540,7 +603,7 @@ async function prepareAndStartRemoteAgentSession(
const expectedResume = payload.options.resumeSessionId;
let resumeLost = false;
// 只处理当前这条连接的往来;正在让出名额的那条剩下的收尾不再进任务。
- const isCurrent = () => active === client && linkState !== 'releasing';
+ const isCurrent = () => active === client && linkState !== 'releasing' && linkState !== 'closed';
// 连回时只补新映射,不替换已有的(见 ExecutorWorkspace.addAliases)。
const applyProjection = (projection: Parameters<typeof shadowAliases>[0], virtualRoot: string | undefined) => {
const aliases = shadowAliases(projection, workspace.workingDir, personalRoots, openedDirs);
@@ -634,8 +697,10 @@ async function prepareAndStartRemoteAgentSession(
}, deps.newId, deps.log);
if (stateNow() === 'closed') throw new Error('[REMOTE_AGENT_EXPIRED] The task has ended on this computer.');
active = client;
+ let remoteStarted = false;
try {
const raw = await client.open(kind, payload);
+ remoteStarted = true;
if (closedEarly) throw new Error((closedEarly as { message?: string }).message ?? '[REMOTE_AGENT_UNAVAILABLE] The agent stopped right after starting.');
if (stateNow() === 'closed') {
// 连回途中任务关掉了(那时还没有这条连接可关):对方已经起了进程,关掉它让出名额。
@@ -659,8 +724,17 @@ async function prepareAndStartRemoteAgentSession(
}
return client;
} catch (error) {
- client.abandon('start-failed');
if (active === client) active = null;
+ if (remoteStarted && !client.isClosed) {
+ // An invalid started descriptor or a local bootstrap error can occur
+ // after the other computer has started its Agent. End that run before
+ // the caller falls back to another executor.
+ await client.close('close', 'navigation').catch((closeError) => {
+ deps.log?.warn('remote agent: closing a failed startup run failed', {
+ runId: client.runId, error: String(closeError),
+ });
+ });
+ } else client.abandon('start-failed');
throw error;
}
}
@@ -707,16 +781,19 @@ async function prepareAndStartRemoteAgentSession(
const imageDeliveryEpoch = await timing.measure('image-epoch', async () =>
deps.readImageDeliveryEpoch?.(opts.sessionId!),
);
+ requireOpen();
const startOptions = openOptions(reconnect);
const projectFiles = await timing
.measure('project-files', () => hostToolsOnly ? Promise.resolve([]) : deps.collectProjectFiles(opts.workingDir))
.catch(() => []);
+ requireOpen();
const ancestorFiles = await timing
.measure(
'ancestor-files',
() => (!hostToolsOnly && deps.collectAncestorFiles?.(opts.workingDir) || Promise.resolve([])),
)
.catch(() => []);
+ requireOpen();
// 每次打开(含连回)都重新看一遍:上级目录里的标记以这次打开时为准。
const ancestorMarkers = await timing
.measure(
@@ -724,12 +801,14 @@ async function prepareAndStartRemoteAgentSession(
() => (!hostToolsOnly && deps.collectAncestorMarkers?.(opts.workingDir) || Promise.resolve(undefined)),
)
.catch(() => undefined);
+ requireOpen();
const collectedPersonal = await timing
.measure(
'personal-config',
() => (!hostToolsOnly && deps.collectPersonal?.(kind, projectFiles) || Promise.resolve(null)),
)
.catch(() => null);
+ requireOpen();
personalRoots = collectedPersonal?.roots ?? [];
const personal = collectedPersonal?.personal ?? { files: [] };
const importFiles =
@@ -740,6 +819,9 @@ async function prepareAndStartRemoteAgentSession(
)
.catch(() => [])
: [];
+ requireOpen();
+ const gitRepo = await timing.measure('git-probe', () => deps.isGitRepo(opts.workingDir)).catch(() => false);
+ requireOpen();
return {
sessionId: opts.sessionId!,
acceptsImageDeliveryReceipts: true,
@@ -754,9 +836,7 @@ async function prepareAndStartRemoteAgentSession(
osVersion: `${os.type()} ${os.release()}`,
// 仅供被控端把项目说明中的本机 Home 路径投影到虚拟工作区;不会进入 deviceHosted。
homeDir: os.homedir(),
- isGitRepo: await timing
- .measure('git-probe', () => deps.isGitRepo(opts.workingDir))
- .catch(() => false),
+ isGitRepo: gitRepo,
},
projectFiles,
ancestorFiles,
@@ -799,6 +879,7 @@ async function prepareAndStartRemoteAgentSession(
return RemoteAgentRunClient.caps(deps.invoke);
}),
);
+ requireOpen();
if (caps.virtualWorkspace !== true) {
throw new Error('[REMOTE_AGENT_UNSUPPORTED] The other computer does not support the virtual workspace required to protect local paths.');
}
@@ -808,7 +889,9 @@ async function prepareAndStartRemoteAgentSession(
deps.pool?.noteMaxRuns(caps.maxRuns);
deps.pool?.noteIdleReclaimMinutes(caps.idleReclaimMinutes);
await timing.measure('connection-slot', async () => deps.pool?.beforeOpen(member));
+ requireOpen();
const payload = await buildPayload(reconnect, timing);
+ requireOpen();
try {
const client = await timing.measure('remote-open', () =>
openRun(payload, reconnect, onOpened),
@@ -938,9 +1021,18 @@ async function prepareAndStartRemoteAgentSession(
kind,
...(client ? { runId: client.runId } : {}),
});
- if (client) void client.close('close', 'navigation').catch(() => undefined);
+ active = null;
+ if (client) {
+ // Notify M, but end reverse HTTP/WS and local resources without waiting for M.
+ void client.close('close', 'navigation').catch(() => undefined);
+ client.abandon('start-cancelled');
+ }
+ void disposeLocal().catch(error => {
+ deps.log?.warn('remote agent: cancelled startup cleanup failed', { error: String(error) });
+ });
};
signal.addEventListener('abort', cancelStart, { once: true });
+ if (signal.aborted) cancelStart();
try {
await connect(false, (started) => {
firstStarted = started;
diff --git a/apps/desktop/src/main/remote-agent/executor/__tests__/virtualWorkspace.test.ts b/apps/desktop/src/main/remote-agent/executor/__tests__/virtualWorkspace.test.ts
index 1860c678bb..0f1dd606a4 100644
--- a/apps/desktop/src/main/remote-agent/executor/__tests__/virtualWorkspace.test.ts
+++ b/apps/desktop/src/main/remote-agent/executor/__tests__/virtualWorkspace.test.ts
@@ -27,7 +27,7 @@ function written(local: string, virtual: string): string { return virtual.starts
/** 转发给 exec-server 的 Codex 请求里与沙箱有关的字段。 */
interface MappedSandboxRequest {
cwd?: string;
- sandbox: { cwd?: string; userHomeDir?: string; permissions: { file_system: { entries: unknown[] } } };
+ sandbox: { cwd?: string; userHomeDir?: string; windowsSandboxLevel?: unknown; permissions: { file_system: { entries: unknown[] } } };
}
function setup(virtual: string) {
@@ -590,6 +590,7 @@ describe('virtual workspace', () => {
] } },
cwd: 'file:///home/agent/workspace',
userHomeDir: 'file:///home/agent',
+ windowsSandboxLevel: 'disabled',
};
const params = mapExecServerParams({ path: 'file:///home/agent/workspace/a.txt', sandbox }, workspace, 'fs/readFile') as MappedSandboxRequest;
expect(params.sandbox.permissions.file_system.entries).toEqual([
@@ -606,6 +607,11 @@ describe('virtual workspace', () => {
]);
expect(params.sandbox.cwd).toBe(pathToFileURL(project).href);
expect(params.sandbox.userHomeDir).toBe(pathToFileURL(os.homedir()).href);
+ expect(params.sandbox.windowsSandboxLevel).toBe(process.platform === 'win32' ? 'restricted-token' : 'disabled');
+ const explicit = mapExecServerParams({ sandbox: { ...sandbox, windowsSandboxLevel: 'mxc' } }, workspace) as MappedSandboxRequest;
+ expect(explicit.sandbox.windowsSandboxLevel).toBe('mxc');
+ const unrestricted = mapExecServerParams({ sandbox: { ...sandbox, permissions: { type: 'unrestricted' } } }, workspace) as MappedSandboxRequest;
+ expect(unrestricted.sandbox.windowsSandboxLevel).toBe('disabled');
// 没有虚拟工作区(旧版对端)时沙箱原样转发,与之前一致。
const plain = new ExecutorWorkspace({ workingDir: project });
expect((mapExecServerParams({ sandbox }, plain) as MappedSandboxRequest).sandbox).toBe(sandbox);
diff --git a/apps/desktop/src/main/remote-agent/host/providerAccess.ts b/apps/desktop/src/main/remote-agent/host/providerAccess.ts
index a86f11c83d..848d20f58f 100644
--- a/apps/desktop/src/main/remote-agent/host/providerAccess.ts
+++ b/apps/desktop/src/main/remote-agent/host/providerAccess.ts
@@ -19,8 +19,11 @@ import type { RemoteAgentHostDeps } from './runHost.js';
/** Shared users and same-account group relays both need a guest-isolated proxy binding. */
export function createGuestProviderRouteBinder(deps: {
recordRequestUsage?(controller: string, providerId: string, kind: AgentKind, sample: GuestRequestUsage): void;
+ receiptMeteringAllowed?(controller: string, sessionId: string): boolean;
readProviders(): Promise<readonly ProviderView[]>;
- guestAccess(controller: string): { providerId: string; memberId: string } | null;
+ guestAccess(controller: string, sessionId: string): { providerId: string; memberId: string } | null;
+ modelAllowed?(controller: string, model: string, sessionId: string): boolean;
+ modelRestricted?(controller: string, sessionId: string): boolean;
ownerAllowed(controller: string): boolean;
providerAllowed(providerId: string): boolean;
memberBudgetDenial?(providerId: string, model: string, memberId?: string): { code: string; message: string } | null;
@@ -30,7 +33,7 @@ export function createGuestProviderRouteBinder(deps: {
read(providerId: string, memberId?: string): { models: readonly string[] | null; providerModels: readonly string[] | null; memberBudget?: { enabled: boolean; rules: unknown[] } | null };
};
}): NonNullable<RemoteAgentHostDeps['bindGuestProviderRoute']> {
- return async ({ kind, hostSessionId, providerId, controller, isCurrent, relayModelAccess }) => {
+ return async ({ kind, hostSessionId, providerId, controller, sessionId, isCurrent, relayModelAccess }) => {
const views = await deps.readProviders();
// An obsolete asynchronous launch must never replace the current binding.
if (!isCurrent()) return null;
@@ -38,15 +41,21 @@ export function createGuestProviderRouteBinder(deps: {
// not a direct-share member of this computer. Intersect this computer's
// provider grants with the original member's live grant at the coordinator.
const sharedPeer = isProviderSharePeer(controller);
- const memberId = sharedPeer ? deps.guestAccess(controller)?.memberId : undefined;
+ const memberId = sharedPeer ? deps.guestAccess(controller, sessionId)?.memberId : undefined;
const providerAllowed = (): boolean => {
- const access = sharedPeer ? deps.guestAccess(controller) : null;
+ const access = sharedPeer ? deps.guestAccess(controller, sessionId) : null;
return (sharedPeer
? !!access && access.memberId === memberId && access.providerId === providerId
: deps.ownerAllowed(controller)) && deps.providerAllowed(providerId);
};
if (!providerAllowed()) return null;
- const localAllows = (model: string) => isCurrent() && providerAllowed() && deps.modelAccess.allows(providerId, model, memberId);
+ // The CLI catalog lists models the member may switch to; the current M
+ // lease pins the model allowed to execute right now. G must reauthorize
+ // that same task at O before the proxy permits a different model.
+ const catalogAllows = (model: string) => isCurrent() && providerAllowed()
+ && deps.modelAccess.allows(providerId, model, memberId);
+ const localAllows = (model: string) => catalogAllows(model)
+ && (deps.modelAllowed?.(controller, model, sessionId) ?? true);
const relayDenials = new Map<string, { code: string; message: string }>();
const allowsModel = async (model: string) => {
relayDenials.delete(model);
@@ -66,11 +75,15 @@ export function createGuestProviderRouteBinder(deps: {
// The native runtime freezes this list at startup. Keep temporary pauses out of
// it: each request is checked live, and a recovered model must work without restart.
const modelIds = guestProviderModelIds(views, providerId, kind)
- .filter(model => localAllows(model) && (!relayModelAccess || relayModelAccess.models.includes(model)));
+ .filter(model => catalogAllows(model) && (!relayModelAccess || relayModelAccess.models.includes(model)));
if (!isCurrent()) return null;
const provider = views.find(view => view.id === providerId);
- const receiptMetering = sharedPeer && (kind === 'codex' || kind === 'pi') && provider && providerWeeklyQuotaSource(provider) === 'codex' && !!deps.recordRequestUsage;
+ // Delegated runs send their turn counters to O. Local-only proxy receipts
+ // would otherwise zero those counters without delivering them to O.
+ const receiptMetering = sharedPeer && (deps.receiptMeteringAllowed?.(controller, sessionId) ?? true)
+ && (kind === 'codex' || kind === 'pi') && provider && providerWeeklyQuotaSource(provider) === 'codex' && !!deps.recordRequestUsage;
const binding = registerGuestProviderRoute(hostSessionId, providerId, allowsModel, () => {
+ if (deps.modelRestricted?.(controller, sessionId)) return true;
if (relayModelAccess) return true;
try {
const rule = deps.modelAccess.read(providerId, memberId);
diff --git a/apps/desktop/src/main/remote-agent/host/runHost.ts b/apps/desktop/src/main/remote-agent/host/runHost.ts
index 109282324d..4b82d991e7 100644
--- a/apps/desktop/src/main/remote-agent/host/runHost.ts
+++ b/apps/desktop/src/main/remote-agent/host/runHost.ts
@@ -1,6 +1,6 @@
import type { GeneratedImageUpstream } from '../../cindy-media/generatedImageJournal';
import { remoteAgentStartupTiming } from '../startupTiming';
-import { parseProviderSharePeer } from '@cindy/device-link';
+import { parseProviderSharePeer, providerShareGuestPeer } from '@cindy/device-link';
import { DEFAULT_REMOTE_AGENT_LIMITS, type RemoteAgentLimits, type RemoteAgentLimitUsage } from '../../../shared/remoteAgentLimits.js';
/**
* 远程 Agent 运行服务(被控端:提供 Agent 登录、订阅与供应商的电脑)。
@@ -215,7 +215,7 @@ export interface RemoteAgentHostDeps {
* 记录受邀者每一轮的用量(分享者的管理页按人、按模型、按组内电脑展示)。只对 guest 调用。
* memberKey:这一轮在哪台组内电脑运行——转给组内电脑的是那台的键,在本机运行的是 `local`。
*/
- recordGuestUsage?(controller: string, usage: RunUsageRecord): void;
+ recordGuestUsage?(controller: string, usage: RunUsageRecord, sessionId?: string): void;
/** 记录同账号其他电脑每一轮的用量(远程与分享页按使用方展示)。只对 owner 调用。 */
recordOwnerUsage?(controller: string, usage: RunUsageRecord): void;
/**
@@ -226,10 +226,11 @@ export interface RemoteAgentHostDeps {
* 两者都带上控制端:供应商分享的受邀者只能用分享给它的那个供应商。
*/
providerAccess?: {
- resolve(kind: RemoteAgentKind, model: string, providerId: string | null | undefined, controller: string): Promise<string | null>;
- isAllowed(providerId: string, controller: string, model?: string): boolean;
- models?(kind: RemoteAgentKind, providerId: string, controller: string): Promise<string[]>;
- restricted?(providerId: string, controller: string): boolean;
+ resolve(kind: RemoteAgentKind, model: string, providerId: string | null | undefined, controller: string,
+ sessionId?: string): Promise<string | null>;
+ isAllowed(providerId: string, controller: string, model?: string, sessionId?: string): boolean;
+ models?(kind: RemoteAgentKind, providerId: string, controller: string, sessionId?: string): Promise<string[]>;
+ restricted?(providerId: string, controller: string, sessionId?: string): boolean;
};
/** 同账号任务在启动前登记来源和逐请求的实时模型授权,子代理同样受此约束。 */
bindOwnerProviderRoute?(hostSessionId: string, providerId: string, allowsModel?: (providerId: string, model: string) => boolean): OwnerProviderRouteBinding;
@@ -246,6 +247,7 @@ export interface RemoteAgentHostDeps {
hostSessionId: string;
providerId: string;
controller: string;
+ sessionId: string;
isCurrent(): boolean;
relayModelAccess?: { models: string[]; allows(model: string): Promise<boolean> };
}): Promise<GuestProviderRouteBinding | null>;
@@ -254,12 +256,33 @@ export interface RemoteAgentHostDeps {
* 组内电脑运行,本机中转。不提供 = 受邀者的任务一律在本机运行(现有接线)。
*/
groupRelay?: RemoteAgentGroupRelayDeps;
+ /** Group owner chooses an executor; executor accepts a bounded grant from its authenticated owner peer. */
+ directGuestExecution?: {
+ ownerScope(): string;
+ locate?(controller: string, request: Extract<RemoteAgentRequest, { op: 'direct-locate' }>): Promise<{ deviceId: string } | null>;
+ /** O accepts fresh relay history; native history must stay on its recorded M. */
+ acceptRelay?(controller: string, sessionId: string, hasNativeHistory: boolean): Promise<void>;
+ allocate(controller: string, request: Extract<RemoteAgentRequest, { op: 'allocate' }>): Promise<{ deviceId: string; generation: string; leaseDurationMs?: number } | null>;
+ status(controller: string, request: Extract<RemoteAgentRequest, { op: 'direct-status' }>): void;
+ release(controller: string, request: Extract<RemoteAgentRequest, { op: 'direct-release' }>): Promise<void>;
+ switch(controller: string, request: Extract<RemoteAgentRequest, { op: 'direct-switch' }>): Promise<{ token?: string }>;
+ switched?(controller: string, sessionId: string, token: string): Promise<void>;
+ sessionAllowed(controller: string, sessionId: string): boolean;
+ /** Unlike sessionAllowed, true only for a current, local G→M delegation. */
+ sessionDelegated(controller: string, sessionId: string): boolean;
+ usage(controller: string, request: Extract<RemoteAgentRequest, { op: 'direct-usage' }>): Promise<void> | void;
+ delegate(controller: string, request: Extract<RemoteAgentRequest, { op: 'delegate' }>): Promise<boolean>;
+ forget(ownerDeviceId: string, guestPeer: string, cleanupEpoch: number,
+ confirmedOwnership?: boolean): boolean;
+ };
/**
* 转分享(本机是分享者,docs/product-rules/provider-sharing.md §4.3):受邀者把这里分享的供应商放进了它自己的
* 供应商组又分享给了别人。组所在电脑(受邀者)经 op `reshare` 报上它分享的人,本机记下等主人逐人同意;组转来的
* 受邀者任务(带 relay)只在主人同意过的人上运行。不提供 = 不接受 op `reshare`、也不核对(测试 / 旧接线)。
*/
reshare?: {
+ /** Delegated G→M access never owns the original share's consent list. */
+ canUse?(controller: string): boolean;
sync(controller: string, entries: readonly RemoteAgentReshareEntry[], batch?: RemoteAgentReshareBatch): Promise<RemoteAgentReshareResult>;
allows(controller: string, reshareKey: string | undefined): boolean;
};
@@ -385,6 +408,7 @@ interface PendingReverse {
interface Run {
groupProviderId?: string;
id: string;
+ sessionId?: string;
controller: string;
trust: RemoteAgentControllerTrust;
/** 本机侧任务 id:影子目录按它存放,同一任务多次打开共用。 */
@@ -663,6 +687,8 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
relay?: string;
hostSessionIds: string[];
nativeIds: string[];
+ /** Direct/relay run IDs whose attachment subdirs may outlive a failed shutdown. */
+ attachmentRunIds?: string[];
/** 原生分叉会话 → 历史涉及的祖先任务目录;同账号远程任务也使用此索引。 */
forkWorkspaces?: Record<string, string[]>;
/**
@@ -679,63 +705,189 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
* 受邀者已删除、本机的数据已清掉,只剩这几台组内电脑还没通知到(当时离线等):之后每次清理时再试。
*/
forgetPending?: string[];
+ /** M's verified O for direct G→M tasks; retained after the short-lived delegation expires. */
+ directOwnerDeviceId?: string;
+ directOwnerScopeKey?: string;
+ cleanupEpoch?: number;
+ /** Completed deletion ID is retained so a lost ACK cannot purge a rejoined guest. */
+ lastDirectForgetId?: string;
}
const guestIndexFile = path.join(deps.runsRoot, 'guest-sessions.json');
const guestDigest = (scope: string) => createHash('sha256').update(scope).digest('hex').slice(0, 32);
let guestIndex: Promise<Map<string, GuestSessionRecord>> | null = null;
let guestIndexWrite: Promise<void> = Promise.resolve();
+ const directRunStarts = new WeakMap<Run, { work: Promise<void>; disposal?: Promise<void> }>();
+ const directGuestLocks = new Map<string, {
+ tail: Promise<void>;
+ forgets: Map<string, Promise<unknown>>;
+ }>();
+ let directGuestOperations = 0;
+
+ /** M serializes direct mutations per local account + guest, never across relay scopes.
+ * O's device identity stays in the ownership check and dedupe key: another O
+ * cannot inherit a successful forget ACK. Settled queues are removed; queued
+ * work is bounded even when a native startup or filesystem operation stalls.
+ */
+ function withDirectGuestLock(peer: string, fn: () => Promise<unknown>,
+ forget?: { controller: string; forgetId: string; cleanupEpoch: number }): Promise<unknown> {
+ const ownerScope = deps.directGuestExecution?.ownerScope();
+ if (!ownerScope) fail('REMOTE_AGENT_INVALID', 'direct guest account is unavailable');
+ const scope = JSON.stringify([ownerScope, peer]);
+ const forgetKey = forget && JSON.stringify([forget.controller, forget.forgetId, forget.cleanupEpoch]);
+ const previous = directGuestLocks.get(scope);
+ const duplicate = forgetKey ? previous?.forgets.get(forgetKey) : undefined;
+ if (duplicate) return duplicate;
+ if (directGuestOperations >= 256) fail('REMOTE_AGENT_BUSY', 'too many pending shared task operations');
+ const queue = previous ?? { tail: Promise.resolve(), forgets: new Map<string, Promise<unknown>>() };
+ const owner = deps.captureOwner();
+ directGuestOperations += 1;
+ const work = queue.tail.then(() => {
+ if (disposed || !deps.isOwnerCurrent(owner) || deps.directGuestExecution?.ownerScope() !== ownerScope) {
+ fail('REMOTE_AGENT_UNAVAILABLE', 'direct guest account changed');
+ }
+ return fn();
+ });
+ const tail = work.then(() => undefined, () => undefined).finally(() => {
+ directGuestOperations -= 1;
+ if (forgetKey) queue.forgets.delete(forgetKey);
+ if (queue.tail === tail) directGuestLocks.delete(scope);
+ });
+ queue.tail = tail;
+ if (forgetKey) queue.forgets.set(forgetKey, work);
+ directGuestLocks.set(scope, queue);
+ return work;
+ }
- function readRelayMembers(value: unknown): Record<string, GroupRelayMember> | undefined {
- if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
- const out: Record<string, GroupRelayMember> = {};
- for (const [nativeId, raw] of Object.entries(value as Record<string, unknown>)) {
- const item = raw as Partial<GroupRelayMember> | null;
- if (!item || typeof item.memberKey !== 'string' || typeof item.agentDeviceId !== 'string' || typeof item.providerId !== 'string') continue;
- out[nativeId] = { memberKey: item.memberKey, agentDeviceId: item.agentDeviceId, providerId: item.providerId, sameAccount: item.sameAccount === true };
+ function parseGuestIndex(raw: string): Map<string, GuestSessionRecord> {
+ const invalid = (): never => { throw new Error('Remote agent guest session index is invalid'); };
+ const object = (value: unknown): value is Record<string, unknown> =>
+ !!value && typeof value === 'object' && !Array.isArray(value);
+ const nonempty = (value: unknown): value is string => typeof value === 'string' && value.length > 0;
+ const uuid = (value: unknown): value is string => typeof value === 'string' && /^[0-9a-f-]{36}$/.test(value);
+ const list = (value: unknown, valid: (item: unknown) => boolean = nonempty): string[] => {
+ if (value === undefined) return [];
+ if (!Array.isArray(value) || !value.every(valid)) invalid();
+ return value as string[];
+ };
+ const parsed: unknown = JSON.parse(raw);
+ if (!object(parsed)) invalid();
+ const map = new Map<string, GuestSessionRecord>();
+ for (const [digest, value] of Object.entries(parsed as Record<string, unknown>)) {
+ if (!object(value)) invalid();
+ const record = value as Record<string, unknown>;
+ if (!nonempty(record.controller) || (record.relay !== undefined && !nonempty(record.relay))) invalid();
+ if (digest !== guestDigest(guestScopeOf(record.controller as string, record.relay as string | undefined))) invalid();
+ list(record.hostSessionIds, uuid);
+ list(record.nativeIds);
+ list(record.attachmentRunIds, uuid);
+ list(record.relayDevices);
+ list(record.forgetPending);
+ if (record.forkWorkspaces !== undefined) {
+ if (!object(record.forkWorkspaces)) invalid();
+ for (const [nativeId, ids] of Object.entries(record.forkWorkspaces as Record<string, unknown>)) {
+ if (!nativeId || ids === undefined) invalid();
+ list(ids, uuid);
+ }
+ }
+ if (record.members !== undefined) {
+ if (!object(record.members)) invalid();
+ for (const [nativeId, member] of Object.entries(record.members as Record<string, unknown>)) {
+ if (!nativeId || !object(member)) return invalid();
+ if (!nonempty(member.memberKey)
+ || (!nonempty(member.agentDeviceId) && !(member.agentDeviceId === ''
+ && member.memberKey === PROVIDER_GROUP_LOCAL_MEMBER_KEY)) || !nonempty(member.providerId)
+ || (member.sameAccount !== undefined && typeof member.sameAccount !== 'boolean')) invalid();
+ member.sameAccount ??= false;
+ }
+ }
+ if (record.directOwnerDeviceId !== undefined
+ && (!nonempty(record.directOwnerDeviceId) || record.directOwnerDeviceId.length > 128)) invalid();
+ if (record.directOwnerScopeKey !== undefined
+ && (!nonempty(record.directOwnerScopeKey) || record.directOwnerScopeKey.length > 512)) invalid();
+ if (record.cleanupEpoch !== undefined
+ && (!Number.isSafeInteger(record.cleanupEpoch) || (record.cleanupEpoch as number) < 0)) invalid();
+ if (record.lastDirectForgetId !== undefined && !uuid(record.lastDirectForgetId)) invalid();
+ if (record.directOwnerDeviceId !== undefined || record.directOwnerScopeKey !== undefined
+ || record.cleanupEpoch !== undefined || record.lastDirectForgetId !== undefined) {
+ if (record.relay !== undefined || parseProviderSharePeer(record.controller as string)?.role !== 'guest') invalid();
+ }
+ // Validate the entire file before publishing anything. Optional fields in
+ // older indexes stay optional; never trim ownership or cleanup evidence.
+ map.set(digest, { ...record, hostSessionIds: list(record.hostSessionIds),
+ nativeIds: list(record.nativeIds) } as unknown as GuestSessionRecord);
}
- return Object.keys(out).length ? out : undefined;
+ return map;
}
function loadGuestIndex(): Promise<Map<string, GuestSessionRecord>> {
- guestIndex ??= fsp.readFile(guestIndexFile, 'utf8')
- .then((raw) => {
- const parsed = JSON.parse(raw) as Record<string, Partial<GuestSessionRecord>>;
- const map = new Map<string, GuestSessionRecord>();
- for (const [digest, record] of Object.entries(parsed)) {
- const list = (value: unknown) => (Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : []);
- if (typeof record?.controller !== 'string') continue;
- const forkWorkspaces = Object.fromEntries(Object.entries(record.forkWorkspaces ?? {})
- .map(([nativeId, ids]) => [nativeId, list(ids).filter((id) => /^[0-9a-f-]{36}$/.test(id))]));
- const members = readRelayMembers(record.members);
- const relayDevices = list(record.relayDevices);
- const forgetPending = list(record.forgetPending);
- map.set(digest, {
- controller: record.controller,
- ...(typeof record.relay === 'string' ? { relay: record.relay } : {}),
- hostSessionIds: list(record?.hostSessionIds),
- nativeIds: list(record?.nativeIds),
- ...(Object.keys(forkWorkspaces).length ? { forkWorkspaces } : {}),
- ...(members ? { members } : {}),
- ...(relayDevices.length ? { relayDevices } : {}),
- ...(forgetPending.length ? { forgetPending } : {}),
- });
- }
- return map;
- })
- .catch(() => new Map<string, GuestSessionRecord>());
+ guestIndex ??= fsp.readFile(guestIndexFile, 'utf8').then(parseGuestIndex, (error: NodeJS.ErrnoException) => {
+ if (error.code === 'ENOENT') return new Map<string, GuestSessionRecord>();
+ throw error;
+ }).catch((error) => {
+ // A transient read/parse failure must not become a cached empty index.
+ // The next request can retry after the original file is readable again.
+ guestIndex = null;
+ throw error;
+ });
return guestIndex;
}
- function persistGuestIndex(map: Map<string, GuestSessionRecord>): Promise<void> {
- guestIndexWrite = guestIndexWrite.then(async () => {
+ function applyGuestIndexUpdates(map: Map<string, GuestSessionRecord>,
+ updates: ReadonlyMap<string, GuestSessionRecord | undefined>): void {
+ for (const [digest, record] of updates) {
+ if (record) map.set(digest, record);
+ else map.delete(digest);
+ }
+ }
+
+ function persistGuestIndex(map: Map<string, GuestSessionRecord>, strict = false,
+ updates?: ReadonlyMap<string, GuestSessionRecord | undefined>
+ | ((current: Map<string, GuestSessionRecord>) => ReadonlyMap<string, GuestSessionRecord | undefined>)): Promise<void> {
+ const commit = guestIndexWrite.then(async () => {
+ const pending = typeof updates === 'function' ? updates(map) : updates;
+ if (pending?.size === 0) return;
await fsp.mkdir(deps.runsRoot, { recursive: true });
const tmp = `${guestIndexFile}.${randomUUID()}.tmp`;
- await fsp.writeFile(tmp, JSON.stringify(Object.fromEntries(map)));
- await fsp.rename(tmp, guestIndexFile);
- }).catch((error) => {
+ // Merge into the latest shared index when this write reaches the queue.
+ // A direct tombstone is not visible to idempotent ACKs until rename wins;
+ // unrelated guests can keep updating their own entries in the meantime.
+ const next = pending ? new Map(map) : map;
+ if (pending) applyGuestIndexUpdates(next, pending);
+ try {
+ await fsp.writeFile(tmp, JSON.stringify(Object.fromEntries(next)));
+ await fsp.rename(tmp, guestIndexFile);
+ if (pending) applyGuestIndexUpdates(map, pending);
+ } finally {
+ await fsp.rm(tmp, { force: true }).catch(() => undefined);
+ }
+ });
+ guestIndexWrite = commit.catch((error) => {
deps.log?.warn('remote agent guest session index write failed', { error: String(error) });
});
- return guestIndexWrite;
+ return strict ? commit : guestIndexWrite;
+ }
+
+ /** Store O's identity only after M has validated its server-backed delegation. */
+ async function recordDirectGuestOwner(ownerDeviceId: string,
+ guest: { shareId: string; memberId: string; guestDeviceId: string; cleanupEpoch?: number }): Promise<void> {
+ const peer = providerShareGuestPeer(guest.shareId, guest.memberId, guest.guestDeviceId);
+ const map = await loadGuestIndex();
+ const digest = guestDigest(peer);
+ await persistGuestIndex(map, true, (current) => {
+ const existing = current.get(digest);
+ const ownerScopeKey = deps.directGuestExecution?.ownerScope();
+ if (!ownerScopeKey) fail('REMOTE_AGENT_INVALID', 'direct guest account is unavailable');
+ if (existing?.relay || (existing?.directOwnerDeviceId && existing.directOwnerDeviceId !== ownerDeviceId)
+ || (existing?.directOwnerScopeKey && existing.directOwnerScopeKey !== ownerScopeKey)) {
+ fail('REMOTE_AGENT_INVALID', 'direct guest ownership does not match this computer');
+ }
+ return new Map([[digest, {
+ ...(existing ?? { controller: peer, hostSessionIds: [], nativeIds: [] }),
+ directOwnerDeviceId: ownerDeviceId,
+ directOwnerScopeKey: ownerScopeKey,
+ cleanupEpoch: Math.max(existing?.cleanupEpoch ?? 0, guest.cleanupEpoch ?? 0),
+ }]]);
+ });
}
async function recordGuestSession(
@@ -745,35 +897,52 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
nativeIds: ReadonlyArray<string | undefined>,
member?: GroupRelayMember,
forkWorkspaceIds?: readonly string[],
+ attachmentRunId?: string,
): Promise<void> {
const map = await loadGuestIndex();
const digest = guestDigest(guestScopeOf(controller, relay));
- const record = map.get(digest) ?? { controller, ...(relay ? { relay } : {}), hostSessionIds: [], nativeIds: [] };
- let changed = !map.has(digest) || reviveForgottenRecord(record);
- if (!record.hostSessionIds.includes(hostSessionId)) {
- record.hostSessionIds.push(hostSessionId);
- changed = true;
- }
- for (const id of nativeIds) {
- if (id && !record.nativeIds.includes(id)) {
- record.nativeIds.push(id);
+ const update = (current: Map<string, GuestSessionRecord>) => {
+ const existing = current.get(digest);
+ const record = existing ? { ...existing, hostSessionIds: [...existing.hostSessionIds],
+ nativeIds: [...existing.nativeIds] }
+ : { controller, ...(relay ? { relay } : {}), hostSessionIds: [], nativeIds: [] };
+ let changed = !current.has(digest) || reviveForgottenRecord(record);
+ if (!record.hostSessionIds.includes(hostSessionId)) {
+ record.hostSessionIds.push(hostSessionId);
changed = true;
}
- if (id && forkWorkspaceIds?.length) {
- const ancestors = [...new Set([...(record.forkWorkspaces?.[id] ?? []), ...forkWorkspaceIds])];
- if (ancestors.length !== record.forkWorkspaces?.[id]?.length) {
- record.forkWorkspaces = { ...record.forkWorkspaces, [id]: ancestors };
+ if (attachmentRunId && !record.attachmentRunIds?.includes(attachmentRunId)) {
+ record.attachmentRunIds = [...(record.attachmentRunIds ?? []), attachmentRunId];
+ changed = true;
+ }
+ for (const id of nativeIds) {
+ if (id && !record.nativeIds.includes(id)) {
+ record.nativeIds.push(id);
+ changed = true;
+ }
+ if (id && forkWorkspaceIds?.length) {
+ const ancestors = [...new Set([...(record.forkWorkspaces?.[id] ?? []), ...forkWorkspaceIds])];
+ if (ancestors.length !== record.forkWorkspaces?.[id]?.length) {
+ record.forkWorkspaces = { ...record.forkWorkspaces, [id]: ancestors };
+ changed = true;
+ }
+ }
+ if (id && member && record.members?.[id]?.memberKey !== member.memberKey) {
+ record.members = { ...record.members, [id]: { ...member } };
changed = true;
}
}
- if (id && member && record.members?.[id]?.memberKey !== member.memberKey) {
- record.members = { ...record.members, [id]: { ...member } };
- changed = true;
- }
+ return changed ? new Map([[digest, record]]) : new Map<string, GuestSessionRecord>();
+ };
+ if (!relay && map.get(digest)?.directOwnerDeviceId) {
+ await persistGuestIndex(map, true, update);
+ } else {
+ // Legacy relay state events publish synchronously for the next resume.
+ const pending = update(map);
+ if (!pending.size) return;
+ applyGuestIndexUpdates(map, pending);
+ await persistGuestIndex(map);
}
- if (!changed) return;
- map.set(digest, record);
- await persistGuestIndex(map);
}
async function forkWorkspacesFor(scope: string, nativeId: string | undefined): Promise<string[]> {
@@ -878,7 +1047,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
if (t - run.closedAt > retainMs) void disposeRun(run);
continue;
}
- if (!deps.isControllerAuthorized(run.controller)) {
+ if (!deps.isControllerAuthorized(run.controller) || !delegatedRunAllowed(run)) {
void finishRun(run, 'access-revoked', 'navigation');
} else if (!deps.isOwnerCurrent(run.owner)) {
void finishRun(run, 'account-changed', 'account-boundary');
@@ -997,7 +1166,9 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
void recordGuestSession(run.controller, run.relayKey, run.hostSessionId, [
typeof state.id === 'string' ? state.id : undefined,
typeof state.requestSessionId === 'string' ? state.requestSessionId : undefined,
- ], undefined, run.forkWorkspaceIds);
+ ], undefined, run.forkWorkspaceIds).catch((error) => {
+ deps.log?.warn('remote agent guest session index update failed', { error: String(error) });
+ });
}
}
@@ -1244,7 +1415,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
if (run.trust === 'guest') {
// 先登记再启动:启动中途失败时,受邀者目录与会话记录也能在分享删除时被找到并清理。
await timing.measure('guest-registration', () =>
- recordGuestSession(run.controller, run.relayKey, hostSessionId, []),
+ recordGuestSession(run.controller, run.relayKey, hostSessionId, [], undefined, undefined, run.id),
);
guestHome = guestHomeFor(guestScopeOf(run.controller, run.relayKey));
await fsp.mkdir(guestHome, { recursive: true, mode: 0o700 });
@@ -1353,6 +1524,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
hostSessionId,
providerId: run.providerId!,
controller: run.controller,
+ sessionId: payload.sessionId,
isCurrent: () => !run.closing && deps.isOwnerCurrent(run.owner),
...(relayModelAccess ? { relayModelAccess } : {}),
}),
@@ -1370,7 +1542,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
} else if (run.providerId) {
run.ownerRoute = deps.bindOwnerProviderRoute?.(hostSessionId, run.providerId, deps.providerAccess
? (providerId, model) => !run.closing && deps.isControllerAuthorized(run.controller)
- && deps.providerAccess!.isAllowed(providerId, run.controller, model)
+ && deps.providerAccess!.isAllowed(providerId, run.controller, model, run.sessionId)
: undefined);
}
const handle = await timing.measure('agent-session', () =>
@@ -1583,7 +1755,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
if (samples.length === 0) return;
// 转给组内电脑的记在那台名下;在本机运行的(含组里选回本机)记为本机。
const memberKey = run.relay?.member.memberKey ?? PROVIDER_GROUP_LOCAL_MEMBER_KEY;
- record(run.controller, { kind: run.kind, providerId: run.providerId ?? null, memberKey, samples });
+ record(run.controller, { kind: run.kind, providerId: run.providerId ?? null, memberKey, samples }, run.sessionId);
} catch (error) {
deps.log?.warn('remote agent usage record failed', { runId: run.id, error: String(error) });
}
@@ -1725,28 +1897,33 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
}
/** 发一张「需要换一台」凭证:只认发给的这个受邀者的这个任务,过期作废。 */
- function issueGroupSwitchToken(run: Run, exclude: ReadonlySet<string>): string {
+ function issueGroupSwitchTokenFor(controller: string, hostSessionId: string, exclude: ReadonlySet<string>): string {
const at = now();
for (const [token, entry] of groupSwitchTokens) {
if (entry.expiresAt <= at) groupSwitchTokens.delete(token);
}
const token = newGroupSwitchToken();
groupSwitchTokens.set(token, {
- controller: run.controller,
- hostSessionId: run.hostSessionId!,
+ controller,
+ hostSessionId,
exclude: [...exclude],
expiresAt: at + GROUP_SWITCH_TOKEN_TTL_MS,
});
return token;
}
- /** 受邀者交接后重新打开时带回的凭证:有效则用掉,返回要避开的那几台;无效(别人的、过期、用过)返回空。 */
+ function issueGroupSwitchToken(run: Run, exclude: ReadonlySet<string>): string {
+ return issueGroupSwitchTokenFor(run.controller, run.hostSessionId!, exclude);
+ }
+
+ /** 受邀者交接后重新打开时带回的凭证:短期内幂等,失败重开仍避开原电脑。只认同一受邀者和任务。 */
function takeGroupSwitchToken(controller: string, hostSessionId: string, token: string | undefined): string[] {
if (!token) return [];
const entry = groupSwitchTokens.get(token);
if (!entry || entry.controller !== controller || entry.hostSessionId !== hostSessionId) return [];
+ if (entry.expiresAt > now()) return entry.exclude;
groupSwitchTokens.delete(token);
- return entry.expiresAt > now() ? entry.exclude : [];
+ return [];
}
/**
@@ -1897,7 +2074,9 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
void recordGuestSession(run.controller, undefined, run.hostSessionId, [
typeof state.id === 'string' ? state.id : undefined,
typeof state.requestSessionId === 'string' ? state.requestSessionId : undefined,
- ], current);
+ ], current).catch((error) => {
+ deps.log?.warn('remote agent guest session index update failed', { error: String(error) });
+ });
}
// 组内电脑不能替本机发凭证。
const { [GROUP_SWITCH_STATE_KEY]: _forged, ...forwarded } = state;
@@ -1912,14 +2091,14 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const providerId = run.providerId;
if (!current() || !providerId || !deps.providerAccess) return { type: 'callback', value: false };
if (request.model) {
- try { return { type: 'callback', value: deps.providerAccess.isAllowed(providerId, run.controller, request.model) }; }
+ try { return { type: 'callback', value: deps.providerAccess.isAllowed(providerId, run.controller, request.model, run.sessionId) }; }
catch (error) {
if (error instanceof Error && error.message.includes('[REMOTE_AGENT_MEMBER_BUDGET_PAUSED]'))
return { type: 'callback', value: { allowed: false, code: 'REMOTE_AGENT_MEMBER_BUDGET_PAUSED' } };
throw error;
}
}
- const models = await deps.providerAccess.models?.(run.kind, providerId, run.controller);
+ const models = await deps.providerAccess.models?.(run.kind, providerId, run.controller, run.sessionId);
// This is the frozen runtime catalog. Temporary usage pauses are evaluated
// by the individual model checks, so recovery does not require a restart.
return { type: 'callback', value: current() && models ? models : [] };
@@ -1949,7 +2128,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
backend.modelAccess = caps.relayModelAccess === true && !!deps.providerAccess?.models;
if (caps.virtualWorkspace !== true
|| (payload.options.localApplication !== undefined && caps.localApplication !== true)
- || (!backend.modelAccess && deps.providerAccess?.restricted?.(groupProviderId, run.controller))
+ || (!backend.modelAccess && deps.providerAccess?.restricted?.(groupProviderId, run.controller, run.sessionId))
|| (current.sameAccount ? caps.guestRelay !== true : caps.reshareConsent !== true)) {
throw new Error('[REMOTE_AGENT_PEER_TOO_OLD] the computer in the provider group cannot take shared tasks yet');
}
@@ -2057,14 +2236,14 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
if (method === 'setWritableDirs') callArgs = [confineGuestDirs(args[0], run.virtualRoot)];
const access = deps.providerAccess;
if (access && (method === 'send' || method === 'steer') && run.providerId
- && !access.isAllowed(run.providerId, run.controller, run.authorizedModel)) {
+ && !access.isAllowed(run.providerId, run.controller, run.authorizedModel, run.sessionId)) {
failProviderNotAllowed();
}
if (method === 'setModel') {
// 来源钉在分享的供应商上(本机按分享的那个供应商核对模型),转给那台时换成那台上的这个供应商。
const opts = args[1] && typeof args[1] === 'object' && !Array.isArray(args[1]) ? args[1] as Record<string, unknown> : {};
if (access) {
- const resolved = await access.resolve(run.kind, typeof args[0] === 'string' ? args[0] : '', run.providerId ?? null, run.controller);
+ const resolved = await access.resolve(run.kind, typeof args[0] === 'string' ? args[0] : '', run.providerId ?? null, run.controller, run.sessionId);
if (!resolved) failProviderNotAllowed();
}
callArgs = [args[0], { ...opts, providerId: relay.member.providerId }, ...args.slice(2)];
@@ -2143,7 +2322,17 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
deps.log?.info('remote agent run finished', { runId: run.id, reason, ...(run.idleReclaimed ? { idleReclaimed: true } : {}) });
}
- async function disposeRun(run: Run): Promise<void> {
+ function disposeRun(run: Run): Promise<void> {
+ // open ACKs before native startup, which may need poll/reply. Stop first
+ // (finishRun rejects reverse requests), then drain startup's last writes.
+ // Startup never acquires the guest lock. Keep it in runs until it drains,
+ // and coalesce sweep/dispose calls instead of accumulating pending waits.
+ const startup = directRunStarts.get(run);
+ if (startup) return startup.disposal ??= startup.work.then(() => disposeRunFiles(run));
+ return disposeRunFiles(run);
+ }
+
+ async function disposeRunFiles(run: Run): Promise<void> {
runs.delete(key(run.controller, run.id));
await fsp.rm(run.attachmentsDir, { recursive: true, force: true }).catch(() => undefined);
// 影子工作区(项目说明类文件的副本)在任务收尾后一并清理,不长期留在本机;同一任务的
@@ -2173,9 +2362,16 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
function requireRun(controller: string, runId: string): Run {
const run = runs.get(key(controller, runId));
if (!run) fail('REMOTE_AGENT_NOT_FOUND', 'task is not running on this computer');
+ if (!delegatedRunAllowed(run)) fail('REMOTE_AGENT_UNAVAILABLE', 'this shared task is no longer authorized');
return run;
}
+ function delegatedRunAllowed(run: Run): boolean {
+ return run.trust !== 'guest' || (deps.isControllerAuthorized(run.controller)
+ && (!!run.relayKey || !deps.directGuestExecution
+ || (run.sessionId !== undefined && deps.directGuestExecution.sessionAllowed(run.controller, run.sessionId))));
+ }
+
async function call(run: Run, callId: string, method: RemoteAgentMethod, payload: RemoteAgentPayload): Promise<void> {
if (method !== 'setModel') return callOnHandle(run, callId, method, payload);
const change = (run.modelChange ?? Promise.resolve()).then(() => callOnHandle(run, callId, method, payload));
@@ -2189,6 +2385,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
let rollbackProvider: (() => void) | undefined;
try {
if (run.closing) fail('REMOTE_AGENT_EXPIRED', 'task has ended');
+ if (!delegatedRunAllowed(run)) fail('REMOTE_AGENT_UNAVAILABLE', 'this shared task is no longer authorized');
if (!handle) fail('REMOTE_AGENT_UNAVAILABLE', 'agent has not started');
const raw = await resolvePayload(run.controller, payload);
const args = takeGroupNewRound(run, callId, method, Array.isArray(raw) ? raw : []);
@@ -2217,7 +2414,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
let nextProviderId: string | undefined;
const access = deps.providerAccess;
if (access && (method === 'send' || method === 'steer') && run.providerId
- && !access.isAllowed(run.providerId, run.controller, run.authorizedModel)) {
+ && !access.isAllowed(run.providerId, run.controller, run.authorizedModel, run.sessionId)) {
failProviderNotAllowed();
}
if (access && method === 'setModel') {
@@ -2230,6 +2427,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
typeof args[0] === 'string' ? args[0] : '',
typeof requested === 'string' ? requested : null,
run.controller,
+ run.sessionId,
);
if (!resolved) failProviderNotAllowed();
if (explicitProvider || run.trust === 'guest') {
@@ -2251,6 +2449,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
callArgs = [message, opts];
}
if (run.closing) fail('REMOTE_AGENT_EXPIRED', 'task has ended');
+ if (!delegatedRunAllowed(run)) fail('REMOTE_AGENT_UNAVAILABLE', 'this shared task is no longer authorized');
if (nextProviderId && run.ownerRoute && run.providerId) {
const binding = run.ownerRoute;
const previousProviderId = run.providerId;
@@ -2302,7 +2501,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const t = now();
for (const { runId, hold } of wanted) {
const run = runs.get(key(controller, runId));
- if (!run) continue;
+ if (!run || !delegatedRunAllowed(run)) continue;
run.lastReadAt = t;
// Only apply the snapshot when this request arrives; an older long poll returning later must
// not clear a newer hold received with a process startup reply.
@@ -2314,7 +2513,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
};
const live = () => wanted.flatMap(({ runId, cursor }) => {
const run = runs.get(key(controller, runId));
- return run && run.log.isValidCursor(cursor) ? [{ run, cursor }] : [];
+ return run && delegatedRunAllowed(run) && run.log.isValidCursor(cursor) ? [{ run, cursor }] : [];
});
touch(true);
const initial = live();
@@ -2328,7 +2527,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const { runId, cursor } = wanted[(start + index) % wanted.length];
const run = runs.get(key(controller, runId));
// 不存在或游标超出已写范围(对端状态与本机不一致):控制端按任务丢失处理。
- if (!run || !run.log.isValidCursor(cursor)) {
+ if (!run || !delegatedRunAllowed(run) || !run.log.isValidCursor(cursor)) {
out.runs.push({ runId, cursor, missing: true });
continue;
}
@@ -2356,6 +2555,8 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
runMatch: (run: Run) => boolean,
recordMatch: (record: GuestSessionRecord) => boolean,
wholeController: boolean,
+ directForgetId?: string,
+ directCleanupEpoch?: number,
): Promise<void> {
const owned = [...runs.values()].filter(runMatch);
await Promise.all(owned.map((run) => finishRun(run, 'access-revoked', 'navigation')));
@@ -2369,14 +2570,48 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
const controllers = wholeController
? new Set([...owned.map((run) => run.controller), ...records.map(([, record]) => record.controller)])
: new Set<string>();
+ const directControllers = directForgetId
+ ? new Set([...owned.map((run) => run.controller), ...records.map(([, record]) => record.controller)])
+ : new Set<string>();
+ const directPaths: string[] = [];
+ for (const controller of directControllers) {
+ const otherRelay = [...map.values()].some((record) => record.controller === controller && !!record.relay)
+ || [...runs.values()].some((run) => run.controller === controller && !!run.relayKey);
+ const prefix = controllerDir(controller);
+ if (!otherRelay) {
+ // No relay shares this peer's parent directories: also remove older
+ // orphan children whose run ID predated durable attachment indexing.
+ directPaths.push(path.join(deps.runsRoot, 'workspaces', prefix),
+ path.join(deps.runsRoot, 'attachments', prefix));
+ continue;
+ }
+ // A same-peer relay shares the parent directories. Delete only the
+ // direct subdirs recorded before M wrote any guest content.
+ const workspaceIds = new Set([
+ ...owned.map((run) => run.hostSessionId).filter((id): id is string => !!id),
+ ...records.flatMap(([, record]) => [...record.hostSessionIds,
+ ...Object.values(record.forkWorkspaces ?? {}).flat()]),
+ ]);
+ const attachmentIds = new Set([
+ ...owned.map((run) => run.id),
+ ...records.flatMap(([, record]) => record.attachmentRunIds ?? []),
+ ]);
+ if ([...workspaceIds, ...attachmentIds].some((id) => !/^[0-9a-f-]{36}$/.test(id))) {
+ fail('REMOTE_AGENT_INVALID', 'direct guest cleanup contains an invalid local directory id');
+ }
+ directPaths.push(...[...workspaceIds].map((id) => path.join(deps.runsRoot, 'workspaces', prefix, id)),
+ ...[...attachmentIds].map((id) => path.join(deps.runsRoot, 'attachments', prefix, id)));
+ }
// 受邀者目录里是它的 Codex / Pi 会话历史;Windows 上刚退出的 Agent 可能还占着文件,重试几次。
const targets = [
...[...controllers].flatMap((controller) => ['workspaces', 'attachments'].map((dir) => path.join(deps.runsRoot, dir, controllerDir(controller)))),
+ ...directPaths,
...[...scopes].map((scope) => guestHomeFor(scope)),
];
- await Promise.all(targets.map((target) => (
- fsp.rm(target, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }).catch(() => undefined)
- )));
+ await Promise.all(targets.map((target) => {
+ const removal = fsp.rm(target, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+ return directForgetId ? removal : removal.catch(() => undefined);
+ }));
if (!records.length) return;
// 接过这些受邀者任务的组内电脑(含启动失败、还没有原生会话 id 的):先记成待通知再逐台通知,通知到才划掉,
// 当时离线的之后再试——不能因为一次没通知到就丢了「要通知哪台」。
@@ -2391,6 +2626,9 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
record.forgetPending = [...devices];
forgets = true;
}
+ if (directForgetId && !deps.purgeHostedTranscripts) {
+ fail('REMOTE_AGENT_INVALID', 'direct guest transcript cleanup is unavailable');
+ }
try {
await deps.purgeHostedTranscripts?.(
records.flatMap(([, record]) => record.hostSessionIds),
@@ -2399,27 +2637,38 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
} catch (error) {
// 留着登记,下次清理重试。
deps.log?.warn('remote agent transcript purge failed', { error: String(error) });
+ if (directForgetId) throw error;
if (forgets) {
await persistGuestIndex(map);
void retryPendingForgets();
}
return;
}
+ const updates = new Map<string, GuestSessionRecord | undefined>();
for (const [digest, record] of records) {
// 本机这边清完了,只留下还没通知到的组内电脑。
if (record.forgetPending?.length) {
- map.set(digest, {
+ updates.set(digest, {
controller: record.controller,
...(record.relay ? { relay: record.relay } : {}),
hostSessionIds: [],
nativeIds: [],
forgetPending: record.forgetPending,
});
+ } else if (directForgetId && record.directOwnerDeviceId && !record.relay) {
+ updates.set(digest, { controller: record.controller, hostSessionIds: [], nativeIds: [],
+ directOwnerDeviceId: record.directOwnerDeviceId,
+ ...(record.directOwnerScopeKey ? { directOwnerScopeKey: record.directOwnerScopeKey } : {}),
+ cleanupEpoch: Math.max(map.get(digest)?.cleanupEpoch ?? 0, record.cleanupEpoch ?? 0, directCleanupEpoch ?? 0),
+ lastDirectForgetId: directForgetId });
} else {
- map.delete(digest);
+ updates.set(digest, undefined);
}
}
- await persistGuestIndex(map);
+ // Legacy relay cleanup retains its existing best-effort publication. Direct
+ // cleanup keeps the old retryable record until the tombstone is on disk.
+ if (!directForgetId) applyGuestIndexUpdates(map, updates);
+ await persistGuestIndex(map, directForgetId !== undefined, directForgetId ? updates : undefined);
if (forgets) void retryPendingForgets();
}
@@ -2505,6 +2754,11 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
async function handle(controller: string, raw: unknown, signal?: AbortSignal): Promise<unknown> {
const request = parseRemoteAgentRequest(raw);
+ return handleRequest(controller, request, signal);
+ }
+
+ async function handleRequest(controller: string, request: RemoteAgentRequest,
+ signal?: AbortSignal, directLocked = false): Promise<unknown> {
if (!deps.isControllerAuthorized(controller)) fail('REMOTE_AGENT_UNAVAILABLE', 'remote control is not allowed');
switch (request.op) {
case 'native-history': {
@@ -2525,18 +2779,85 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
assertCurrent();
return result;
}
+ case 'direct-locate':
+ if (trustOf(controller) !== 'guest' || !deps.directGuestExecution?.locate) fail('REMOTE_AGENT_INVALID', 'location is only for shared users');
+ return deps.directGuestExecution.locate(controller, request);
+ case 'allocate': {
+ if (trustOf(controller) !== 'guest' || !deps.directGuestExecution) fail('REMOTE_AGENT_INVALID', 'allocation is only for shared users');
+ if (!directLocked) return withDirectGuestLock(controller, () => handleRequest(controller, request, signal, true));
+ // An existing O-hosted task stays on its legacy route, even when an old
+ // controller asks to allocate it again without a native resume ID.
+ if (deps.directGuestExecution.locate
+ && !await deps.directGuestExecution.locate(controller, { op: 'direct-locate', sessionId: request.sessionId })) {
+ const record = (await loadGuestIndex()).get(guestDigest(controller));
+ if (record?.hostSessionIds.includes(hostSessionIdFor(controller, request.sessionId))
+ || [...runs.values()].some((run) => run.controller === controller && !run.relayKey
+ && run.sessionId === request.sessionId)) return null;
+ }
+ return deps.directGuestExecution.allocate(controller, request);
+ }
+ case 'direct-status':
+ if (trustOf(controller) !== 'guest' || !deps.directGuestExecution) fail('REMOTE_AGENT_INVALID', 'status is only for shared users');
+ deps.directGuestExecution.status(controller, request);
+ return {};
+ case 'direct-release':
+ if (trustOf(controller) !== 'guest' || !deps.directGuestExecution) fail('REMOTE_AGENT_INVALID', 'release is only for shared users');
+ await deps.directGuestExecution.release(controller, request);
+ return {};
+ case 'direct-switch':
+ if (trustOf(controller) !== 'guest' || !deps.directGuestExecution) fail('REMOTE_AGENT_INVALID', 'switch is only for shared users');
+ return deps.directGuestExecution.switch(controller, request);
+ case 'direct-usage':
+ if (trustOf(controller) !== 'owner' || !deps.directGuestExecution) fail('REMOTE_AGENT_INVALID', 'usage requires the owner account');
+ await deps.directGuestExecution.usage(controller, request);
+ return {};
+ case 'delegate': {
+ if (trustOf(controller) !== 'owner' || !deps.directGuestExecution) fail('REMOTE_AGENT_INVALID', 'delegation requires the owner account');
+ if (!directLocked) return withDirectGuestLock(
+ providerShareGuestPeer(request.shareId, request.memberId, request.guestDeviceId),
+ () => handleRequest(controller, request, signal, true));
+ const revoked = await deps.directGuestExecution.delegate(controller, request);
+ if (request.action === 'grant') {
+ try {
+ await recordDirectGuestOwner(controller, request);
+ } catch (error) {
+ await deps.directGuestExecution.delegate(controller, { ...request, action: 'revoke' }).catch(() => undefined);
+ throw error;
+ }
+ }
+ if (request.action === 'revoke' && revoked) {
+ await Promise.all([...runs.values()].filter((run) => {
+ const peer = parseProviderSharePeer(run.controller);
+ return peer?.role === 'guest' && peer.shareId === request.shareId
+ && peer.memberId === request.memberId && peer.deviceId === request.guestDeviceId
+ && run.sessionId === request.sessionId;
+ }).map((run) => finishRun(run, 'access-revoked', 'navigation')));
+ }
+ return {};
+ }
case 'fast-policy':
if (!deps.fastPolicy) fail('REMOTE_AGENT_UNSUPPORTED', 'subscription Fast policy is not supported');
return deps.fastPolicy!(controller, request);
case 'fork': {
const owner = deps.captureOwner();
const controllerTrust = trustOf(controller);
+ if (!directLocked && controllerTrust === 'guest' && !request.relay && deps.directGuestExecution) {
+ return withDirectGuestLock(controller, () => handleRequest(controller, request, signal, true));
+ }
const guest = controllerTrust === 'guest' || !!request.relay;
+ if (controllerTrust === 'guest' && !request.relay
+ && deps.directGuestExecution && !deps.directGuestExecution.sessionAllowed(controller, request.sourceSessionId)) {
+ fail('REMOTE_AGENT_INVALID', 'this shared task is not authorized on this computer');
+ }
const scope = guestScopeOf(controller, request.relay);
const assertAccess = () => {
if (!deps.isOwnerCurrent(owner) || !deps.isControllerAuthorized(controller)) {
fail('REMOTE_AGENT_UNAVAILABLE', 'remote control is not allowed');
}
+ if (controllerTrust === 'guest' && !request.relay && deps.directGuestExecution
+ && !deps.directGuestExecution.sessionAllowed(controller, request.sourceSessionId)) {
+ fail('REMOTE_AGENT_UNAVAILABLE', 'this shared task is no longer authorized');
+ }
if (controllerTrust === 'guest' && request.relay && deps.reshare
&& !deps.reshare.allows(controller, request.reshareKey)) failProviderNotAllowed();
};
@@ -2548,12 +2869,12 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
fail('REMOTE_AGENT_INVALID', 'this conversation cannot be forked on this computer');
}
const providerId = await deps.providerAccess?.resolve(
- request.agentKind, request.model, request.providerId, controller,
+ request.agentKind, request.model, request.providerId, controller, request.sourceSessionId,
);
if (deps.providerAccess && !providerId) failProviderNotAllowed();
const assertProvider = () => {
assertAccess();
- if (providerId && !deps.providerAccess?.isAllowed(providerId, controller, request.model)) failProviderNotAllowed();
+ if (providerId && !deps.providerAccess?.isAllowed(providerId, controller, request.model, request.sourceSessionId)) failProviderNotAllowed();
};
assertProvider();
const member = guest && !request.relay ? await relayMemberOf(controller, request.sourceSdkSessionId) : null;
@@ -2640,10 +2961,18 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
return result;
}
case 'images': {
+ if (trustOf(controller) === 'guest' && !request.relay && deps.directGuestExecution
+ && !deps.directGuestExecution.sessionAllowed(controller, request.sessionId)) {
+ fail('REMOTE_AGENT_INVALID', 'this shared task is not authorized on this computer');
+ }
if (!deps.imageArtifacts) fail('REMOTE_AGENT_INVALID', 'image recovery is unavailable');
const owner = deps.captureOwner();
const result = await deps.imageArtifacts!(hostSessionIdFor(guestScopeOf(controller, request.relay), request.sessionId), request);
- if (!deps.isOwnerCurrent(owner) || !deps.isControllerAuthorized(controller)) fail('REMOTE_AGENT_UNAVAILABLE', 'remote control is not allowed');
+ if (!deps.isOwnerCurrent(owner) || !deps.isControllerAuthorized(controller)
+ || (trustOf(controller) === 'guest' && !request.relay && deps.directGuestExecution
+ && !deps.directGuestExecution.sessionAllowed(controller, request.sessionId))) {
+ fail('REMOTE_AGENT_UNAVAILABLE', 'remote control is not allowed');
+ }
return result;
}
case 'caps': {
@@ -2667,20 +2996,63 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
...(deps.imageArtifacts ? { imageRecovery: true, imageRecoveryRelay: true } : {}),
// 能按受邀者隔离运行(供应商级授权与出站边界都已接上),才接受组所在电脑中转过来的受邀者任务。
...(deps.providerAccess && deps.bindGuestProviderRoute ? { guestRelay: true } : {}),
+ ...(deps.directGuestExecution && deps.providerAccess && deps.bindGuestProviderRoute
+ ? { directGuestExecution: true } : {}),
...(deps.providerAccess && deps.bindGuestProviderRoute ? { relayModelAccess: true } : {}),
// 转分享的同意只对受邀者(把这里分享的供应商放进自己组的人)有意义。
- ...(guest && deps.reshare ? { reshareConsent: true } : {}),
- ...(guest && deps.reshare ? { reshareBatch: true } : {}),
+ ...(guest && deps.reshare && (deps.reshare.canUse?.(controller) ?? true) ? { reshareConsent: true } : {}),
+ ...(guest && deps.reshare && (deps.reshare.canUse?.(controller) ?? true) ? { reshareBatch: true } : {}),
};
return caps;
}
case 'forget':
- // 组所在电脑删掉了某个受邀者:清掉替它运行过的任务。只作用于调用方自己的 relay。
- await forgetRelay(controller, request.relay);
+ if ('directGuest' in request) {
+ // The short-lived lease is gone after deletion. This durable record
+ // binds the guest to the authenticated O that originally delegated it.
+ if (trustOf(controller) !== 'owner') fail('REMOTE_AGENT_INVALID', 'direct guest cleanup requires the owner computer');
+ if (!deps.directGuestExecution?.forget) fail('REMOTE_AGENT_INVALID', 'direct guest cleanup is unavailable');
+ const peer = providerShareGuestPeer(request.directGuest.shareId, request.directGuest.memberId,
+ request.directGuest.guestDeviceId);
+ if (!directLocked) return withDirectGuestLock(peer,
+ () => handleRequest(controller, request, signal, true), { controller, ...request.directGuest });
+ const record = (await loadGuestIndex()).get(guestDigest(peer));
+ const ownerScopeKey = deps.directGuestExecution.ownerScope();
+ if (!ownerScopeKey) fail('REMOTE_AGENT_INVALID', 'direct guest account is unavailable');
+ if (!record) {
+ // A provisional O route can be deleted before its grant reaches M.
+ // There is nothing to purge if M has neither a run nor a guest home.
+ if ([...runs.values()].some((run) => run.controller === peer && !run.relayKey)) {
+ fail('REMOTE_AGENT_INVALID', 'direct guest cleanup is missing its run index');
+ }
+ try {
+ await fsp.stat(guestHomeFor(guestScopeOf(peer, undefined)));
+ fail('REMOTE_AGENT_INVALID', 'direct guest cleanup is missing its home index');
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+ }
+ deps.directGuestExecution.forget(controller, peer, request.directGuest.cleanupEpoch);
+ return {};
+ }
+ if (record.controller !== peer || record.relay || record.directOwnerDeviceId !== controller
+ || record.directOwnerScopeKey !== ownerScopeKey) {
+ fail('REMOTE_AGENT_INVALID', 'direct guest cleanup is not owned by this computer');
+ }
+ if ((record.cleanupEpoch ?? 0) > request.directGuest.cleanupEpoch) return {};
+ if (record.lastDirectForgetId === request.directGuest.forgetId) return {};
+ if (!deps.directGuestExecution.forget(controller, peer, request.directGuest.cleanupEpoch, true)) return {};
+ await purgeGuests((run) => run.controller === peer && !run.relayKey,
+ (item) => item.controller === peer && !item.relay && item.directOwnerDeviceId === controller,
+ false, request.directGuest.forgetId, request.directGuest.cleanupEpoch);
+ } else {
+ // Group owner only clears the relay scope it issued for this guest.
+ await forgetRelay(controller, request.relay);
+ }
return {};
case 'reshare':
// 转分享:受邀者的组所在电脑报上它分享的人(整体替换它上一份),主人逐人同意。同账号电脑经组使用不需要同意。
- if (!deps.reshare || trustOf(controller) !== 'guest') fail('REMOTE_AGENT_INVALID', 'reshare is only for shared users');
+ if (!deps.reshare || trustOf(controller) !== 'guest' || deps.reshare.canUse?.(controller) === false) {
+ fail('REMOTE_AGENT_INVALID', 'reshare is only for shared users');
+ }
return deps.reshare.sync(controller, request.entries, request.batch);
case 'upload': {
const uploadKey = key(controller, request.uploadId);
@@ -2718,7 +3090,17 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
let payload = decodeOpenPayload(await resolvePayload(controller, request.payload));
// 供应商组的组所在电脑替受邀者中转过来的任务:不论那台是不是同账号,都按受邀者隔离运行。
const relayKey = payload.relay;
+ if (!directLocked && controllerTrust === 'guest' && !relayKey && deps.directGuestExecution) {
+ // Uploads were consumed above. Re-enter with the decoded payload so
+ // authorization, resume lookup and runs.set all happen under the lock.
+ return withDirectGuestLock(controller, () => handleRequest(controller,
+ { ...request, payload: { json: payload } }, signal, true));
+ }
const trust: RemoteAgentControllerTrust = relayKey ? 'guest' : controllerTrust;
+ if (controllerTrust === 'guest' && !relayKey && deps.directGuestExecution
+ && !deps.directGuestExecution.sessionAllowed(controller, payload.sessionId)) {
+ fail('REMOTE_AGENT_INVALID', 'this shared task is not authorized on this computer');
+ }
if (relayKey && guestUnsupported) {
fail('REMOTE_AGENT_UNSUPPORTED', `${request.agentKind} is not available to shared users on this computer`);
}
@@ -2750,6 +3132,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
payload.options.model,
payload.options.providerId,
controller,
+ payload.sessionId,
);
if (!resolved) failProviderNotAllowed();
providerId = resolved;
@@ -2762,7 +3145,12 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
let avoid: string[] = [];
/** 选电脑的同一步已计入那台(或本机这一台)的负载,交给任务;任务没建起来时放掉。 */
let reserved: GroupRelayLoad | undefined;
- const groupRouted = controllerTrust === 'guest' && !relayKey && !payload.groupAssigned && !!deps.groupRelay && !!providerId;
+ // The guest-supplied groupAssigned hint cannot authorize M to route a
+ // delegated task into M's own group. Ordinary G→O guests have no local
+ // delegation and must retain O's group routing.
+ const groupRouted = controllerTrust === 'guest' && !relayKey && !payload.groupAssigned
+ && !deps.directGuestExecution?.sessionDelegated(controller, payload.sessionId)
+ && !!deps.groupRelay && !!providerId;
if (groupRouted && deps.groupRelay && providerId) {
const resumeId = payload.options.resumeSessionId;
if (resumeId) {
@@ -2775,6 +3163,13 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
hostSessionIdFor(controller, payload.sessionId),
payload.groupSwitchToken,
);
+ if (avoid.length && payload.groupSwitchToken) {
+ // A valid token binds this guest and task to the move. Retire its
+ // old direct assignment before planning a new executor, so a
+ // failed open can retry with the token without reviving old M.
+ await deps.directGuestExecution?.switched?.(controller, payload.sessionId,
+ payload.groupSwitchToken);
+ }
const plan = await deps.groupRelay.plan({
kind: request.agentKind,
model: payload.options.model,
@@ -2795,6 +3190,18 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
reserved?.release();
fail('REMOTE_AGENT_UNSUPPORTED', `${request.agentKind} is not available on this computer`);
}
+ if (controllerTrust === 'guest' && !relayKey
+ && !deps.directGuestExecution?.sessionDelegated(controller, payload.sessionId)) {
+ try {
+ // The accepted O fallback, not a possibly stale release notice,
+ // retires the direct pin. This also covers a lost release ACK.
+ await deps.directGuestExecution?.acceptRelay?.(controller, payload.sessionId,
+ !!payload.options.resumeSessionId);
+ } catch (error) {
+ reserved?.release();
+ throw error;
+ }
+ }
// 上面有等待:同一个 runId 的重发可能已经先登记了。
if (runs.has(key(controller, request.runId))) {
reserved?.release();
@@ -2808,10 +3215,15 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
failProviderNotAllowed();
}
// 供应商查询/组分配有 await;最终检查与登记间不能再等待,防止并发 open 超额。
+ if (controllerTrust === 'guest' && !relayKey && deps.directGuestExecution
+ && !deps.directGuestExecution.sessionAllowed(controller, payload.sessionId)) {
+ reserved?.release();
+ fail('REMOTE_AGENT_UNAVAILABLE', 'this shared task is no longer authorized');
+ }
try {
// Admission may throw a specific pause error after the awaited group reservation.
// Nothing owns the reserved load until runs.set, so release it on either rejection path.
- if (providerId && deps.providerAccess && !deps.providerAccess.isAllowed(providerId, controller, payload.options.model)) {
+ if (providerId && deps.providerAccess && !deps.providerAccess.isAllowed(providerId, controller, payload.options.model, payload.sessionId)) {
failProviderNotAllowed();
}
assertRunCapacity(controller);
@@ -2825,6 +3237,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
// group restriction even when the caller says it was already assigned.
...(trust === 'guest' && deps.groupRelay && providerId ? { groupProviderId: providerId } : {}),
id: request.runId,
+ sessionId: payload.sessionId,
authorizedModel: payload.options.model,
acceptsImageDeliveryReceipts: payload.acceptsImageDeliveryReceipts === true,
controller,
@@ -2867,7 +3280,9 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
} else {
// 组为受邀者的全新任务选中了本机这一台:本机起不来时与组内电脑一样换下一台。
if (groupRouted && !payload.options.resumeSessionId) run.groupFreshStart = { avoid };
- void startRun(run, payload);
+ const starting = startRun(run, payload);
+ if (directLocked) directRunStarts.set(run, { work: starting });
+ void starting;
}
return {};
}
@@ -2972,6 +3387,19 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
return {
handle,
+ /** O alone may issue a one-use switch token after validating a direct guest assignment. */
+ issueDirectGroupSwitchToken(controller: string, sessionId: string, exclude: ReadonlySet<string>): string | null {
+ const peer = parseProviderSharePeer(controller);
+ if (disposed || peer?.role !== 'guest' || !deps.isControllerAuthorized(controller)
+ || !/^[A-Za-z0-9_-]{1,128}$/.test(sessionId) || exclude.size === 0 || exclude.size > 32) return null;
+ const hostSessionId = hostSessionIdFor(controller, sessionId);
+ const roundKey = key(controller, hostSessionId);
+ const previous = groupSwitchRounds.get(roundKey);
+ const tried = new Set([...(previous && now() - previous.at <= GROUP_SWITCH_ROUND_MS ? previous.tried : []), ...exclude]);
+ if (tried.size > 32) return null;
+ groupSwitchRounds.set(roundKey, { tried, at: now() });
+ return issueGroupSwitchTokenFor(controller, hostSessionId, tried);
+ },
limitUsage(): RemoteAgentLimitUsage {
const counts = [...usageByDevice().values()];
return { total: counts.reduce((sum, count) => sum + count, 0), devices: counts.length, largestDevice: Math.max(0, ...counts) };
@@ -3000,7 +3428,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
async revalidateModelAccess(): Promise<void> {
await Promise.all([...runs.values()]
.filter(run => run.relay && !run.relay.modelAccess && run.providerId
- && deps.providerAccess?.restricted?.(run.providerId, run.controller))
+ && deps.providerAccess?.restricted?.(run.providerId, run.controller, run.sessionId))
.map(run => finishRun(run, 'access-revoked', 'navigation')));
},
/** 立即结束某个控制端的全部任务(例如分享被关闭),不等巡检周期。 */
diff --git a/apps/desktop/src/main/remote-agent/host/service.ts b/apps/desktop/src/main/remote-agent/host/service.ts
index 635d7f3231..d9afb19259 100644
--- a/apps/desktop/src/main/remote-agent/host/service.ts
+++ b/apps/desktop/src/main/remote-agent/host/service.ts
@@ -8,8 +8,10 @@ import { readRemoteAgentLimitsState } from './limitsStore.js';
import path from 'node:path';
import { createNativeHistoryTransfer } from '../nativeHistoryTransfer';
import { nativeHistoryStorage } from '../nativeHistoryStorage';
+import fsp from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
-import { isProviderSharePeer, parseProviderSharePeer } from '@cindy/device-link';
+import { isProviderSharePeer, parseProviderSharePeer, providerShareGuestPeer, type RemoteAgentRequest } from '@cindy/device-link';
import type { Maker, StartSessionOptions } from '@cindy/maker-core';
import { LOCAL_AGENT_CLIENT } from '@cindy/maker-core';
@@ -20,30 +22,33 @@ import {
type DataOwnerBroadcastScope,
} from '../../device-link/broadcast-tap.js';
import { setRemoteAgentHandler } from '../../device-link/dispatch.js';
-import { remoteBackgroundInvoke } from '../../device-link/index.js';
-import { providerShareGuestAccess } from '../../device-link/providerShareHost.js';
+import { getSelfDeviceId, remoteBackgroundInvoke } from '../../device-link/index.js';
+import { getProviderShareHostLoadedSnapshot, onProviderShareHostChanged, ownedProviderShareGuestAccess, providerShareGuestAccess, verifyProviderShareMemberGeneration } from '../../device-link/providerShareHost.js';
+import { applyProviderShareDelegation, clearProviderShareDelegations, delegatedProviderShareGuestAccess, delegatedProviderShareLeases, delegatedProviderShareModelAllowed, delegatedProviderShareReceiptAuthority, delegatedProviderShareSessionAllowed, delegatedProviderShareTaskAccess, invalidateProviderShareDelegation, revokeDelegatedProviderShareGuest } from '../../device-link/providerShareDelegatedAccess.js';
+import { checkProviderShareDelegation, grantProviderShareDelegation, providerShareOwnerKey, revokeProviderShareDelegation } from '../../device-link/providerShareApi.js';
import { remoteModelAccess } from '../../device-link/remoteModelAccess.js';
import { handleProviderShareReshare, providerShareReshareAllows } from '../../device-link/providerShareReshare.js';
import { createProviderGroupGuestRelay } from '../../provider-group/guestRelay.js';
import { providerGroupReshare } from '../../provider-group/reshareRuntime.js';
import { getProviderGroupOwnerScope } from '../../provider-group/runtime.js';
-import { readProviderGroup } from '../../provider-group/store.js';
+import { onProviderGroupChanged, readProviderGroup } from '../../provider-group/store.js';
import { bindGroupFastPolicy, bindLocalHostedGroupFastPolicy, receiveGroupFastPolicy, startGroupFastPolicySync } from '../../provider-group/fastPolicyRuntime.js';
import { groupFastPolicyStore } from '../../provider-group/fastPolicyStore.js';
import { captureProviderManagementScope } from '../../provider-group/managementScope.js';
import { createSubscriptionFastPolicy } from '../../maker-host/subscription-fast-policy.js';
import { getSessionProvider } from '../../maker-host/session-provider-store.js';
import { remoteAgentPollerFor } from '../controller/service';
-import { getProviderShareUsageStore, installProviderShareUsageStore } from '../../device-link/providerShareUsageStore.js';
+import { RemoteAgentRunClient, type RemoteAgentInvoke } from '../controller/runClient.js';
+import { getProviderShareUsageStore, installProviderShareUsageStore, type ProviderShareDirectReceiptRoute } from '../../device-link/providerShareUsageStore.js';
import { currentProviderPartyUsageStore, flushProviderPartyUsage } from '../../usage/providerPartyUsageStore.js';
-import { readDeviceLinkSettings } from '../../device-link/settings-store.js';
+import { onDeviceLinkSettingChanged, readDeviceLinkSettings } from '../../device-link/settings-store.js';
import { readTurnUsageResetAt } from '../../goal-host/usageLimit.js';
import { getDesktopProviderService } from '../../maker-host/createDesktopProviderService.js';
import { bindHostedSessionProvider, hasHostedSessionModelAccess } from '../../maker-host/session-provider-store.js';
import { hostedProviderOffersModel } from '../../maker-host/guest-provider-route-store.js';
import { isRemoteProviderInvocationAllowed } from '../../maker-host/remote-provider-access-store.js';
import { createGuestProviderRouteBinder, guestProviderModelIds, resolveGuestProviderId, resolveSharedProviderId } from './providerAccess';
-import { createRemoteAgentHost, type HostedStartInput, type RemoteAgentHost, type RunUsageRecord } from './runHost';
+import { createRemoteAgentHost, type GroupRelayLoad, type HostedStartInput, type RemoteAgentHost, type RunUsageRecord } from './runHost';
import { purgeClaudeHostedSessionArtifacts, purgeClaudeHostedTranscripts, purgePiHostedSubagentRuns } from './transcripts';
import { captureGeneratedImageStorage, generatedImageErrorCode, handleGeneratedImageArtifacts, prepareGeneratedImageTransport } from '../../cindy-media/generatedImageStorage';
@@ -113,13 +118,135 @@ export function hostedStartOptions(input: HostedStartInput): StartSessionOptions
let host: RemoteAgentHost | null = null;
let stopFastPolicySync: (() => void) | undefined;
+let stopDirectRouteWatch: (() => void) | undefined;
+let stopDirectModelWatch: (() => void) | undefined;
+let stopDirectGroupWatch: (() => void) | undefined;
+let stopDirectSettingsWatch: (() => void) | undefined;
+let directRouteSweep: ReturnType<typeof setInterval> | undefined;
+let delegationCheckTimer: ReturnType<typeof setInterval> | undefined;
+
+/** M's per-task delegated lease takes precedence over any other task's lease. */
+function guestAccessForTask(controller: string, sessionId?: string) {
+ return delegatedProviderShareGuestAccess(controller)
+ ? sessionId ? delegatedProviderShareTaskAccess(controller, sessionId) : null
+ : providerShareGuestAccess(controller);
+}
/** 受邀者能用的供应商:分享的那一个,且本机仍开放「允许被远程调用」。 */
-function guestAllows(controller: string, providerId: string): boolean {
- const access = providerShareGuestAccess(controller);
+function guestAllows(controller: string, providerId: string, sessionId?: string): boolean {
+ const access = guestAccessForTask(controller, sessionId);
return !!access && access.providerId === providerId && isRemoteProviderInvocationAllowed(providerId);
}
+/** An undelegated guest is allowed only on the computer that owns its share. */
+function shareTaskModelAllowed(controller: string, model: string, sessionId?: string): boolean {
+ if (!isProviderSharePeer(controller)) return true;
+ if (delegatedProviderShareGuestAccess(controller)) {
+ return delegatedProviderShareModelAllowed(controller, model, sessionId);
+ }
+ return ownedProviderShareGuestAccess(controller) !== null;
+}
+
+/** Durable admission fence around legacy best-effort guest cleanup. */
+export function createProviderShareMemberPurger(options: {
+ userDataDir: string;
+ usage: ReturnType<typeof installProviderShareUsageStore>;
+ current: Pick<RemoteAgentHost, 'purgeControllers' | 'activeControllers'>;
+ ownerScope: () => string;
+ ownerDeviceId: () => string | null | undefined;
+ isCurrent: () => boolean;
+ hasAccess: (controller: string) => boolean;
+}): (match: (controller: string) => boolean) => Promise<void> {
+ const { usage, current } = options;
+ let memberPurgeWork: Promise<void> = Promise.resolve();
+ const purgeMemberControllers = (match: (controller: string) => boolean): Promise<void> => {
+ const work = memberPurgeWork.then(async () => {
+ const ownerScope = options.ownerScope();
+ const ownerDeviceId = options.ownerDeviceId();
+ if (!ownerDeviceId) throw new Error('Provider share owner device is unavailable');
+ const assertCurrent = () => {
+ if (!options.isCurrent() || options.ownerScope() !== ownerScope || options.ownerDeviceId() !== ownerDeviceId) {
+ throw new Error('Provider share cleanup owner changed');
+ }
+ };
+ const pending = usage.listPendingMemberCleanup(ownerScope, ownerDeviceId).filter((member) =>
+ match(providerShareGuestPeer(member.shareId, member.memberId, 'membership-cleanup')));
+ const belongs = (controller: string, member: typeof pending[number]) => {
+ const peer = parseProviderSharePeer(controller);
+ return peer?.role === 'guest' && peer.shareId === member.shareId && peer.memberId === member.memberId;
+ };
+ // A delayed duplicate purge must not delete a newly admitted incarnation.
+ const guarded = (controller: string) => match(controller)
+ && (pending.some((member) => belongs(controller, member)) || !options.hasAccess(controller));
+ const indexFile = path.join(options.userDataDir, 'remote-agent', 'guest-sessions.json');
+ const readIndex = async (): Promise<Array<Record<string, unknown>>> => {
+ let raw: string;
+ try { raw = await fsp.readFile(indexFile, 'utf8'); }
+ catch (error) {
+ if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+ throw error;
+ }
+ const parsed = JSON.parse(raw) as unknown;
+ if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('Invalid guest cleanup index');
+ const records = Object.values(parsed);
+ if (records.some((record) => !record || typeof record !== 'object' || Array.isArray(record)
+ || typeof (record as Record<string, unknown>).controller !== 'string')) {
+ throw new Error('Invalid guest cleanup index record');
+ }
+ return records as Array<Record<string, unknown>>;
+ };
+ const before = pending.length ? await readIndex() : [];
+ for (const member of pending) {
+ const scopes = before.filter((record) => belongs(record.controller as string, member)).map((record) => ({
+ controller: record.controller as string,
+ ...(typeof record.relay === 'string' && record.relay ? { relay: record.relay } : {}),
+ }));
+ for (const controller of current.activeControllers()) {
+ if (belongs(controller, member)) scopes.push({ controller });
+ }
+ assertCurrent();
+ await usage.rememberMemberCleanupScopes(member, scopes);
+ }
+ await current.purgeControllers(guarded);
+ assertCurrent();
+ // runHost's legacy cleanup is best effort. Retain the membership fence
+ // until its durable index and pending relay forgets are actually empty.
+ // Scope receipts survive index deletion, so failed directory removal can
+ // be retried after an O restart without reviving the old relay tombstone.
+ const directoryKey = (scope: string) => createHash('sha256').update(scope).digest('hex').slice(0, 16);
+ const scopes = usage.listPendingMemberCleanup(ownerScope, ownerDeviceId)
+ .filter((member) => pending.some((item) => item.shareId === member.shareId && item.memberId === member.memberId
+ && item.joinedAt === member.joinedAt && item.present === member.present))
+ .flatMap((member) => member.cleanupScopes ?? []);
+ for (const scope of scopes) {
+ assertCurrent();
+ const controllerKey = directoryKey(scope.controller);
+ const guestKey = directoryKey(scope.relay ? `${scope.controller}\0relay:${scope.relay}` : scope.controller);
+ const cleanupRoot = path.resolve(options.userDataDir, 'remote-agent');
+ for (const [directory, key] of [['workspaces', controllerKey], ['attachments', controllerKey], ['guest-homes', guestKey]] as const) {
+ const target = path.resolve(cleanupRoot, directory, key);
+ const relative = path.relative(cleanupRoot, target);
+ if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('Invalid guest cleanup directory');
+ await fsp.rm(target, { recursive: true, force: true });
+ }
+ }
+ const after = pending.length ? await readIndex() : [];
+ for (const member of pending) {
+ const unfinished = after.some((record) => belongs(record.controller as string, member)
+ && ['hostSessionIds', 'nativeIds', 'members', 'relayDevices', 'forgetPending', 'forkWorkspaces', 'attachmentRunIds']
+ .some((field) => record[field] !== undefined && (record[field] === null
+ || typeof record[field] !== 'object' || Object.keys(record[field] as object).length > 0)));
+ if (unfinished) throw new Error('Provider share legacy history cleanup is still pending');
+ assertCurrent();
+ await usage.acknowledgeMemberCleanup(member);
+ }
+ });
+ memberPurgeWork = work.catch(() => undefined);
+ return work;
+ };
+ return purgeMemberControllers;
+}
+
export function installRemoteAgentHost(options: { getMaker: () => Maker; userDataDir: string }): void {
if (host) return;
const usage = installProviderShareUsageStore(options.userDataDir);
@@ -146,6 +273,594 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
now: () => Date.now(),
log,
});
+ let checkingDelegations = false;
+ delegationCheckTimer = setInterval(() => {
+ if (checkingDelegations) return;
+ checkingDelegations = true;
+ const byPeer = new Map<string, ReturnType<typeof delegatedProviderShareLeases>>();
+ for (const item of delegatedProviderShareLeases()) {
+ const list = byPeer.get(item.peer) ?? [];
+ list.push(item);
+ byPeer.set(item.peer, list);
+ }
+ const groups = [...byPeer.values()];
+ let next = 0;
+ void Promise.all(Array.from({ length: Math.min(8, groups.length) }, async () => {
+ while (next < groups.length) {
+ const items = groups[next++];
+ const first = items[0];
+ const peer = parseProviderSharePeer(first.peer);
+ const deviceId = getSelfDeviceId();
+ if (peer?.role !== 'guest' || !deviceId) continue;
+ try {
+ const confirmed = await checkProviderShareDelegation({
+ shareId: peer.shareId, memberId: peer.memberId, guestDeviceId: peer.deviceId,
+ executorDeviceId: deviceId,
+ });
+ for (const item of items) if (!confirmed.active || confirmed.ownerDeviceId !== item.lease.ownerDeviceId) {
+ invalidateProviderShareDelegation(item.peer, item.sessionId, item.lease.nonce);
+ }
+ } catch {
+ // An unavailable server cannot extend a lease; its original deadline still applies.
+ }
+ }
+ })).finally(() => { checkingDelegations = false; });
+ }, 60_000);
+ (delegationCheckTimer as { unref?: () => void }).unref?.();
+ const directRoutes = new Map<string, {
+ shareId: string; memberId: string; guestDeviceId: string; executorDeviceId: string;
+ providerId: string; groupProviderId: string; memberKey: string; agentKind: string;
+ model: string; sessionId: string; expiresAt: number;
+ generation: string;
+ load?: GroupRelayLoad; lastStatusAt: number;
+ }>();
+ // The executor can finish a turn while O's socket is reconnecting. Retry the same
+ // receipt ID; O persists recent IDs so an ambiguous acknowledgement is harmless.
+ const pendingUsage = new Map<string, { owner: string; request: Extract<RemoteAgentRequest, { op: 'direct-usage' }>;
+ at: number; sending: boolean }>();
+ const sendPendingUsage = (id: string) => {
+ const receipt = pendingUsage.get(id);
+ if (!receipt || receipt.sending) return;
+ receipt.sending = true;
+ void groupRelay.connect(receipt.owner).invoke([receipt.request]).then(() => {
+ pendingUsage.delete(id);
+ }).catch(() => {
+ receipt.sending = false;
+ });
+ };
+ const allocations = new Map<string, Promise<void>>();
+ const directTaskContext = (controller: string, sessionId: string) => {
+ const peer = parseProviderSharePeer(controller);
+ const access = ownedProviderShareGuestAccess(controller);
+ const settings = readDeviceLinkSettings();
+ const ownerDeviceId = getSelfDeviceId();
+ if (peer?.role !== 'guest' || !access || !ownerDeviceId || !getProviderShareHostLoadedSnapshot()
+ || access.shareId !== peer.shareId || access.memberId !== peer.memberId
+ || !settings.remoteControlEnabled || settings.revokedControllers.includes(peer.deviceId)
+ || !isRemoteProviderInvocationAllowed(access.providerId)) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] Provider share access is unavailable');
+ }
+ const identity = { ownerScope: providerShareOwnerKey(), ownerDeviceId,
+ shareId: peer.shareId, memberId: peer.memberId, guestDeviceId: peer.deviceId, sessionId };
+ const joinedAt = getProviderShareHostLoadedSnapshot()?.find((share) => share.shareId === peer.shareId)
+ ?.members.find((member) => member.memberId === peer.memberId)?.joinedAt;
+ if (!joinedAt || !usage.memberGenerationReady(identity, joinedAt)) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] Provider share membership cleanup is pending');
+ }
+ const location = usage.findDirectTaskLocation(identity);
+ if (location && (location.providerId !== access.providerId
+ || usage.pendingDirectCleanupFor(identity.ownerScope, location))) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] Provider share task is unavailable');
+ }
+ return { identity, location, access, joinedAt };
+ };
+ // Removing M from the new-task pool does not move its native history. The
+ // durable location can retain only this exact guest/task/provider on M;
+ // current share, model, device and server/M authorization remain separate.
+ const directTargetAllowed = (route: Pick<ProviderShareDirectReceiptRoute,
+ 'ownerScope' | 'ownerDeviceId' | 'shareId' | 'memberId' | 'guestDeviceId' | 'sessionId'
+ | 'providerId' | 'executorDeviceId' | 'executorProviderId' | 'memberKey'>): boolean => {
+ if (readProviderGroup(route.providerId)?.members.some((member) => member.kind === 'device'
+ && member.key === route.memberKey && member.agentDeviceId === route.executorDeviceId
+ && member.providerId === route.executorProviderId)) return true;
+ const saved = usage.findDirectTaskLocation(route);
+ return !!saved && saved.providerId === route.providerId && saved.memberKey === route.memberKey
+ && saved.executorDeviceId === route.executorDeviceId && saved.executorProviderId === route.executorProviderId;
+ };
+ const liveDirectTargetAllowed = (route: NonNullable<ReturnType<typeof directRoutes.get>>) =>
+ directTargetAllowed({ ...route, ownerScope: providerShareOwnerKey(), ownerDeviceId: getSelfDeviceId() ?? '',
+ providerId: route.groupProviderId, executorProviderId: route.providerId });
+ // The server has one generation per G→M link. Two different task IDs may
+ // renew together, so grant and M's confirmation must be serialized per link.
+ const delegationGrants = new Map<string, Promise<void>>();
+ const withDelegationGrant = async <T>(linkKey: string, work: () => Promise<T>): Promise<T> => {
+ while (delegationGrants.has(linkKey)) await delegationGrants.get(linkKey);
+ let release!: () => void;
+ const turn = new Promise<void>((resolve) => { release = resolve; });
+ delegationGrants.set(linkKey, turn);
+ try { return await work(); }
+ finally {
+ if (delegationGrants.get(linkKey) === turn) delegationGrants.delete(linkKey);
+ release();
+ }
+ };
+ const directSwitchIssued = new Map<string, { generation: string; executorDeviceId: string;
+ at: number; token: string }>();
+ const directSwitchPending = new Map<string, Promise<{ token?: string }>>();
+ const directSwitchAttempts = new Map<string, number>();
+ const revokeDirectRoute = (key: string, route: NonNullable<ReturnType<typeof directRoutes.get>>): Promise<void> => {
+ directRoutes.delete(key);
+ route.load?.release();
+ const { shareId, memberId, guestDeviceId, executorDeviceId, providerId, model, sessionId } = route;
+ void revokeUnusedDirectPair(route).catch(() => undefined);
+ return groupRelay.connect(executorDeviceId).invoke([{
+ op: 'delegate', action: 'revoke', shareId, memberId, guestDeviceId, providerId, model, sessionId,
+ generation: route.generation,
+ }]).then(() => undefined).catch(() => undefined);
+ };
+ const previousDirectRouteAllowed = (route: ProviderShareDirectReceiptRoute): boolean => {
+ const settings = readDeviceLinkSettings();
+ const peer = providerShareGuestPeer(route.shareId, route.memberId, route.guestDeviceId);
+ const access = ownedProviderShareGuestAccess(peer);
+ return route.ownerScope === providerShareOwnerKey() && route.ownerDeviceId === getSelfDeviceId()
+ && route.expiresAt > Date.now() && settings.remoteControlEnabled
+ && usage.memberGenerationReady(route, route.memberJoinedAt)
+ && usage.listActiveDirectReceiptRoutes(route.ownerScope).some((saved) => saved.ownerDeviceId === route.ownerDeviceId
+ && saved.shareId === route.shareId && saved.memberId === route.memberId && saved.guestDeviceId === route.guestDeviceId
+ && saved.sessionId === route.sessionId && saved.executorDeviceId === route.executorDeviceId && saved.generation === route.generation)
+ && !usage.pendingDirectCleanupFor(route.ownerScope, route)
+ && !settings.revokedControllers.includes(route.executorDeviceId)
+ && access?.providerId === route.providerId
+ && isRemoteProviderInvocationAllowed(route.providerId)
+ && remoteModelAccess.allowsDelegatedExecution(route.providerId, route.model, route.memberId)
+ && directTargetAllowed(route);
+ };
+ const assertCommittedDirectRoute = (route: ProviderShareDirectReceiptRoute): void => {
+ const current = directTaskContext(providerShareGuestPeer(route.shareId, route.memberId,
+ route.guestDeviceId), route.sessionId);
+ if (current.identity.ownerScope !== route.ownerScope || current.identity.ownerDeviceId !== route.ownerDeviceId
+ || current.joinedAt !== route.memberJoinedAt || current.location?.generation !== route.generation
+ || current.location.executorDeviceId !== route.executorDeviceId
+ || current.location.executorProviderId !== route.executorProviderId
+ || current.location.providerId !== route.providerId || current.location.model !== route.model
+ || current.location.memberKey !== route.memberKey || current.location.agentKind !== route.agentKind
+ || !previousDirectRouteAllowed(route)) throw new Error('Provider share access changed during commit');
+ };
+ type DirectPairTask = Pick<ProviderShareDirectReceiptRoute,
+ 'shareId' | 'memberId' | 'guestDeviceId' | 'executorDeviceId' | 'sessionId' | 'generation'>;
+ const hasValidDirectSibling = (route: DirectPairTask): boolean => {
+ const sameGuest = (other: DirectPairTask) => other.shareId === route.shareId
+ && other.memberId === route.memberId && other.guestDeviceId === route.guestDeviceId;
+ for (const live of directRoutes.values()) {
+ if (!sameGuest(live) || live.sessionId === route.sessionId
+ || live.executorDeviceId !== route.executorDeviceId) continue;
+ if (previousDirectRouteAllowed({ ...live, ownerScope: providerShareOwnerKey(),
+ ownerDeviceId: getSelfDeviceId() ?? '', providerId: live.groupProviderId,
+ executorProviderId: live.providerId })) return true;
+ }
+ // O may have restarted without restoring A into memory. Only the latest
+ // task assignment counts: an old executor or a provisional row is not A.
+ const latest = new Map<string, ProviderShareDirectReceiptRoute>();
+ for (const saved of usage.listActiveDirectReceiptRoutes(providerShareOwnerKey())) {
+ if (sameGuest(saved) && saved.sessionId !== route.sessionId
+ && saved.ownerDeviceId === getSelfDeviceId()) latest.set(saved.sessionId, saved);
+ }
+ return [...latest.values()].some((saved) => saved.committedAt !== undefined
+ && saved.executorDeviceId === route.executorDeviceId && previousDirectRouteAllowed(saved));
+ };
+ const revokeUnusedDirectPair = (route: DirectPairTask): Promise<void> => {
+ // A server generation belongs to G/M, even when B's allocation created it.
+ // Removing B's local lease must not disconnect a still-authorized sibling A.
+ return hasValidDirectSibling(route) ? Promise.resolve() : revokeProviderShareDelegation({
+ shareId: route.shareId, memberId: route.memberId, guestDeviceId: route.guestDeviceId,
+ executorDeviceId: route.executorDeviceId, generation: route.generation,
+ });
+ };
+ /** A new M grant replaces the session lease without closing its run. Restore
+ * the last committed model with another grant before retiring a failed one. */
+ const restorePreviousDirectGrant = async (previous: ProviderShareDirectReceiptRoute) => {
+ if (!previousDirectRouteAllowed(previous)) throw new Error('Previous provider share route is no longer allowed');
+ const delegation = { shareId: previous.shareId, memberId: previous.memberId,
+ guestDeviceId: previous.guestDeviceId, executorDeviceId: previous.executorDeviceId };
+ // A delete/rejoin boundary cannot resurrect the task that preceded it.
+ if (usage.pendingDirectCleanupFor(previous.ownerScope, delegation)) {
+ throw new Error('Previous provider share task is pending deletion');
+ }
+ const memberJoinedAt = previous.memberJoinedAt ?? getProviderShareHostLoadedSnapshot()
+ ?.find((share) => share.shareId === previous.shareId)?.members.find((member) => member.memberId === previous.memberId)?.joinedAt;
+ if (!memberJoinedAt) throw new Error('Previous provider share membership is unavailable');
+ const granted = await grantProviderShareDelegation(delegation);
+ const restored: ProviderShareDirectReceiptRoute = {
+ ownerScope: previous.ownerScope, ownerDeviceId: previous.ownerDeviceId, ...delegation, memberJoinedAt,
+ sessionId: previous.sessionId, agentKind: previous.agentKind,
+ executorProviderId: previous.executorProviderId, providerId: previous.providerId,
+ memberKey: previous.memberKey, model: previous.model,
+ generation: granted.generation, expiresAt: granted.expiresAt,
+ };
+ const { invoke } = groupRelay.connect(previous.executorDeviceId);
+ let grantAttempted = false;
+ try {
+ await verifyProviderShareMemberGeneration({ ...delegation, joinedAt: memberJoinedAt });
+ const cleanupEpoch = await usage.registerDirectReceiptRoute(restored);
+ if (!previousDirectRouteAllowed(previous)) throw new Error('Previous provider share route is no longer allowed');
+ await bindGroupFastPolicy({ group: previous.providerId, deviceId: previous.executorDeviceId,
+ sessionId: previous.sessionId, providerShareGuest: {
+ shareId: previous.shareId, memberId: previous.memberId, guestDeviceId: previous.guestDeviceId,
+ } });
+ if (!previousDirectRouteAllowed(previous)) throw new Error('Previous provider share route is no longer allowed');
+ grantAttempted = true;
+ await invoke([{ op: 'delegate', action: 'grant', ...delegation,
+ providerId: previous.executorProviderId, model: previous.model,
+ sessionId: previous.sessionId, generation: granted.generation, cleanupEpoch }]);
+ if (!previousDirectRouteAllowed(previous)) throw new Error('Previous provider share route is no longer allowed');
+ await usage.commitDirectReceiptRoute(restored);
+ assertCommittedDirectRoute(restored);
+ return restored;
+ } catch (error) {
+ const revokes = [revokeUnusedDirectPair(restored)];
+ if (grantAttempted) revokes.push(invoke([{ op: 'delegate', action: 'revoke', ...delegation,
+ providerId: previous.executorProviderId, model: previous.model,
+ sessionId: previous.sessionId, generation: granted.generation }]).then(() => undefined));
+ await Promise.allSettled(revokes);
+ try { await usage.markDirectReceiptRouteRevoked(restored); }
+ catch (revokeError) { log.warn('provider group failed restoration journal revocation will retry', {
+ error: String(revokeError),
+ }); }
+ throw error;
+ }
+ };
+ const dropLiveDirectReceiptRoute = (route: ProviderShareDirectReceiptRoute) => {
+ const key = JSON.stringify([providerShareGuestPeer(route.shareId, route.memberId,
+ route.guestDeviceId), route.sessionId]);
+ const live = directRoutes.get(key);
+ if (live?.generation !== route.generation || live.executorDeviceId !== route.executorDeviceId) return;
+ directRoutes.delete(key);
+ live.load?.release();
+ directSwitchIssued.delete(key);
+ };
+ const revokeRetiredDirectReceiptRoutes = (key: string, routes: ProviderShareDirectReceiptRoute[]): Promise<void> => {
+ const live = directRoutes.get(key);
+ if (live) {
+ directRoutes.delete(key);
+ live.load?.release();
+ }
+ const targets = [...routes];
+ if (live && !targets.some((route) => route.generation === live.generation
+ && route.executorDeviceId === live.executorDeviceId)) {
+ targets.push({ ownerScope: providerShareOwnerKey(), ownerDeviceId: getSelfDeviceId() ?? '',
+ shareId: live.shareId, memberId: live.memberId, guestDeviceId: live.guestDeviceId,
+ executorDeviceId: live.executorDeviceId, executorProviderId: live.providerId,
+ providerId: live.groupProviderId, memberKey: live.memberKey, agentKind: live.agentKind,
+ model: live.model, sessionId: live.sessionId, generation: live.generation,
+ expiresAt: live.expiresAt });
+ }
+ const revocations: Promise<void>[] = [];
+ for (const route of targets) {
+ try {
+ revocations.push(revokeDirectRoute(key, {
+ shareId: route.shareId, memberId: route.memberId, guestDeviceId: route.guestDeviceId,
+ executorDeviceId: route.executorDeviceId, providerId: route.executorProviderId,
+ groupProviderId: route.providerId, memberKey: route.memberKey, agentKind: route.agentKind,
+ model: route.model, sessionId: route.sessionId, generation: route.generation,
+ expiresAt: route.expiresAt, lastStatusAt: Date.now(),
+ }));
+ } catch (error) {
+ log.warn('provider group retired direct route remote revocation failed', {
+ executorDeviceId: route.executorDeviceId, error: String(error),
+ });
+ }
+ }
+ directSwitchIssued.delete(key);
+ return Promise.all(revocations).then(() => undefined);
+ };
+ const retireDirectReceiptRoutes = async (routes: ProviderShareDirectReceiptRoute[]) => {
+ for (const route of routes) {
+ try {
+ await usage.markDirectReceiptRouteRevoked(route);
+ dropLiveDirectReceiptRoute(route);
+ }
+ catch (error) { log.warn('provider group superseded route journal revocation will retry', {
+ error: String(error),
+ }); }
+ }
+ };
+ const settlePendingDirectCleanup = async (delegation: {
+ shareId: string; memberId: string; guestDeviceId: string; executorDeviceId: string;
+ }, invoke: RemoteAgentInvoke): Promise<boolean> => {
+ const ownerScope = providerShareOwnerKey();
+ const pending = usage.pendingDirectCleanupFor(ownerScope, delegation);
+ if (!pending) return false;
+ await invoke([{ op: 'forget', directGuest: {
+ shareId: pending.shareId, memberId: pending.memberId,
+ guestDeviceId: pending.guestDeviceId, forgetId: pending.pendingId,
+ cleanupEpoch: pending.cleanupEpoch,
+ } }]);
+ // Keep the cleanup pending until all pre-delete routes have been retired
+ // durably. A crash can then retry the idempotent forget before any grant.
+ for (const saved of usage.listActiveDirectReceiptRoutes(ownerScope)) {
+ if (saved.shareId === delegation.shareId && saved.memberId === delegation.memberId
+ && saved.guestDeviceId === delegation.guestDeviceId
+ && saved.executorDeviceId === delegation.executorDeviceId) {
+ await revokeProviderShareDelegation({ ...delegation, generation: saved.generation });
+ await usage.markDirectReceiptRouteRevoked(saved);
+ }
+ }
+ for (const [key, route] of directRoutes) {
+ if (route.shareId === delegation.shareId && route.memberId === delegation.memberId
+ && route.guestDeviceId === delegation.guestDeviceId
+ && route.executorDeviceId === delegation.executorDeviceId) {
+ directRoutes.delete(key);
+ route.load?.release();
+ directSwitchIssued.delete(key);
+ }
+ }
+ await usage.acknowledgeDirectCleanup(pending);
+ return true;
+ };
+ const restoreDirectRoute = (controller: string, sessionId: string) => {
+ const key = JSON.stringify([controller, sessionId]);
+ const live = directRoutes.get(key);
+ if (live) {
+ if (!usage.pendingDirectCleanupFor(providerShareOwnerKey(), live)) return live;
+ directRoutes.delete(key);
+ live.load?.release();
+ return null;
+ }
+ const peer = parseProviderSharePeer(controller);
+ const self = getSelfDeviceId();
+ const settings = readDeviceLinkSettings();
+ if (peer?.role !== 'guest' || !self || !settings.remoteControlEnabled
+ || settings.revokedControllers.includes(peer.deviceId) || !getProviderShareHostLoadedSnapshot()) return null;
+ const saved = usage.listActiveDirectReceiptRoutes(providerShareOwnerKey())
+ .filter((route) => route.ownerDeviceId === self
+ && route.shareId === peer.shareId && route.memberId === peer.memberId
+ && route.guestDeviceId === peer.deviceId && route.sessionId === sessionId)
+ .reduce<(ReturnType<typeof usage.listActiveDirectReceiptRoutes>[number]) | null>((last, route) =>
+ !last || (last.createdAt ?? 0) <= (route.createdAt ?? 0) ? route : last, null);
+ const access = ownedProviderShareGuestAccess(controller);
+ if (!saved || saved.committedAt === undefined
+ || usage.pendingDirectCleanupFor(saved.ownerScope, saved)
+ || access?.providerId !== saved.providerId
+ || !isRemoteProviderInvocationAllowed(saved.providerId)
+ || !remoteModelAccess.allowsDelegatedExecution(saved.providerId, saved.model, saved.memberId)
+ || !directTargetAllowed(saved)) return null;
+ const load = groupRelay.trackRun(saved.providerId, saved.memberKey);
+ const route = { shareId: saved.shareId, memberId: saved.memberId, guestDeviceId: saved.guestDeviceId,
+ executorDeviceId: saved.executorDeviceId, providerId: saved.executorProviderId,
+ groupProviderId: saved.providerId, memberKey: saved.memberKey, agentKind: saved.agentKind,
+ model: saved.model, sessionId: saved.sessionId, expiresAt: saved.expiresAt,
+ generation: saved.generation, load, lastStatusAt: Date.now() };
+ directRoutes.set(key, route);
+ return route;
+ };
+ let reconcileAfterAllocation = false;
+ let reconcilingJournal = false;
+ let reconcileJournalAgain = false;
+ const reconcileDirectJournal = async () => {
+ if (reconcilingJournal) { reconcileJournalAgain = true; return; }
+ const self = getSelfDeviceId();
+ if (!self) return;
+ const settings = readDeviceLinkSettings();
+ if (!getProviderShareHostLoadedSnapshot() && settings.remoteControlEnabled) return;
+ reconcilingJournal = true;
+ try {
+ type JournalRoute = ReturnType<typeof usage.listActiveDirectReceiptRoutes>[number];
+ const rows = usage.listActiveDirectReceiptRoutes(providerShareOwnerKey())
+ .filter((route) => route.ownerDeviceId === self);
+ const routeOrder = new Map(rows.map((route, index) => [route, index]));
+ const sessionKey = (route: JournalRoute) => JSON.stringify([
+ route.shareId, route.memberId, route.guestDeviceId, route.sessionId]);
+ const pairKey = (route: JournalRoute) => JSON.stringify([
+ route.shareId, route.memberId, route.guestDeviceId, route.executorDeviceId]);
+ const sessionExecutorKey = (route: JournalRoute) => JSON.stringify([
+ sessionKey(route), route.executorDeviceId]);
+ const latestSession = new Map<string, JournalRoute>();
+ const latestExecutor = new Map<string, JournalRoute>();
+ const latestPair = new Map<string, JournalRoute>();
+ for (const route of rows) {
+ const addLatest = (map: Map<string, JournalRoute>, id: string) => { map.set(id, route); };
+ addLatest(latestSession, sessionKey(route));
+ if (route.committedAt !== undefined) {
+ addLatest(latestExecutor, sessionExecutorKey(route));
+ }
+ addLatest(latestPair, pairKey(route));
+ }
+ const valid = (route: JournalRoute): boolean => {
+ if (route.committedAt === undefined || latestSession.get(sessionKey(route)) !== route
+ || usage.pendingDirectCleanupFor(route.ownerScope, route)
+ || !settings.remoteControlEnabled
+ || settings.revokedControllers.includes(route.executorDeviceId)) return false;
+ const peer = providerShareGuestPeer(route.shareId, route.memberId, route.guestDeviceId);
+ const live = directRoutes.get(JSON.stringify([peer, route.sessionId]));
+ if (live && (live.executorDeviceId !== route.executorDeviceId || live.expiresAt > route.expiresAt)) return false;
+ const access = ownedProviderShareGuestAccess(peer);
+ return access?.providerId === route.providerId
+ && isRemoteProviderInvocationAllowed(route.providerId)
+ && remoteModelAccess.allowsDelegatedExecution(route.providerId, route.model, route.memberId)
+ && directTargetAllowed(route);
+ };
+ const jobs = new Map<string, JournalRoute[]>();
+ for (const route of [...latestExecutor.values(), ...rows.filter((row) => row.committedAt === undefined)]) {
+ const key = pairKey(route);
+ const group = jobs.get(key) ?? [];
+ group.push(route);
+ jobs.set(key, group);
+ }
+ const reconcileRoute = async (route: JournalRoute) => {
+ if (allocations.has(JSON.stringify([
+ providerShareGuestPeer(route.shareId, route.memberId, route.guestDeviceId), route.sessionId,
+ ]))) { reconcileAfterAllocation = true; return; }
+ // Only the newest provisional route can describe M's current lease.
+ // Retiring an older one first can expose an obsolete committed route.
+ if (route.committedAt === undefined && latestSession.get(sessionKey(route)) !== route) return;
+ // A provisional grant may already have replaced M's old lease. Resolve
+ // that generation first; old committed rows cannot clear its journal.
+ if (route.committedAt !== undefined && rows.some((candidate) =>
+ candidate.committedAt === undefined && sessionKey(candidate) === sessionKey(route)
+ && (candidate.createdAt ?? 0) >= (route.createdAt ?? 0))) return;
+ if (route.committedAt === undefined) {
+ const previous = [...rows].reverse().find((candidate) => candidate.committedAt !== undefined
+ && routeOrder.get(candidate)! < routeOrder.get(route)!
+ && sessionExecutorKey(candidate) === sessionExecutorKey(route));
+ if (previous && previousDirectRouteAllowed(previous)) {
+ let recovered = false;
+ let deferred = false;
+ try {
+ await withDelegationGrant(pairKey(route), async () => {
+ const key = JSON.stringify([providerShareGuestPeer(route.shareId, route.memberId,
+ route.guestDeviceId), route.sessionId]);
+ if (allocations.has(key)) { reconcileAfterAllocation = true; deferred = true; return; }
+ const current = usage.listActiveDirectReceiptRoutes(providerShareOwnerKey());
+ const pending = current.filter((candidate) => sessionKey(candidate) === sessionKey(route));
+ if (pending.at(-1)?.generation !== route.generation
+ || !pending.some((candidate) => candidate.generation === previous.generation)
+ || !previousDirectRouteAllowed(previous)) { deferred = true; return; }
+ const restored = await restorePreviousDirectGrant(previous);
+ const live = directRoutes.get(key);
+ if (live?.generation === previous.generation) directRoutes.set(key, {
+ ...live, generation: restored.generation, expiresAt: restored.expiresAt,
+ });
+ await retireDirectReceiptRoutes(pending.filter((candidate) =>
+ candidate.executorDeviceId === route.executorDeviceId));
+ recovered = true;
+ });
+ } catch (error) {
+ log.warn('provider group previous direct route restoration failed', {
+ executorDeviceId: route.executorDeviceId, error: String(error),
+ });
+ }
+ if (recovered || deferred) return;
+ if (usage.listActiveDirectReceiptRoutes(providerShareOwnerKey())
+ .some((candidate) => candidate.generation !== route.generation
+ && sessionKey(candidate) === sessionKey(route)
+ && (candidate.createdAt ?? 0) > (route.createdAt ?? 0))) {
+ dropLiveDirectReceiptRoute(previous);
+ return;
+ }
+ if (previousDirectRouteAllowed(previous)) {
+ // g2 may have crashed before M saw it. Revoke only g2, keep g1's
+ // committed evidence for a later restoration attempt, and stop O
+ // from advertising g1 until M has confirmed a fresh grant.
+ dropLiveDirectReceiptRoute(previous);
+ const revokes = await Promise.allSettled([
+ groupRelay.connect(route.executorDeviceId).invoke([{ op: 'delegate', action: 'revoke',
+ shareId: route.shareId, memberId: route.memberId, guestDeviceId: route.guestDeviceId,
+ providerId: route.executorProviderId, model: route.model, sessionId: route.sessionId,
+ generation: route.generation }]),
+ revokeUnusedDirectPair(route),
+ ]);
+ if (revokes.some((result) => result.status === 'rejected')) {
+ log.warn('provider group provisional direct revocation will retry', {
+ executorDeviceId: route.executorDeviceId,
+ });
+ }
+ return;
+ }
+ }
+ }
+ if (valid(route)) {
+ for (const old of rows) if (old !== route
+ && routeOrder.get(old)! < routeOrder.get(route)!
+ && sessionExecutorKey(old) === sessionExecutorKey(route)) {
+ await usage.markDirectReceiptRouteRevoked(old);
+ dropLiveDirectReceiptRoute(old);
+ }
+ return;
+ }
+ const serverRevoke = latestPair.get(pairKey(route)) === route;
+ const revoke = { op: 'delegate' as const, action: 'revoke' as const,
+ shareId: route.shareId, memberId: route.memberId, guestDeviceId: route.guestDeviceId,
+ providerId: route.executorProviderId, model: route.model, sessionId: route.sessionId,
+ generation: route.generation };
+ const work = [groupRelay.connect(route.executorDeviceId).invoke([revoke])];
+ if (serverRevoke) work.push(revokeUnusedDirectPair(route));
+ const outcomes = await Promise.allSettled(work);
+ if (outcomes.some((outcome) => outcome.status === 'rejected')) {
+ log.warn('provider group direct revocation will retry', { executorDeviceId: route.executorDeviceId });
+ return;
+ }
+ for (const old of rows) if (routeOrder.get(old)! <= routeOrder.get(route)!
+ && sessionExecutorKey(old) === sessionExecutorKey(route)) {
+ await usage.markDirectReceiptRouteRevoked(old);
+ dropLiveDirectReceiptRoute(old);
+ }
+ };
+ const groups = [...jobs.values()];
+ let nextGroup = 0;
+ await Promise.all(Array.from({ length: Math.min(16, groups.length) }, async () => {
+ while (nextGroup < groups.length) {
+ const group = groups[nextGroup++]!;
+ for (const route of group) {
+ try { await reconcileRoute(route); }
+ catch (error) {
+ log.warn('provider group direct journal route reconciliation failed', {
+ executorDeviceId: route.executorDeviceId, error: String(error),
+ });
+ }
+ }
+ }
+ }));
+ } catch (error) {
+ log.warn('provider group direct journal reconciliation failed', { error: String(error) });
+ } finally {
+ reconcilingJournal = false;
+ if (reconcileJournalAgain) {
+ reconcileJournalAgain = false;
+ queueMicrotask(() => { void reconcileDirectJournal(); });
+ }
+ }
+ };
+ stopDirectRouteWatch = onProviderShareHostChanged(() => {
+ if (!getProviderShareHostLoadedSnapshot()) return;
+ for (const [key, route] of directRoutes) {
+ const access = ownedProviderShareGuestAccess(providerShareGuestPeer(route.shareId, route.memberId, route.guestDeviceId));
+ if (!access || access.providerId !== route.groupProviderId || route.expiresAt <= Date.now()
+ || !remoteModelAccess.allowsDelegatedExecution(route.groupProviderId, route.model, route.memberId)) revokeDirectRoute(key, route);
+ }
+ void reconcileDirectJournal();
+ });
+ stopDirectModelWatch = remoteModelAccess.subscribe(() => {
+ for (const [key, route] of directRoutes) {
+ if (!remoteModelAccess.allowsDelegatedExecution(route.groupProviderId, route.model, route.memberId)) revokeDirectRoute(key, route);
+ }
+ void reconcileDirectJournal();
+ });
+ stopDirectGroupWatch = onProviderGroupChanged((providerId) => {
+ for (const [key, route] of directRoutes) {
+ if (route.groupProviderId !== providerId) continue;
+ if (!liveDirectTargetAllowed(route)) {
+ revokeDirectRoute(key, route);
+ }
+ }
+ void reconcileDirectJournal();
+ });
+ stopDirectSettingsWatch = onDeviceLinkSettingChanged((changed) => {
+ if (changed !== 'remoteControlEnabled' && changed !== 'revokedControllers') return;
+ const settings = readDeviceLinkSettings();
+ for (const [key, route] of directRoutes) {
+ if (!settings.remoteControlEnabled || settings.revokedControllers.includes(route.executorDeviceId)) {
+ revokeDirectRoute(key, route);
+ }
+ }
+ void reconcileDirectJournal();
+ });
+ directRouteSweep = setInterval(() => {
+ void reconcileDirectJournal();
+ for (const [id, receipt] of pendingUsage) {
+ if (receipt.at + 30 * 60_000 <= Date.now()) pendingUsage.delete(id);
+ else sendPendingUsage(id);
+ }
+ for (const [key, route] of directRoutes) {
+ const access = getProviderShareHostLoadedSnapshot()
+ ? providerShareGuestAccess(providerShareGuestPeer(route.shareId, route.memberId, route.guestDeviceId)) : null;
+ if (route.expiresAt <= Date.now() || !liveDirectTargetAllowed(route)
+ || (getProviderShareHostLoadedSnapshot() && (!access || access.providerId !== route.groupProviderId
+ || !remoteModelAccess.allowsDelegatedExecution(route.groupProviderId, route.model, route.memberId)))) {
+ revokeDirectRoute(key, route);
+ } else if (Date.now() - route.lastStatusAt > 150_000) route.load?.setRunning(false);
+ }
+ }, 60_000);
+ (directRouteSweep as { unref?: () => void }).unref?.();
host = createRemoteAgentHost({
nativeHistory: createNativeHistoryTransfer(path.join(options.userDataDir, 'native-history-transfers'), nativeHistoryStorage(options.userDataDir)),
fastPolicy: receiveGroupFastPolicy,
@@ -176,45 +891,51 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
isControllerAuthorized,
controllerTrust: (controller) => (isProviderSharePeer(controller) ? 'guest' : 'owner'),
providerAccess: {
- models: async (kind, providerId, controller) => {
+ models: async (kind, providerId, controller, sessionId) => {
const views = await getDesktopProviderService().listProviders({ allowSideEffects: false });
- const access = isProviderSharePeer(controller) ? providerShareGuestAccess(controller) : null;
+ const access = isProviderSharePeer(controller) ? guestAccessForTask(controller, sessionId) : null;
if (isProviderSharePeer(controller) && access?.providerId !== providerId) return [];
return guestProviderModelIds(views, providerId, kind)
.filter(model => isControllerAuthorized(controller) && isRemoteProviderInvocationAllowed(providerId)
+ && shareTaskModelAllowed(controller, model, sessionId)
&& remoteModelAccess.allows(providerId, model, access?.memberId));
},
- restricted: (providerId, controller) => {
+ restricted: (providerId, controller, sessionId) => {
try {
- const access = isProviderSharePeer(controller) ? providerShareGuestAccess(controller) : null;
+ if (delegatedProviderShareGuestAccess(controller)) return true;
+ const access = isProviderSharePeer(controller) ? guestAccessForTask(controller, sessionId) : null;
const rule = remoteModelAccess.read(providerId, access?.memberId);
return rule.models !== null || rule.providerModels !== null || !!(rule.memberBudget?.enabled && rule.memberBudget.rules.length);
} catch { return true; }
},
- resolve: async (kind, model, providerId, controller) => {
+ resolve: async (kind, model, providerId, controller, sessionId) => {
const views = await getDesktopProviderService().listProviders({ allowSideEffects: false });
- const memberId = isProviderSharePeer(controller) ? providerShareGuestAccess(controller)?.memberId : undefined;
+ const access = isProviderSharePeer(controller) ? guestAccessForTask(controller, sessionId) : null;
+ const memberId = access?.memberId;
const allowed = (id: string) => {
- if (!isRemoteProviderInvocationAllowed(id) || !remoteModelAccess.allows(id, model, memberId)) return false;
+ if (!isRemoteProviderInvocationAllowed(id) || !shareTaskModelAllowed(controller, model, sessionId) || !remoteModelAccess.allows(id, model, memberId)) return false;
assertMemberBudget(id, model, memberId);
return true;
};
// 受邀者:来源钉在分享的供应商上,且要它提供所选模型(启动与每次换模型都核对)。
if (isProviderSharePeer(controller)) {
+ // G still names O's shared provider; M resolves that alias to its own group member provider.
+ const delegated = sessionId ? delegatedProviderShareTaskAccess(controller, sessionId) : null;
return resolveGuestProviderId(
views,
- providerShareGuestAccess(controller)?.providerId,
- (id) => guestAllows(controller, id) && allowed(id),
+ access?.providerId,
+ (id) => guestAllows(controller, id, sessionId) && allowed(id),
kind,
model,
- providerId,
+ delegated ? undefined : providerId,
);
}
return resolveSharedProviderId(views, allowed, kind, model, providerId);
},
- isAllowed: (providerId, controller, model) => {
- const access = isProviderSharePeer(controller) ? providerShareGuestAccess(controller) : null;
- return (isProviderSharePeer(controller) ? guestAllows(controller, providerId) : isRemoteProviderInvocationAllowed(providerId))
+ isAllowed: (providerId, controller, model, sessionId) => {
+ const access = isProviderSharePeer(controller) ? guestAccessForTask(controller, sessionId) : null;
+ return (isProviderSharePeer(controller) ? guestAllows(controller, providerId, sessionId) : isRemoteProviderInvocationAllowed(providerId))
+ && shareTaskModelAllowed(controller, model ?? '', sessionId)
&& remoteModelAccess.allows(providerId, model ?? '', access?.memberId)
&& (assertMemberBudget(providerId, model ?? '', access?.memberId), true);
},
@@ -222,12 +943,15 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
// 受邀者任务的出站登记:本机 proxy 只让它经分享的供应商、用它提供的模型。
bindGuestProviderRoute: createGuestProviderRouteBinder({
readProviders: () => getDesktopProviderService().listProviders({ allowSideEffects: false }),
- guestAccess: providerShareGuestAccess,
+ guestAccess: guestAccessForTask,
+ modelAllowed: shareTaskModelAllowed,
+ modelRestricted: (controller, sessionId) => delegatedProviderShareTaskAccess(controller, sessionId) !== null,
ownerAllowed: isControllerAuthorized,
providerAllowed: isRemoteProviderInvocationAllowed,
modelAccess: remoteModelAccess,
memberBudgetAllows,
memberBudgetDenial,
+ receiptMeteringAllowed: (controller, sessionId) => delegatedProviderShareTaskAccess(controller, sessionId) === null,
recordRequestUsage: (controller, providerId, kind, sample) => {
const peer = parseProviderSharePeer(controller);
if (peer?.role === 'guest' && peer.memberId) usage.record(peer.shareId, peer.memberId,
@@ -248,23 +972,477 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
// task close/idle retains bindings so resuming cannot restore Fast.
await groupFastPolicyStore.forgetSessions(hostSessionIds, assertCurrent);
},
- recordGuestUsage: (controller, sample) => {
+ recordGuestUsage: (controller, sample, sessionId) => {
const peer = parseProviderSharePeer(controller);
- if (peer?.role === 'guest' && peer.memberId) usage.record(peer.shareId, peer.memberId, sample);
+ if (peer?.role === 'guest' && peer.memberId) {
+ // O receives only model/counter data for the matching delegated task.
+ const authority = sessionId && delegatedProviderShareReceiptAuthority(controller, sessionId);
+ if (authority) {
+ for (let i = 0; i < sample.samples.length; i += 64) {
+ const usageId = randomUUID();
+ const request: Extract<RemoteAgentRequest, { op: 'direct-usage' }> = {
+ op: 'direct-usage', shareId: peer.shareId, memberId: peer.memberId,
+ guestDeviceId: peer.deviceId, sessionId, generation: authority.generation, usageId,
+ agentKind: sample.kind, samples: sample.samples.slice(i, i + 64),
+ };
+ if (pendingUsage.size >= 20_000) pendingUsage.delete(pendingUsage.keys().next().value!);
+ pendingUsage.set(usageId, { owner: authority.ownerDeviceId, request, at: Date.now(), sending: false });
+ sendPendingUsage(usageId);
+ }
+ } else if (ownedProviderShareGuestAccess(controller)) {
+ usage.record(peer.shareId, peer.memberId, sample);
+ } else {
+ log.warn('provider share delegated usage could not be attributed to owner', {
+ shareId: peer.shareId, memberId: peer.memberId,
+ });
+ }
+ }
// 同账号的组所在电脑替它的受邀者转过来的任务:记在那台电脑名下(经那台使用)。
else if (!peer) recordDeviceUsage(controller, sample, 'relay');
},
recordOwnerUsage: (controller, sample) => recordDeviceUsage(controller, sample, 'device'),
// 供应商组(本机是组所在电脑):受邀者的任务按组分给组内电脑,本机中转(provider-groups.md §4)。
groupRelay,
+ directGuestExecution: {
+ ownerScope: providerShareOwnerKey,
+ async locate(controller, request) {
+ const key = JSON.stringify([controller, request.sessionId]);
+ while (allocations.has(key)) await allocations.get(key);
+ const { location } = directTaskContext(controller, request.sessionId);
+ return location ? { deviceId: location.executorDeviceId } : null;
+ },
+ async acceptRelay(controller, sessionId, hasNativeHistory) {
+ const key = JSON.stringify([controller, sessionId]);
+ while (allocations.has(key)) await allocations.get(key);
+ let finish!: () => void;
+ const turn = new Promise<void>((resolve) => { finish = resolve; });
+ allocations.set(key, turn);
+ try {
+ const { identity, location } = directTaskContext(controller, sessionId);
+ if (!location) return;
+ if (hasNativeHistory) throw new Error('[REMOTE_AGENT_UNAVAILABLE] Native history belongs to its original executor');
+ await withDelegationGrant(JSON.stringify([identity.shareId, identity.memberId,
+ identity.guestDeviceId, location.executorDeviceId]), async () => {
+ const current = directTaskContext(controller, sessionId);
+ if (current.identity.ownerScope !== identity.ownerScope
+ || current.identity.ownerDeviceId !== identity.ownerDeviceId
+ || current.location?.generation !== location.generation) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] Provider share assignment changed');
+ }
+ const routes = usage.listActiveDirectReceiptRoutes(identity.ownerScope).filter((route) =>
+ route.ownerDeviceId === identity.ownerDeviceId && route.shareId === identity.shareId
+ && route.memberId === identity.memberId && route.guestDeviceId === identity.guestDeviceId
+ && route.sessionId === sessionId);
+ for (const route of routes) await usage.markDirectReceiptRouteRevoked(route);
+ if (!await usage.markDirectTaskRelayed(identity, location.generation)) {
+ throw new Error('[REMOTE_AGENT_UNAVAILABLE] Provider share assignment changed');
+ }
+ // Remote revocation is best effort; the durable handoff must finish
+ // before O accepts history, even if the failed executor is offline.
+ void revokeRetiredDirectReceiptRoutes(key, routes);
+ });
+ } finally {
+ if (allocations.get(key) === turn) allocations.delete(key);
+ finish();
+ }
+ },
+ async allocate(controller, request) {
+ const routeKey = JSON.stringify([controller, request.sessionId]);
+ while (allocations.has(routeKey)) await allocations.get(routeKey);
+ let finish!: () => void;
+ const turn = new Promise<void>((resolve) => { finish = resolve; });
+ allocations.set(routeKey, turn);
+ try {
+ const peer = parseProviderSharePeer(controller);
+ const access = ownedProviderShareGuestAccess(controller);
+ if (peer?.role !== 'guest' || !access || !isRemoteProviderInvocationAllowed(access.providerId)
+ || !remoteModelAccess.allowsDelegatedExecution(access.providerId, request.model, access.memberId)) return null;
+ if (!directRoutes.has(routeKey) && directRoutes.size >= 512) return null;
+ const { identity, location, joinedAt } = directTaskContext(controller, request.sessionId);
+ const old = restoreDirectRoute(controller, request.sessionId) ?? undefined;
+ const group = readProviderGroup(access.providerId);
+ if (location && (location.agentKind !== request.agentKind
+ || (request.preferredExecutorDeviceId && request.preferredExecutorDeviceId !== location.executorDeviceId))) return null;
+ const preferred = location?.executorDeviceId ?? request.preferredExecutorDeviceId;
+ // A live G→M task cannot be renewed on a newly selected M: its run and
+ // reliable link remain on the original executor, including after O restarts.
+ if (preferred && !location && !group?.members.some((member) => member.kind === 'device'
+ && member.agentDeviceId === preferred)) return null;
+ if (preferred && readDeviceLinkSettings().revokedControllers.includes(preferred)) return null;
+ const retained = old && old.expiresAt > Date.now() && old.groupProviderId === access.providerId
+ && old.agentKind === request.agentKind && old.model === request.model
+ && (!preferred || old.executorDeviceId === preferred)
+ && liveDirectTargetAllowed(old);
+ const selected = location ? { agentDeviceId: location.executorDeviceId, providerId: location.executorProviderId,
+ memberKey: location.memberKey, sameAccount: true }
+ : retained ? { agentDeviceId: old.executorDeviceId, providerId: old.providerId,
+ memberKey: old.memberKey, sameAccount: true }
+ : await groupRelay.plan({ kind: request.agentKind, model: request.model,
+ providerId: access.providerId,
+ exclude: preferred ? new Set(group!.members.filter((member) => member.kind !== 'device'
+ || member.agentDeviceId !== preferred).map((member) => member.key)) : new Set(), reserve: true });
+ if (!selected || !('sameAccount' in selected) || !selected.sameAccount
+ || (preferred && selected.agentDeviceId !== preferred)) {
+ if (selected && 'load' in selected) selected.load?.release();
+ return null;
+ }
+ try {
+ const assertCurrent = (generation = location?.generation) => {
+ const current = directTaskContext(controller, request.sessionId);
+ const live = current.access;
+ const currentGroup = readProviderGroup(access.providerId);
+ if (current.identity.ownerScope !== identity.ownerScope || current.identity.ownerDeviceId !== identity.ownerDeviceId
+ || current.joinedAt !== joinedAt
+ || current.location?.generation !== generation
+ || readDeviceLinkSettings().revokedControllers.includes(selected.agentDeviceId)
+ || live.providerId !== access.providerId || !remoteModelAccess.allowsDelegatedExecution(live.providerId, request.model, live.memberId)
+ || (!location && !currentGroup?.members.some((member) => member.kind === 'device'
+ && member.key === selected.memberKey && member.agentDeviceId === selected.agentDeviceId
+ && member.providerId === selected.providerId))) {
+ throw new Error('Provider share access changed');
+ }
+ };
+ const { invoke } = groupRelay.connect(selected.agentDeviceId);
+ const caps = await RemoteAgentRunClient.caps(invoke);
+ assertCurrent();
+ if (!caps.directGuestExecution || !caps.guestRelay) {
+ if ('load' in selected) selected.load?.release();
+ return null;
+ }
+ const delegation = { shareId: peer.shareId, memberId: peer.memberId,
+ guestDeviceId: peer.deviceId, executorDeviceId: selected.agentDeviceId };
+ return await withDelegationGrant(JSON.stringify([delegation.shareId, delegation.memberId,
+ delegation.guestDeviceId, delegation.executorDeviceId]), async () => {
+ const ownerDeviceId = getSelfDeviceId();
+ if (!ownerDeviceId) {
+ if ('load' in selected) selected.load?.release();
+ return null;
+ }
+ const ownerScope = providerShareOwnerKey();
+ const cleaned = await settlePendingDirectCleanup(delegation, invoke);
+ assertCurrent();
+ if (getSelfDeviceId() !== ownerDeviceId || providerShareOwnerKey() !== ownerScope) {
+ throw new Error('Provider share owner changed');
+ }
+ const effectiveOld = directRoutes.get(routeKey) === old ? old : undefined;
+ const effectiveRetained = !!(retained && effectiveOld && !cleaned);
+ const previousReceipt = effectiveOld?.executorDeviceId === selected.agentDeviceId
+ ? usage.listActiveDirectReceiptRoutes(providerShareOwnerKey()).find((saved) =>
+ saved.ownerDeviceId === ownerDeviceId && saved.shareId === peer.shareId
+ && saved.memberId === peer.memberId && saved.guestDeviceId === peer.deviceId
+ && saved.sessionId === request.sessionId && saved.executorDeviceId === selected.agentDeviceId
+ && saved.generation === effectiveOld.generation && saved.committedAt !== undefined)
+ : undefined;
+ // The executor checks this server grant before installing a local
+ // guest lease. Never lengthen its lease ahead of server confirmation.
+ const granted = await grantProviderShareDelegation(delegation);
+ const receiptRoute = {
+ ownerScope, ownerDeviceId,
+ memberJoinedAt: joinedAt,
+ ...delegation, sessionId: request.sessionId, agentKind: request.agentKind,
+ executorProviderId: selected.providerId,
+ providerId: access.providerId, memberKey: selected.memberKey,
+ model: request.model, generation: granted.generation, expiresAt: granted.expiresAt,
+ };
+ let memberGrantAttempted = false;
+ try {
+ await verifyProviderShareMemberGeneration({ ...delegation, joinedAt });
+ assertCurrent();
+ // Persist a provisional route before M can execute. A crash before
+ // commit leaves recovery enough information to revoke M's lease.
+ const cleanupEpoch = await usage.registerDirectReceiptRoute(receiptRoute);
+ // M authenticates O against the server pair grant and persists the
+ // policy before its task lease can admit a guessed/reused task ID.
+ await bindGroupFastPolicy({ group: access.providerId, deviceId: selected.agentDeviceId,
+ sessionId: request.sessionId,
+ providerShareGuest: { shareId: peer.shareId, memberId: peer.memberId, guestDeviceId: peer.deviceId } });
+ assertCurrent();
+ memberGrantAttempted = true;
+ await invoke([{ op: 'delegate', action: 'grant', shareId: peer.shareId,
+ memberId: peer.memberId, guestDeviceId: peer.deviceId, providerId: selected.providerId,
+ model: request.model, sessionId: request.sessionId, generation: granted.generation, cleanupEpoch }]);
+ assertCurrent();
+ await usage.commitDirectReceiptRoute(receiptRoute);
+ assertCurrent(receiptRoute.generation);
+ assertCommittedDirectRoute(receiptRoute);
+ if (effectiveOld && !effectiveRetained) {
+ if (effectiveOld.executorDeviceId !== selected.agentDeviceId) revokeDirectRoute(routeKey, effectiveOld);
+ else effectiveOld.load?.release();
+ }
+ const load = ('load' in selected ? selected.load : effectiveRetained ? effectiveOld?.load : undefined)
+ ?? groupRelay.trackRun(access.providerId, selected.memberKey);
+ if (!effectiveRetained) load.setRunning(false);
+ directRoutes.set(routeKey, { ...delegation, providerId: selected.providerId,
+ groupProviderId: access.providerId, memberKey: selected.memberKey,
+ agentKind: request.agentKind, model: request.model, sessionId: request.sessionId,
+ expiresAt: granted.expiresAt, generation: granted.generation,
+ load, lastStatusAt: effectiveRetained ? effectiveOld!.lastStatusAt : Date.now() });
+ if (previousReceipt) await retireDirectReceiptRoutes([previousReceipt]);
+ assertCurrent(receiptRoute.generation);
+ assertCommittedDirectRoute(receiptRoute);
+ return { deviceId: selected.agentDeviceId, generation: granted.generation,
+ leaseDurationMs: Math.min(30 * 60_000, Math.max(0, Math.floor(granted.expiresAt - Date.now()))) };
+ } catch (error) {
+ dropLiveDirectReceiptRoute(receiptRoute);
+ // M's new grant may have replaced an active A lease. Re-grant A with
+ // a fresh server generation, keeping its run alive and its journal
+ // current. This also rolls back a failed B model authorization.
+ let previousRestored = false;
+ if (previousReceipt && previousDirectRouteAllowed(previousReceipt)) {
+ try {
+ const restored = await restorePreviousDirectGrant(previousReceipt);
+ if (effectiveOld && directRoutes.get(routeKey) === effectiveOld) directRoutes.set(routeKey, {
+ ...effectiveOld, generation: restored.generation, expiresAt: restored.expiresAt,
+ });
+ await retireDirectReceiptRoutes([previousReceipt, receiptRoute]);
+ previousRestored = true;
+ } catch (restoreError) {
+ log.warn('provider group previous direct route restoration failed', {
+ executorDeviceId: selected.agentDeviceId, error: String(restoreError),
+ });
+ }
+ }
+ if (previousRestored) throw error;
+ // M may never have accepted the new grant. Quarantine O's old route
+ // until a fresh grant confirms its state, without revoking g1's
+ // committed evidence merely because g2 was sent.
+ if (previousReceipt) dropLiveDirectReceiptRoute(previousReceipt);
+ else if (effectiveOld && effectiveOld.executorDeviceId === selected.agentDeviceId
+ && directRoutes.get(routeKey) === effectiveOld) {
+ directRoutes.delete(routeKey);
+ effectiveOld.load?.release();
+ directSwitchIssued.delete(routeKey);
+ }
+ const revoked = await Promise.allSettled([
+ invoke([{ op: 'delegate', action: 'revoke', shareId: peer.shareId,
+ memberId: peer.memberId, guestDeviceId: peer.deviceId, providerId: selected.providerId,
+ model: request.model, sessionId: request.sessionId, generation: granted.generation }]),
+ revokeUnusedDirectPair(receiptRoute),
+ ]);
+ if (revoked.every((result) => result.status === 'fulfilled')) {
+ if (memberGrantAttempted && previousReceipt && previousDirectRouteAllowed(previousReceipt)) {
+ // g2 could have missed M entirely. Keep the provisional marker
+ // so restart/reconciliation retries g1 without advertising it.
+ log.warn('provider group previous direct route restoration will retry', {
+ executorDeviceId: selected.agentDeviceId,
+ });
+ } else {
+ try {
+ if (memberGrantAttempted && previousReceipt) {
+ await usage.markDirectReceiptRouteRevoked(previousReceipt);
+ }
+ await usage.markDirectReceiptRouteRevoked(receiptRoute);
+ } catch (revokeError) {
+ log.warn('provider group direct route journal revocation will retry', {
+ error: String(revokeError),
+ });
+ }
+ }
+ } else {
+ log.warn('provider group failed allocation revocation will retry', {
+ executorDeviceId: selected.agentDeviceId,
+ });
+ }
+ throw error;
+ }
+ });
+ } catch (error) {
+ if ('load' in selected) selected.load?.release();
+ log.warn('provider group direct allocation failed', { error: String(error) });
+ return null;
+ }
+ } finally {
+ if (allocations.get(routeKey) === turn) allocations.delete(routeKey);
+ finish();
+ if (reconcileAfterAllocation) {
+ reconcileAfterAllocation = false;
+ void reconcileDirectJournal();
+ }
+ }
+ },
+ status(controller, request) {
+ const route = restoreDirectRoute(controller, request.sessionId);
+ if (!route || route.expiresAt <= Date.now() || !ownedProviderShareGuestAccess(controller)) return;
+ route.load?.setRunning(request.running);
+ route.lastStatusAt = Date.now();
+ },
+ async release(controller, request) {
+ const peer = parseProviderSharePeer(controller);
+ const ownerDeviceId = getSelfDeviceId();
+ if (peer?.role !== 'guest' || !ownerDeviceId) return;
+ const key = JSON.stringify([controller, request.sessionId]);
+ // A failed g1 open can report after g2 has already been allocated.
+ // Serialize with allocation before comparing the durable generation.
+ while (allocations.has(key)) await allocations.get(key);
+ let finish!: () => void;
+ const turn = new Promise<void>((resolve) => { finish = resolve; });
+ allocations.set(key, turn);
+ try {
+ const ownerScope = providerShareOwnerKey();
+ const current = () => usage.listActiveDirectReceiptRoutes(ownerScope)
+ .filter((route) => route.ownerDeviceId === ownerDeviceId
+ && route.shareId === peer.shareId && route.memberId === peer.memberId
+ && route.guestDeviceId === peer.deviceId && route.sessionId === request.sessionId);
+ const candidate = current().at(-1);
+ if (!candidate || candidate.committedAt === undefined
+ || candidate.generation !== request.generation) return;
+ const linkKey = JSON.stringify([peer.shareId, peer.memberId, peer.deviceId,
+ candidate.executorDeviceId]);
+ await withDelegationGrant(linkKey, async () => {
+ const routes = current();
+ const saved = routes.at(-1);
+ if (!saved || saved.committedAt === undefined || saved.generation !== request.generation
+ || ownerScope !== providerShareOwnerKey() || ownerDeviceId !== getSelfDeviceId()) return;
+ // The journal is the restart boundary. A failed write leaves the
+ // assignment intact so reconciliation can still find it.
+ for (const route of routes) await usage.markDirectReceiptRouteRevoked(route);
+ await revokeRetiredDirectReceiptRoutes(key, routes);
+ });
+ } finally {
+ if (allocations.get(key) === turn) allocations.delete(key);
+ finish();
+ }
+ },
+ switch(controller, request) {
+ const key = JSON.stringify([controller, request.sessionId]);
+ const pending = directSwitchPending.get(key);
+ if (pending) return pending;
+ if (allocations.has(key)) return Promise.resolve({});
+ const current = restoreDirectRoute(controller, request.sessionId);
+ const previous = directSwitchIssued.get(key);
+ if (current && previous?.generation === current.generation && Date.now() - previous.at < 2 * 60_000
+ && ownedProviderShareGuestAccess(controller) && current.expiresAt > Date.now()
+ && remoteModelAccess.allowsDelegatedExecution(current.groupProviderId, current.model, current.memberId)
+ && readProviderGroup(current.groupProviderId)?.autoSwitch === true
+ && liveDirectTargetAllowed(current)) {
+ return Promise.resolve({ token: previous.token });
+ }
+ const lastAttempt = directSwitchAttempts.get(key) ?? 0;
+ if (Date.now() - lastAttempt < 10_000 || directSwitchPending.size >= 32) return Promise.resolve({});
+ directSwitchAttempts.set(key, Date.now());
+ for (const [id, at] of directSwitchAttempts) {
+ if (Date.now() - at >= 2 * 60_000) directSwitchAttempts.delete(id);
+ }
+ if (directSwitchAttempts.size > 512) directSwitchAttempts.delete(directSwitchAttempts.keys().next().value!);
+ const work = (async (): Promise<{ token?: string }> => {
+ const peer = parseProviderSharePeer(controller);
+ const route = directRoutes.get(key);
+ if (peer?.role !== 'guest' || !route || route.expiresAt <= Date.now()
+ || route.shareId !== peer.shareId || route.memberId !== peer.memberId
+ || route.guestDeviceId !== peer.deviceId) return {};
+ const valid = () => {
+ const live = directRoutes.get(key);
+ const access = ownedProviderShareGuestAccess(controller);
+ const group = readProviderGroup(route.groupProviderId);
+ return live === route && route.expiresAt > Date.now()
+ && access?.providerId === route.groupProviderId
+ && isRemoteProviderInvocationAllowed(route.groupProviderId)
+ && remoteModelAccess.allowsDelegatedExecution(route.groupProviderId, route.model, route.memberId)
+ && group?.autoSwitch === true
+ && liveDirectTargetAllowed(route);
+ };
+ if (!valid()) return {};
+ const issued = directSwitchIssued.get(key);
+ if (issued?.generation === route.generation && Date.now() - issued.at < 2 * 60_000) {
+ return { token: issued.token };
+ }
+ for (const [id, item] of directSwitchIssued) {
+ if (Date.now() - item.at >= 2 * 60_000) directSwitchIssued.delete(id);
+ }
+ if (directSwitchIssued.size >= 512) return {};
+ // The guest's error is only a request to move its own task. It never
+ // cools an executor or changes group health without an owner-side signal.
+ const group = readProviderGroup(route.groupProviderId);
+ const exclude = new Set(group?.members.filter((member) => member.kind === 'device'
+ && member.agentDeviceId === route.executorDeviceId).map((member) => member.key) ?? [route.memberKey]);
+ const next = await groupRelay.plan({ kind: route.agentKind as 'claude-code' | 'codex' | 'pi',
+ model: route.model, providerId: route.groupProviderId,
+ exclude }).catch(() => null);
+ const canMove = next?.kind === 'member' || (next?.kind === 'local'
+ && options.getMaker().listAvailableAgents().includes(route.agentKind as 'claude-code' | 'codex' | 'pi'));
+ if (!valid() || !next || !canMove || (next.kind === 'member' && exclude.has(next.memberKey))) return {};
+ const token = host?.issueDirectGroupSwitchToken(controller, request.sessionId,
+ exclude);
+ if (!token) return {};
+ directSwitchIssued.set(key, { generation: route.generation,
+ executorDeviceId: route.executorDeviceId, at: Date.now(), token });
+ return { token };
+ })().finally(() => { directSwitchPending.delete(key); });
+ directSwitchPending.set(key, work);
+ return work;
+ },
+ async switched(controller, sessionId, token) {
+ const key = JSON.stringify([controller, sessionId]);
+ while (allocations.has(key)) await allocations.get(key);
+ let finish!: () => void;
+ const turn = new Promise<void>((resolve) => { finish = resolve; });
+ allocations.set(key, turn);
+ try {
+ const peer = parseProviderSharePeer(controller);
+ const issued = directSwitchIssued.get(key);
+ if (peer?.role !== 'guest' || !issued || issued.token !== token) return;
+ const delegation = { shareId: peer.shareId, memberId: peer.memberId,
+ guestDeviceId: peer.deviceId, executorDeviceId: issued.executorDeviceId };
+ const ownerScope = providerShareOwnerKey();
+ const ownerDeviceId = getSelfDeviceId();
+ if (!ownerDeviceId) throw new Error('Provider share owner is unavailable');
+ await withDelegationGrant(JSON.stringify([delegation.shareId, delegation.memberId,
+ delegation.guestDeviceId, delegation.executorDeviceId]), async () => {
+ if (directSwitchIssued.get(key) !== issued) return;
+ const sameTaskRoutes = usage.listActiveDirectReceiptRoutes(ownerScope)
+ .filter((route) => route.ownerDeviceId === ownerDeviceId
+ && route.shareId === delegation.shareId && route.memberId === delegation.memberId
+ && route.guestDeviceId === delegation.guestDeviceId && route.sessionId === sessionId);
+ const routes = sameTaskRoutes
+ .sort((a, b) => (a.createdAt ?? 0) - (b.createdAt ?? 0));
+ const live = directRoutes.get(key);
+ const location = directTaskContext(controller, sessionId).location;
+ if ((live && (live.generation !== issued.generation
+ || live.executorDeviceId !== issued.executorDeviceId))
+ || (sameTaskRoutes.length && sameTaskRoutes.at(-1)?.generation !== issued.generation)
+ || (location && location.generation !== issued.generation)
+ || providerShareOwnerKey() !== ownerScope || getSelfDeviceId() !== ownerDeviceId) {
+ throw new Error('Provider share direct assignment changed during switch');
+ }
+ // Disk is the restart boundary. A failed write leaves the token and
+ // live route intact, so this open fails and can retry with the token.
+ for (const route of routes) await usage.markDirectReceiptRouteRevoked(route);
+ if (location && !await usage.markDirectTaskRelayed(location, issued.generation)) {
+ throw new Error('Provider share direct assignment changed during switch');
+ }
+ void revokeRetiredDirectReceiptRoutes(key, routes);
+ directSwitchAttempts.delete(key);
+ });
+ } finally {
+ if (allocations.get(key) === turn) allocations.delete(key);
+ finish();
+ }
+ },
+ sessionAllowed: (controller, sessionId) => ownedProviderShareGuestAccess(controller) !== null
+ || delegatedProviderShareSessionAllowed(controller, sessionId),
+ sessionDelegated: (controller, sessionId) => delegatedProviderShareTaskAccess(controller, sessionId) !== null,
+ async usage(controller, request) {
+ const ownerDeviceId = getSelfDeviceId();
+ if (!ownerDeviceId) throw new Error('REMOTE_AGENT_INVALID');
+ await usage.recordDirectReceipt(providerShareOwnerKey(), ownerDeviceId, controller, request);
+ },
+ delegate(controller, request) { return applyProviderShareDelegation(controller, request); },
+ forget: revokeDelegatedProviderShareGuest,
+ },
// 转分享(本机是分享者):受邀者的组替它分享的人转来的任务,只在本机主人同意过那个人时运行。
- reshare: { sync: handleProviderShareReshare, allows: providerShareReshareAllows },
+ reshare: { canUse: (controller) => ownedProviderShareGuestAccess(controller) !== null,
+ sync: handleProviderShareReshare, allows: providerShareReshareAllows },
captureOwner: captureDataOwnerBroadcastScope,
isOwnerCurrent: (owner) => isDataOwnerBroadcastScopeCurrent(owner as DataOwnerBroadcastScope),
runsRoot: path.join(options.userDataDir, 'remote-agent'),
log,
});
const current = host;
+ const purgeMemberControllers = createProviderShareMemberPurger({
+ userDataDir: options.userDataDir, usage, current,
+ ownerScope: providerShareOwnerKey, ownerDeviceId: getSelfDeviceId,
+ isCurrent: () => host === current, hasAccess: (controller) => ownedProviderShareGuestAccess(controller) !== null,
+ });
stopFastPolicySync = startGroupFastPolicySync();
setRemoteAgentHandler({
handle: (controller, raw) => current.handle(controller, raw),
@@ -274,7 +1452,7 @@ export function installRemoteAgentHost(options: { getMaker: () => Maker; userDat
abortControllers: (match) => current.abortControllers(match),
revalidateModelAccess: () => current.revalidateModelAccess(),
abortReshare: (match, reshareKey) => current.abortReshare(match, reshareKey),
- purgeControllers: (match) => current.purgeControllers(match),
+ purgeControllers: purgeMemberControllers,
activeControllers: () => current.activeControllers(),
limitUsage: () => current.limitUsage(),
turnRunningControllers: () => current.turnRunningControllers(),
@@ -293,11 +1471,24 @@ export function resolveRemoteAgentHostClaudeSessionId(sdkSessionId: string): str
/** 退出时结束全部远程 Agent 任务。 */
export function disposeRemoteAgentHost(): void {
+ if (delegationCheckTimer) clearInterval(delegationCheckTimer);
+ delegationCheckTimer = undefined;
+ if (directRouteSweep) clearInterval(directRouteSweep);
+ directRouteSweep = undefined;
+ stopDirectRouteWatch?.();
+ stopDirectRouteWatch = undefined;
+ stopDirectModelWatch?.();
+ stopDirectModelWatch = undefined;
+ stopDirectGroupWatch?.();
+ stopDirectGroupWatch = undefined;
+ stopDirectSettingsWatch?.();
+ stopDirectSettingsWatch = undefined;
stopFastPolicySync?.();
stopFastPolicySync = undefined;
setRemoteAgentHandler(null);
host?.dispose();
host = null;
+ clearProviderShareDelegations();
void flushProviderShareUsage();
}
diff --git a/apps/desktop/src/main/remote-desktop/__tests__/captureWindow.test.ts b/apps/desktop/src/main/remote-desktop/__tests__/captureWindow.test.ts
index f8cd927735..49112bc581 100644
--- a/apps/desktop/src/main/remote-desktop/__tests__/captureWindow.test.ts
+++ b/apps/desktop/src/main/remote-desktop/__tests__/captureWindow.test.ts
@@ -2,6 +2,7 @@ import { EventEmitter } from 'node:events';
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
import { DesktopCaptureWindow } from '../captureWindow';
import { denyAppDesktopCapture, markPlaybackFullscreenWindow } from '../capturePermissions';
+import { isCaptureWindowWebContents } from '../captureWindowRegistry';
import { buildContentSecurityPolicy } from '../../security/csp';
const fake = vi.hoisted(() => ({
@@ -30,6 +31,7 @@ vi.mock('electron', () => ({
mainFrame: { url: '', parent: null },
isDestroyed: () => this.destroyed,
setWindowOpenHandler: vi.fn(),
+ setWebRTCIPHandlingPolicy: vi.fn(),
});
constructor(public options: any) {
fake.windows.push(this);
@@ -100,7 +102,12 @@ it('only admits the registered top frame and kills the whole process on stop', a
},
});
expect(win.webContents.setWindowOpenHandler.mock.calls[0][0]()).toEqual({ action: 'deny' });
+ expect(win.webContents.setWebRTCIPHandlingPolicy).not.toHaveBeenCalled();
+ expect(isCaptureWindowWebContents(win.webContents)).toBe(true);
owner.dispose();
+ // Unit regression: native gone may reach app after local destroyed cleanup.
+ // Keep this factory's identity so a capture crash cannot tear down device-link.
+ expect(isCaptureWindowWebContents(win.webContents)).toBe(true);
expect(win.destroyed).toBe(true);
expect(owner.contents).toBeNull();
expect(() => owner.assertSender(valid)).toThrow('PERMISSION_DENIED');
@@ -274,6 +281,16 @@ it.each(['files', 'direct'] as const)('keeps %s transport separate and denies ca
const owner = new DesktopCaptureWindow(vi.fn(), mode);
const ready = owner.start();
const win = fake.windows[0], ses = fake.sessions[0];
+ expect(isCaptureWindowWebContents(win.webContents)).toBe(true);
+ // Unit regression: routed private networks cannot resolve Chromium's default
+ // mDNS candidates. Exercise the real window factory: opt in only the direct
+ // data window, before navigation, without granting media or changing files/video.
+ // Actual ICE and byte transfer are covered by provider-share-direct-smoke.mjs.
+ if (mode === 'direct') {
+ expect(win.webContents.setWebRTCIPHandlingPolicy).toHaveBeenCalledExactlyOnceWith('default_public_and_private_interfaces');
+ expect(win.webContents.setWebRTCIPHandlingPolicy.mock.invocationCallOrder[0])
+ .toBeLessThan(win.loadURL.mock.invocationCallOrder[0]);
+ } else expect(win.webContents.setWebRTCIPHandlingPolicy).not.toHaveBeenCalled();
expect(win.webContents.mainFrame.url).toBe(`http://localhost:9988/index.html?mode=${mode}`);
owner.registered(event(win));
await ready;
diff --git a/apps/desktop/src/main/remote-desktop/captureWindow.ts b/apps/desktop/src/main/remote-desktop/captureWindow.ts
index 3689d59e55..b431f62265 100644
--- a/apps/desktop/src/main/remote-desktop/captureWindow.ts
+++ b/apps/desktop/src/main/remote-desktop/captureWindow.ts
@@ -4,6 +4,7 @@ import { REMOTE_DESKTOP_OFFER_BUDGET } from '@cindy/device-link';
import { readFile } from 'node:fs/promises';
import { installContentSecurityPolicy, parseOrigin } from '../security/csp';
import { throwIpcError } from '../utils/ipcValidate';
+import { markCaptureWindowWebContents } from './captureWindowRegistry';
declare const DESKTOP_CAPTURE_VITE_DEV_SERVER_URL: string | undefined;
declare const DESKTOP_CAPTURE_VITE_NAME: string;
@@ -159,6 +160,14 @@ export class DesktopCaptureWindow {
},
});
this.window = win;
+ markCaptureWindowWebContents(win.webContents);
+ if (this.mode === 'direct') {
+ // This data-only window signals exclusively to already authorized peers.
+ // Chromium's default mDNS host names cannot resolve across routed LANs.
+ // Expose the default route's address without enumerating other interfaces,
+ // granting media permissions, or changing the SDP's ICE/DTLS credentials.
+ win.webContents.setWebRTCIPHandlingPolicy('default_public_and_private_interfaces');
+ }
const failed = () => {
if (this.window !== win) return;
this.dispose();
diff --git a/apps/desktop/src/main/remote-desktop/captureWindowRegistry.ts b/apps/desktop/src/main/remote-desktop/captureWindowRegistry.ts
new file mode 100644
index 0000000000..80a9a0b2de
--- /dev/null
+++ b/apps/desktop/src/main/remote-desktop/captureWindowRegistry.ts
@@ -0,0 +1,13 @@
+import type { WebContents } from 'electron';
+
+// Keep identity through destroyed/gone event ordering without retaining windows.
+// Only the main-owned capture factory can register these isolated renderers.
+const captureContents = new WeakSet<WebContents>();
+
+export function markCaptureWindowWebContents(contents: WebContents): void {
+ captureContents.add(contents);
+}
+
+export function isCaptureWindowWebContents(contents: WebContents): boolean {
+ return captureContents.has(contents);
+}
diff --git a/apps/mobile/src/device-link/DeviceLinkContext.tsx b/apps/mobile/src/device-link/DeviceLinkContext.tsx
index 0f57ad8834..732d63f8bf 100644
--- a/apps/mobile/src/device-link/DeviceLinkContext.tsx
+++ b/apps/mobile/src/device-link/DeviceLinkContext.tsx
@@ -2096,8 +2096,8 @@ const CONNECT_READY_TIMEOUT_MS = 1_500;
// 发请求前确保连接就绪:online 直接放行;否则促成立即重连并有界等待上线,
// 超时抛 NOT_CONNECTED(transient)交由上层重试 —— 把"等整个退避 gap"压成"等一次重连"。
-function ensureOnlineForRequest(client: DeviceLinkClient): Promise<void> {
- if (client.getStatus() === 'online') return Promise.resolve();
+function ensureOnlineForRequest(client: DeviceLinkClient, deviceId?: string): Promise<void> {
+ if (client.getStatus() === 'online' || (deviceId && client.hasOfflineDirectPath(deviceId))) return Promise.resolve();
return client.waitUntilOnline(CONNECT_READY_TIMEOUT_MS);
}
@@ -2190,7 +2190,7 @@ async function sendInvoke<T>(
allowProbe: opts?.allowProbe,
});
try {
- await ensureOnlineForRequest(client);
+ await ensureOnlineForRequest(client, deviceId);
// 连接就绪后先检查一次:重连等待期间调用方状态可能已失效
// (写被同字段新写取代),抛错即中止发送。
opts?.preSend?.();
@@ -2273,7 +2273,7 @@ async function sendSubscribe(
// subscribe 同样走隧道请求超时等待(默认 15s),一样计入并受熔断限制(见 sendInvoke 注释)。
const slot = acquireDeviceSendSlot(deviceId);
try {
- await ensureOnlineForRequest(client);
+ await ensureOnlineForRequest(client, deviceId);
} catch (err) {
settleDeviceSend(deviceId, slot, 'inconclusive');
throw err;
@@ -2318,7 +2318,7 @@ async function sendUnsubscribe(
): Promise<void> {
const slot = acquireDeviceSendSlot(deviceId);
try {
- await ensureOnlineForRequest(client);
+ await ensureOnlineForRequest(client, deviceId);
} catch (err) {
settleDeviceSend(deviceId, slot, 'inconclusive');
throw err;
diff --git a/docs/dev-rules/desktop-development.md b/docs/dev-rules/desktop-development.md
index ccbf61f2ce..c3fb75e852 100644
--- a/docs/dev-rules/desktop-development.md
+++ b/docs/dev-rules/desktop-development.md
@@ -76,6 +76,16 @@ checkout 占用而中止,不要换命令绕过,应把 verdict 交给用户
## 可选启动参数
+只调试本机设备互联服务、仍使用真实账号登录时,保持 `restart:desktop:remote`,
+仅在本次启动环境按账号区域设置 `XDT_DEVICE_LINK_CN_LOCAL_URL=http://127.0.0.1:<端口>`
+和/或 `XDT_DEVICE_LINK_GLOBAL_LOCAL_URL=http://127.0.0.1:<另一个端口>`。
+此覆盖只供未打包的开发版使用,只接受带显式端口、无凭据/路径的 IPv4/IPv6 回环地址,
+仅作用于对应区域的当前会话及按区域读取的设备互联端点。旧 `XDT_DEVICE_LINK_LOCAL_URL`
+只作为 CN 的兼容别名,不能把 Global Access Token 发往 CN 服务。正式版忽略这些覆盖;认证、SSO 双区发现、
+模型与其他服务仍按原清单和账号区域运行。跨电脑可使用经明确授权的临时回环隧道。
+不要为只替换设备互联服务而启动完整 `local` 模式:它会把两个账号区域固定到同一套
+本机服务,不能承载真实双区企业 SSO。
+
两个 restart 命令都支持下列参数。不加任何模式旗标时默认走固定的 `--isolated=dev`
命名沙箱;要回到旧的共库行为必须显式加 `--shared`。这些参数只对 dev 生效,不影响
用户机器上的正式版。
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 8fdb434466..b9f9f475ed 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -1646,6 +1646,13 @@ handler 无 sender 依赖;不加入共享任务访客白名单,不进入自
## 远程 Agent:Agent 在另一台电脑运行
+供应商分享 `allocate` 成功响应可选追加 `leaseDurationMs`,由 O 在回复前按服务端已批准期限计算
+剩余毫秒,最大 30 分钟,不是给 G 重新批准一次完整许可。G 从请求发出时的单调时钟保守计时,
+新建和恢复任务都使用该期限;续权成功才替换期限。到期只结束该任务的本地执行资源,远端 close
+无法交付也不等待普通断链的两分钟重试;不关闭共享 WebSocket、不重放请求、不换执行电脑。
+旧 G 忽略新增字段;旧 O 缺字段时新 G 沿用原 30 分钟合同,M 仍为最终许可闸门。
+字段存在但无效时拒绝把它用作任务授权;此增量不更改 `maker:remote-agent:v1` 或服务端请求格式。
+
共享模型分叉追加 `caps.nativeFork: true` 与 `op: fork`,仍使用
`maker:remote-agent:v1`,不改变 relay、版本号或服务端。控制端先协商能力;旧运行端
缺少能力时明确提示更新,不把历史复制成没有原生上下文的本地任务。旧控制端忽略新增能力。
diff --git a/docs/dev-rules/remote-and-mobile-adaptation.md b/docs/dev-rules/remote-and-mobile-adaptation.md
index f3ffb9bf2b..f89c6b1bce 100644
--- a/docs/dev-rules/remote-and-mobile-adaptation.md
+++ b/docs/dev-rules/remote-and-mobile-adaptation.md
@@ -254,6 +254,22 @@ relay 以 close 1013 `inbound backpressure` 主动断连,此时任何「立即
**托管 Codex 启动的跨机往返与执行环境恢复**(2026-10-22 远程供应商调查:启动 277 次串行文件操作、每次跨机
0.5–3s,启动几分钟、撞 5 分钟上限;握手失败后「能聊天但没有 Shell 与文件工具」):
+- **POSIX Agent → Windows 执行端的沙箱实现**(2026-10-28 真机):固定 Codex 0.159.2
+ 从 macOS 发出受限权限时携带 `windowsSandboxLevel=disabled`,Windows 原生 exec-server
+ 因无法落实沙箱意图拒绝所有命令。控制端只把这种跨平台、`permissions.type=managed` 的
+ disabled 选择映射为 Windows 原生 `restricted-token`;权限条目、网络设置、Cindy 本机授权
+ 闸门均保持原值,显式 Windows 选择和非受限请求不改。原生实现不能落实 deny-read 等规则时
+ 仍拒绝整个请求,不删规则、不转无沙箱、不重放命令,不安装 MXC、创建系统账号或改防火墙。
+ 这是 Windows 原生受限令牌的边界,不声称其网络隔离等同 macOS:网络约束沿用该原生实现。
+ 故障只影响这个任务的执行请求,不重启 device-link、不撤下其它 peer。回归见
+ `remote-agent/__tests__/execServerProjection.e2e.test.ts` 的真实原生进程及
+ `executor/__tests__/virtualWorkspace.test.ts`;临时文件和权限验证均限制在测试目录。
+ Windows 的 Store/MSIX PowerShell 无法在受限令牌下启动(真机 `CreateProcessAsUserW`
+ 错误 `-1073283067`)。同一跨平台适配只在原生声明此类 Shell 时,优先宣告现存的
+ 非 Store PowerShell 7,否则使用现存的系统 Windows PowerShell;先解析真实路径排除
+ 指回 Store 的别名。没有替代时保留原声明并明确失败,不改系统 PATH、不下载或安装 Shell,
+ 不改用户显式命令及其它 Agent 的 Shell。原生回归必须按 initialize 宣告的 Shell 真正执行。
+
- **不可能存在的路径在 Agent 所在电脑直接回答**(`host/execServerShortcut.ts`):Codex 沿工作目录逐级向上找
`.git`、Skill 目录与插件清单。镜像根内的虚拟垫层(真实根目录以上的 `workspace/p/…`)及镜像根本身在任务电脑没有
对应目录(已映射的工作区及真实上级、`home`、`tmp`、`additional` 除外,见 `controller/startRemote.ts` 的
diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.md
index 06bb03618f..fe38568c6f 100644
--- a/docs/product-rules/provider-groups.md
+++ b/docs/product-rules/provider-groups.md
@@ -4,6 +4,9 @@
> 2026-10-12 用户要求:受邀者能查看组内电脑的**匿名状态**,便于判断分享不可用的原因;不显示真实电脑名、设备标识或用量,见 §8、§10。
> 2026-10-10 用户确认:同账号其他电脑经组使用时**直接连到选中的组内电脑**(不经组所在电脑中转),
> 分享的人仍经组所在电脑中转;被组收进去的远程供应商与分享,在同账号其他电脑上只显示组那一项。
+> 2026-10-27 新目标:跨账号受邀者在组完成分配与短期授权后,优先直连选中的执行电脑,失败回退现有中转;
+> 见[受邀者与执行电脑直连](provider-sharing-direct-execution.md)。下文的「分享的人(中转)」描述当前已上线实现,
+> 新路线通过端到端验收前继续有效。
> 2026-10-10 用户确认:分享来的组内电脑按**本账号在那台实际跑着的任务数**统计(含不经组直接用的),见 §5。
> 2026-10-10 用户确认:建组的电脑要看到组里每台在跑几个任务;本机与同账号电脑按**那台这个供应商实际在跑的任务总数**
> 统计(含自己用的、不经组的与替分享的人跑的),见 §5。
@@ -429,7 +432,7 @@
可以手动换模型。具体做法:
- 任务所在的电脑打开任务时声明支持(可选字段 `acceptsGroupSwitch`)。组内电脑(包括组所在电脑本机)上的任务因 §6.1 列出的原因
失败(终态错误,或一轮进行中那台的任务意外结束)时,组所在电脑先按组的口径冷却那台,再看组里还有没有能接的
- 电脑(这一轮已经换下来的不算);有就在事件流里先发一张一次性凭证,再转出原来的错误。旧版本、没有能接的
+ 电脑(这一轮已经换下来的不算);有就在事件流里先发一张短期凭证,再转出原来的错误。凭证只认该受邀者与任务,失败重开可在有效期内重用;旧版本、没有能接的
电脑、或换到哪台都一样的失败,只转出原来的错误。
- 任务所在的电脑只在持有这张凭证时才换:分享被暂停、删除、撤权是分享本身的问题,没有凭证,不会触发换电脑。
凭证只用于紧随其后的那次错误(2 分钟内);用户亲自接手(发消息、重试、换模型)即作废。
diff --git a/docs/product-rules/provider-sharing-direct-execution.md b/docs/product-rules/provider-sharing-direct-execution.md
new file mode 100644
index 0000000000..9c95095d20
--- /dev/null
+++ b/docs/product-rules/provider-sharing-direct-execution.md
@@ -0,0 +1,200 @@
+# 供应商分享:受邀者与执行电脑直连
+
+> 2026-10-27 用户确认的方向:能直连就尝试直连,连不上走 device-link;组所在电脑负责分配和授权,
+> 任务内容直接在受邀者与执行电脑之间传输。本文记录本次实现及上线前仍需验证的边界。
+
+## 路由
+
+受邀者电脑为 G,分享与组所在电脑为 O,本次执行电脑为 M。G 的任务仍记录为 `share:<shareId>`。
+
+1. G 在任务启动前向 O 发 `remote-agent/allocate`,只传 Agent、模型和任务 ID。O 用现有组策略选电脑。
+ 历史任务先发 `direct-locate {sessionId}`:O 按当前账号、分享、已批准成员、G 设备和任务查询持久位置,
+ 返回 `{deviceId}` 或表示旧 O 路径的 `null`。位置不授予执行权限;G 必须指定该 M 重新 `allocate`,
+ 确认返回同一 M 后才能发送原生会话 ID。O 即使在 30 分钟回执过期并重启后,也只为原 M 重新授权;
+ M 不可达、被撤权或不支持所需能力时失败,不按新任务策略改选 M2。已在 O 托管的旧任务没有直连位置,继续旧路径。
+ 重新授权后,G 经该分享原有区域的 relay 确认与原 M 的链路,再探测能力和发送历史;不凭本机缓存的
+ ready 状态判断 M 重启后的链路仍有效。只重开该 peer,不重连共享 WebSocket;授权等待期间用户
+ 主动断开该链路时,本次恢复取消,不替用户重新连接。
+2. 选到同账号、支持访客隔离与短期授权的 M 时,O 先向 device-link 服务端登记 30 分钟的
+ 委托路由,再把临时分配写入本地账本,然后经已认证的同账号链路给 M 安装内存许可。M 在安装前
+ 向服务端核对 O 身份、授权代次和期限。O 同时把组的 Fast 策略绑定到 M 上的实际任务,最后
+ 把分配标记为已提交;全部成功后才把本次 M 的设备 ID 回给 G。O 重启后会重试撤销未完成的分配。
+3. G 与 M 用已有 `providerShare` 链路建链。双方声明 `provider-share-direct-v1`,通过 device-link
+ 转发 WebRTC 信令,只尝试 host ICE candidate;WebRTC 成功后,远程 Agent 的请求、事件、
+ 文件和反向请求都经 G↔M。直连未建成或中途断开时,可靠传输层走 device-link **G↔M relay**,
+ 沿用同一个运行实例和幂等序号,不把内容改送 O。
+ 需要重新分配时,先确认 O 的分享链路;新授权提交后再确认 M 链路和能力,避免重启或重新批准后
+ 误用旧 ready 状态、等满请求超时才回退。仍有效的缓存路由不额外等待 O,恢复只作用于当前 peer。
+4. 选中 O、第三方分享来的组成员、旧客户端、旧服务端或授权失败时,沿用现有 G↔O↔M 路径。
+ G 对委托的 M 在任务打开前做能力探测;探测失败或探测后打开失败时也走旧路径,避免把任务交给不可达的 M。
+ 已返回给 G 的分配若在探测时失败,G 以授权代次向 O 尽力发送释放通知;若 M 已返回启动结果、
+ 随后的本机准备失败,G 先关闭 M 上的 run,再等待 O 的释放回执,才打开旧路径。O 只退役匹配该代的
+ 分配,迟到通知不得撤销同一任务的新授权。释放回执不清除历史位置;O 接受不带原生续接 ID 的
+ 新会话回退时,才持久清除直连位置并退役旧许可。清除落盘失败时拒绝本次打开,避免重启后回到旧 M。
+ 旧路径中的 G↔O 这一段也可能使用已有 WebRTC,但任务正文仍经过 O;它不等于 G↔M 直连。
+5. O 只收分配、续权和运行状态;G 每 30 秒向 O 报运行状态。O 重启后按持久分配恢复组负载,
+ 超过 150 秒未报告的任务不再计作忙碌。O 每分钟检查许可有效期与访问权限。原 M 移出新任务分配组后,
+ 已有任务仍尽力回原 M,且每次续权仍受分享审批、模型、远控开关、设备撤权和 M 本机授权约束。
+6. M 每轮只把模型和 token/金额计数作为用量回执送 O;回执有唯一 ID,O 落盘去重。
+ O 短暂断线时 M 在内存中重试;若 M 重启或 O 连续 30 分钟不可达,尚未送达的计数会丢失,
+ 因此不能把该用量统计用于精确计费。M 对许可到期或撤销后才到达的已完成轮次保留最多 5 分钟
+ 的**仅计费**依据;若执行器在关闭运行时未发出完成事件,或 O 的新授权已到 M、分配账本尚未提交
+ 就发生回滚,这段用量仍可能漏记。
+7. 直连运行中的 M 故障触发既有供应商组交接时,G 向 O 请求短期换机凭证。O 只为当前有效的
+ G/任务/分配签发,并按组策略选下一台;同一物理 M 的所有组成员在这一轮均被排除。G 重新打开
+ 后才把后续正文发往新执行电脑。凭证绑定受邀者和任务,失败重开可在有效期内重用;G 成功打开
+ 后释放本机凭证。O 不因 G 的故障报告冷却 M,且请求有短期限频。受邀者可主动
+ 请求自己任务的换机,故该请求不是 M 故障的可信证明;组健康度必须由 O 的独立信号决定。
+ O 接受仍有效且绑定该受邀者任务的换机凭证后,按授权代次持久清除旧 M 的任务位置并退役直连分配,避免以后重开时按旧账本
+ 又选回故障机;新电脑尚未打开成功时,同一凭证在有效期内仍可重试。
+
+## 授权
+
+- 启用成员模型用量比例限制时,新任务继续走 O 中转,由上游既有机制逐请求核对实时用量;
+ 离线直连许可不具备该能力。O 上修改此策略会退役该成员已有直连许可,仍保留原 M 的历史位置,
+ 不把原生历史迁往另一台电脑。该历史任务在策略关闭前不能重新直连;O 离线时撤权仍受原许可期限约束。
+ O 在提交分配后、向 G 回传前重新核对当前审批与预算等权限;提交期间限制变更时,撤销本代分配,
+ 不沿用最初快照继续放行。
+- device-link 服务端继续负责分享与成员身份、新 G 设备登记,以及 G↔M 的 relay 路由准入。
+ 服务端仅接受分享所在的 O 签发委托;每一跳重新验证分享、成员、G 设备、O、M 和 30 分钟许可。
+ 同账号登录只证明 O↔M 的账号关系,不能代替分享审批或访客隔离。
+- M 本机也持有最多 30 分钟的内存许可,绑定分享、成员、G 物理设备、O 与 M 本机供应商。
+ 授权还按 G 的具体任务 ID 与模型隔离,另一任务的模型许可不能借用。M 在建链和每次调用时复核
+ 远控开关、供应商开放状态、成员模型范围和账号作用域;只开放
+ `maker:remote-agent:v1`,不把 G 提升成同账号主人,也不开放管理、目录和统计通道。
+- G↔M 已建立的 WebRTC 路径在中继 WebSocket 的 1012、1013 或普通重连期间保留。许可不从磁盘恢复,
+ 客户端同时用本地绝对时间和单调时间限制直连 30 分钟,离线不能自行延长。中继和 O 可用时,
+ 运行中的任务约每 20 分钟重新授权并经 relay 重开链路续期;续权失败后每分钟重试。G 在分配请求
+ 发出后的 25 分钟内可复用缓存路由,29 分钟处保守停止未续权的新请求,留出约 1 分钟的时钟与网络余量。
+ 已打开任务即使 O 暂时不可达,也不会在缓存的 25 分钟界限处提前停止。
+ O 的分配响应同时报告已批准许可的剩余时间;G 按单调时钟计时,续权成功才更新期限。
+ 期限耗尽时立即结束该任务在 G 的本地工具和命令,不等待已失权的 M 回复 close,也不延长为
+ 普通断链的两分钟恢复窗口。新建与原机恢复使用同一规则;其余任务和普通 device-link 不受影响。
+ G 从分配或历史授权请求发出时开始计入许可预算;能力探测、MCP 与本机执行器准备、等待 M 启动
+ 回执都包含在内。删除或归档在这些准备阶段也会取消本次启动;已发出的上传不能撤回,但不得
+ 继续发下一片或改走 O 重开。迟到结果只清理本次资源及对应授权代次,不得关闭同一任务的后续
+ 启动或其他任务。回归见 [`roundtrip.test.ts`](../../apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts)。
+ 旧 O 缺少剩余时间字段时沿用原 30 分钟期限;M 始终独立核对实际许可。
+- 正常切模先由 O 对**原 M**重新授权新模型,再让 M 切换;失败时重新确认旧模型授权。进行中的一轮
+ 不切模。O 对分享成员模型许可、组成员配置的本机修改会立即撤销失效路由;O 不可达或刚重启且
+ 尚无原路由内存状态时,本地策略变更对已发 M 许可的传播仍以原 30 分钟到期为上限。
+- O 收到成员暂停、删除、退出或设备撤权时,撤销服务端路由、通知 M 删除本地许可并停止运行。
+ O 或 M 不可达时,已建立直连的撤权最多延迟到许可到期,最长约 30 分钟。新 G 设备在此期间
+ 不能获得许可;首次授权和续期都需要重新到达 O、M 与服务端。
+- O 的回执去重记录和 M 的待发队列各最多 20,000 条。达到上限时可能延迟或丢失用量回执,
+ 不影响权限到期与任务正文的路由;用量页只用于观察,不能直接作为结算账本。
+
+## 删除成员后的数据清理
+
+- O 在持久账本中记录每个成员的服务端 `joinedAt`,包括只使用旧中转的成员;只比较原值相等,
+ 不比较两台电脑的时钟。暂停/恢复不改变它。删除/退出后重新批准即使复用同一 `memberId`,
+ 新 `joinedAt` 也代表新的加入代次。O 重启或离线错过中间删除时,在发布新快照之前比较持久代次,
+ 同一次原子写入清除旧任务位置、退役旧回执路由并排入全部旧 M 清理目标。
+- 加入代次变化或已观察到成员消失后,同成员的直连定位、分配和旧中转准入全部阻断,直到本机
+ 受邀者索引、目录及旧中转 `forgetPending` 清理完成,且所有直连 M 确认 `forget`。M 离线时
+ 不能通过改走旧中转绕过此门。目录清理作用域先落盘,索引删除后目录清理失败也能重启续清;
+ 旧代次的迟到清理回执不能放行新代次。位置及加入代次均不授予执行权限,放行后每次直连仍需
+ 新服务端许可和 M 本机验证。服务端许可也须绑定加入代次,拒绝删除后旧许可因重新批准而复活。
+- 旧账本没有成员代次时,以升级后首次权威快照建立基线,以保留未删除任务的历史;无法追溯
+ 首次记录之前已在 O 离线期间完成的删除和重批准。成员代次不随许可过期淘汰;达到容量上限
+ 时拒绝新增记录,不逐出仍可能有旧数据的成员。
+- 只有账本文件确实不存在(`ENOENT`)才建立全新账本。读取失败(含 Windows 文件占用)、JSON
+ 或安全字段损坏时,拒绝安全查询、准入与账本写入,保留原文件;同一进程在存储恢复后可重新
+ 完整加载,不缓存空白或部分状态。有效旧版 v1 缺少可选字段仍可迁移,但已存在的非法安全
+ 条目或重复身份不能静默丢弃;读取超过当前容量的旧数组时保留完整清理屏障,只拒绝新增。
+- M 的受邀者会话索引同样只在 `ENOENT` 时初始化。其他读取错误、JSON 或已有安全字段损坏时,
+ 拒绝依赖该索引的新委托并保留原文件;恢复后可在同一实例重试。新的直连归属与对应原生历史
+ 索引只在落盘成功后发布,落盘失败保留既有索引。回归见
+ [`groupRelay.test.ts`](../../apps/desktop/src/main/remote-agent/__tests__/groupRelay.test.ts)。
+- O 在每次直连分配前,把 `(账号、分享、成员、G 设备、M 设备)` 写进本地用量账本的长期清理目标。
+ 它不随 30 分钟委托或回执宽限期过期;删除、退出成员时,O 把同成员的目标标为持久待通知,
+ 包括曾执行任务、后来退出组的 M。原有 G→O→M 中转任务仍由 O 的受邀者会话索引向组成员发清理通知。
+ 两类目标合起来覆盖 O 本机、旧中转 M 和直连 M。
+- O 通过已认证的同账号设备链路向每台直连 M 发送不含任务正文的 `forget`,失败保留队列,启动时和
+ 此后定期重试;只有 M 确认完成后才持久划掉待通知。M 按原委托时持久保存的 O、G、分享和成员
+ 精确匹配,先撤掉该受邀者的旧任务许可并停止运行,再删除直连 guest-home、影子工作区、
+ 上传附件与本机托管会话记录;同一受邀者的旧中转任务目录按各自记录保留。
+ 清理失败不会回成功。若 M 从未收到委托且没有该受邀者的直连任务或目录,空清理可幂等确认。
+- 同一成员重加入时,O 在新服务端授权和新 `delegate grant` **之前**先完成所有旧目的地
+ 的待清理;M 离线或清理失败时该成员暂不能运行。每个长期目标还有持久递增的
+ `cleanupEpoch`:旧通知晚于新授权到达时,M 不得清除更高代的许可或新任务;旧通知的丢失回执
+ 可幂等重试。O 收到旧通知的迟到 ACK 也不得删掉新一轮待清理。
+- 清理目标和待通知共用账号作用域并限制为 20,000 个目标;达到上限时拒绝新的直连分配,避免
+ 接受无法追踪清理目的地的任务。升级读取旧用量文件时,从仍在回执宽限期内的直连路由补出目标;
+ 更早、旧版本没有记录的直连目的地不能追溯。旧 M 不识别新 `forget` 时,O 保留待通知并继续重试。
+
+## 兼容与隐私
+
+- `allocate`、`direct-locate`、`delegate`、`direct-status`、`direct-release`、`direct-switch`、`direct-usage`、
+ `forget/directGuest` 和 `directGuestExecution` 是可选远程 Agent 协议扩展;
+ 新任务缺少所需能力时走旧路径。历史任务无法确认位置或重新授权原 M 时失败,不把旧原生 ID 发到猜测的电脑。
+ 旧请求格式与旧中转保持兼容。服务端新增的委托路由是可选 REST 接口与 Redis 短期键,不改变数据库历史迁移。
+- 分享直连信令要由服务端 `hello-ack` 显式声明支持;旧服务端缺少声明时不尝试新的 WebRTC 协商。
+ 新版节点回传的信令拒绝只按对应 id 处理,不拆已就绪的分享可靠链路。滚动升级期间若跨实例路径仍经过
+ 旧节点,拒绝可能没有错误回传,信令会超时退避;可靠帧也可能在重试超时后拆链。跨实例拒绝的及时回传
+ 要等全部 relay 实例升级后才有保障。
+ 普通 1012/1013 重连期间已建立的 WebRTC 可继续传输。若服务端回滚到不认识委托路由的版本,
+ 随后的中继帧或 M 的定期核权会使该直连任务失败,受邀者需重新打开任务走旧路径;不能承诺它持续到
+ 本地许可到期。回滚前应先让正在使用的委托任务结束,或准备处理这类失败。
+- 受邀者界面继续只显示匿名组状态,不显示 M 的名称、设备 ID 或组名单。但直连技术上会让
+ 参与连接的 G 知道本次 M 的设备 ID 和 WebRTC host candidate 中的局域网地址;不能把界面匿名
+ 误写成网络层匿名。信令、许可与任务正文不写入诊断日志。
+- 组里来自**另一账号**的 M 仍按既有逐人转分享同意和 O 中转工作。本轮不把 O 的许可扩展成替
+ 第三方主人授权的能力。跨区域分享沿用所在区域的服务端认证与 device-link 连接。
+- G 或 M 的 Cindy 退出会关闭直连。O 退出不关闭已建立的 G↔M 路径,但没有 O 就不能首次分配或续权。
+
+## 验收与上线门槛
+
+### Desktop 跨网段 mDNS 寻址
+
+2026-10-28:Desktop 的 `DesktopCaptureWindow(mode: direct)` 在加载页面之前,仅为这个隐藏的
+数据窗口设置 `webContents.setWebRTCIPHandlingPolicy('default_public_and_private_interfaces')`。
+[Electron 官方策略](https://www.electronjs.org/docs/latest/api/web-contents#contentssetwebrtciphandlingpolicypolicy)
+使用操作系统默认路由的接口,并允许暴露该接口的地址。本机隔离实验确认 Electron 42.11.12 /
+Chromium 148.0.7778.280 的默认策略生成 `.local` host 候选,该窗口策略生成可直接寻址的 IPv4 UDP
+host 候选;显式设置 `default` 仍生成 `.local`,`default_public_interface_only` 在本机没有候选。
+这解决了路由本身可达、但跨子网不能解析 mDNS 时的寻址缺口,不要求填写 IP。
+
+- 实现只使用 Chromium 的候选生成,不自行枚举网卡、补造候选、解析或重写本机/远端 SDP;
+ 不改 ICE ufrag/password、DTLS fingerprint、信令身份或短期许可。原有 128 KiB SDP、16 个 peer、
+ 15 秒协商预算继续生效。非法/超限描述仍由现有 bridge 和浏览器拒绝。
+- IP 只提供寻址,不授予访问权限。信令仍只发给已有授权链路中的 peer,分享、账号、成员、
+ 设备和许可检查不变;同账号设备使用同一数据窗口,也受此策略影响。不增加 STUN/TURN、
+ 全局 Chromium 开关、摄像头/麦克风权限或防火墙规则;文件与桌面音视频窗口保持原策略。
+- 对端能够看到默认路由接口的真实地址,即使两端原先只交换 `.local`;这可能是 VPN、虚拟网卡,
+ 或直接配置在接口上的公网地址。Cindy 不额外公开其它网卡,但默认路由不一定是能到达对端的
+ 那块网卡。多网卡/VPN 下其它接口可达而默认接口不可达时,直连可能退回 relay;本轮没有
+ 用遍历所有网卡的方式扩大地址暴露。SDP 和 IP 不写入应用诊断日志。
+- Mobile 继续使用原有 WebView runtime,没有此 Electron API;桌面一侧更新后,ICE 可能通过
+ peer-reflexive 候选让另一侧连通,但不能据本机实验承诺所有 Mobile/NAT/VPN 组合都成功。
+ 故障半径仍是单个 peer 的直连尝试:无候选、不可达或超时继续走该 peer 原有 relay,既不重启
+ 共享 WebSocket,也不重放业务命令、重分配 M 或影响其他 peer。
+- 隐藏传输窗口的崩溃由其所属 runtime 清理,按 Main 登记的真实 WebContents 身份隔离;
+ 不进入主界面的全局退出与数据库清理链。共享直连进程崩溃会使该进程承载的全部直连通道
+ 回退中继,但不能关闭共享 WebSocket。主界面 renderer 的致命退出规则保持不变。
+
+可复现命令:`node scripts/provider-share-direct-smoke.mjs --electron-mdns`。脚本在唯一 TEMP
+目录构建最小应用与两套独立 profile,直接运行生产 `desktopDirectRuntime` → `DesktopCaptureWindow`
+→ preload → `startDirectLinkHost` → `createDirectRtcRuntime`;不启动或读取正在运行的 Cindy。
+它只在实验信令中把 `.local` 名称换为随机不可解析名称,禁止借助同机 mDNS 解析把基线测绿。
+脚本仅记录候选数量/类型、ICE 状态和测试字节摘要,不打印 SDP、网卡名或地址。
+
+本机实测:默认策略双端 16 秒后仍为 `new`;新策略双端 UDP host↔host;只更新 offerer 或只更新
+answerer 时均通过 host/peer-reflexive 建链,三个成功组合均双向各校验 256 KiB;强制无候选
+时保持未连接;非法和超过 128 KiB 的远端 SDP 被拒绝,已有健康 peer 仍可传输。
+窗口单测覆盖加载前设置、只作用于 `direct`、权限仍拒绝、已有 desktop/files 隔离;真实 relay
+回退与授权用下述 Chrome 夹具和现有 device-link 测试验证。多网卡物理路由、两台 Windows
+跨 VLAN、macOS、Linux 与 Mobile 的实机行为尚未验证;本机两个独立 Electron 进程的实验不代表
+这些环境已经验收。
+
+### 分享与执行验收
+
+本轮用真实 Chromium WebRTC、生产 `DeviceLinkClient` 和本地三端夹具做传输烟测;夹具中的 O
+模拟分配与鉴权,不等于运行完整的供应商组宿主:1.25 MB UTF-8 任务正文只经 G↔M,O 不收到
+正文;1012 中继断开时原直连完成请求;直连断开而 relay 恢复后 G↔M 只执行一次。服务端路由
+与授权测试覆盖未登记设备、非 O 签发、许可到期和信令限制。
+
+正式启用前仍须在三台真实电脑及真实账号上验证:分享申请和新设备登记、跨区域、真 Agent 的
+附件/工具/长任务、成员暂停与撤权、O 和 M 分别重启、两位受邀者并发、双模式界面匿名呈现。
+客户端与服务端需按[协议兼容规则](../dev-rules/protocol-compatibility.md)先后部署;缺少真实账号
+环境的测试不能冒充这项验收。
diff --git a/docs/product-rules/provider-sharing.md b/docs/product-rules/provider-sharing.md
index 31d3657270..c0f93722a5 100644
--- a/docs/product-rules/provider-sharing.md
+++ b/docs/product-rules/provider-sharing.md
@@ -4,6 +4,8 @@
> 实现与本文的差异以实施计划 §0「实施记录」为准。
> 交互设计稿见 [`docs/design-previews/provider-sharing/index.html`](../design-previews/provider-sharing/index.html)(2026-10-07 已确认);
> 客户端与服务端的工作拆分见 [`docs/provider-sharing-implementation-plan.md`](../provider-sharing-implementation-plan.md)。
+> 2026-10-27 新目标:跨账号分享经供应商组分配后,受邀者优先连接实际执行电脑,并以 30 分钟为
+> 离线授权上限;详见[受邀者与执行电脑直连](provider-sharing-direct-execution.md)。该目标未上线时仍按本文现行授权和中转规则运行。
> 读取时机:新增或修改供应商分享、分享链接、分享申请与审批、分享管理页,或受邀者使用
> 分享供应商的任何路径之前。
> 分享出去的供应商建了[供应商组](provider-groups.md)时,§1 的运行位置、§7.2 管理页、§7.4 用量
diff --git a/packages/device-link-protocol/src/providerShare.ts b/packages/device-link-protocol/src/providerShare.ts
index 1438730e31..216e3cab8f 100644
--- a/packages/device-link-protocol/src/providerShare.ts
+++ b/packages/device-link-protocol/src/providerShare.ts
@@ -3,6 +3,8 @@
* capability for one shared provider. src/dst always remain physical device identifiers.
*/
export const PROVIDER_SHARE_RELAY_CAPABILITY = 'provider-share-v1';
+/** Relay can route provider-share WebRTC signaling in both directions. */
+export const PROVIDER_SHARE_DIRECT_SIGNAL_CAPABILITY = 'provider-share-direct-signal-v1';
export type ProviderShareEndpoint = { role: 'host' } | { role: 'guest'; memberId: string };
export interface ProviderShareScope {
shareId: string;
diff --git a/packages/device-link/src/__tests__/client.test.ts b/packages/device-link/src/__tests__/client.test.ts
index 8838885f3a..36e20ec207 100644
--- a/packages/device-link/src/__tests__/client.test.ts
+++ b/packages/device-link/src/__tests__/client.test.ts
@@ -3,6 +3,7 @@
* 握手 / 请求配对 / 超时 / relay-error / 重连退避 / 心跳僵死 / token 缺失。
*/
import { createHash } from 'node:crypto';
+import { PROVIDER_SHARE_DIRECT_SIGNAL_CAPABILITY } from '@cindy/device-link-protocol';
import { gunzipSync, gzipSync } from 'node:zlib';
import { describe, it, expect, vi } from 'vitest';
import { DeviceLinkClient, computeReconnectDelayMs, type WsLike } from '../client.js';
@@ -35,6 +36,7 @@ import {
} from '../transport.js';
import { PLUGIN_SYNC_CHANNEL } from '../pluginSyncProtocol.js';
import { DIRECT_LINK_SIGNAL, type DirectRuntime, type DirectRuntimeEvents } from '../directNegotiation.js';
+import { providerShareGuestPeer, providerShareHostPeer } from '../providerSharePeer.js';
import { createDirectRuntimeBridge, createDirectRuntimeHost } from '../directRuntimeBridge.js';
import { DL_CONTACTS_SYNC_CHANNEL } from '../contactsSyncProtocol.js';
import { resolveRemoteInvokeTimeoutMs } from '../invokePolicy.js';
@@ -1017,6 +1019,12 @@ class RelayWs extends FakeWs {
*(发送端的可靠层靠未 ACK 的 pending 自行保留)。
*/
class MemoryRelay {
+ providerShareDirectSignalEnabled: boolean;
+ rejectGuestProviderShareDirectSignals = false;
+ readonly rejectedDirectSignals: Envelope[] = [];
+ constructor(private readonly providerShareEnabled = false) {
+ this.providerShareDirectSignalEnabled = providerShareEnabled;
+ }
/** 按目的地记录实际投递给对端的帧(不含 hello-ack/pong 控制帧)。 */
readonly deliveredTo = new Map<string, Envelope[]>();
private readonly members = new Map<string, { ws: RelayWs | null }>();
@@ -1059,7 +1067,9 @@ class MemoryRelay {
env: {
v: PROTOCOL_VERSION,
kind: 'hello-ack',
- payload: { serverProtocolVersion: PROTOCOL_VERSION, deviceId: senderId, userId: 'u1' },
+ payload: { serverProtocolVersion: PROTOCOL_VERSION, deviceId: senderId, userId: 'u1',
+ ...(this.providerShareEnabled ? { capabilities: ['provider-share-v1',
+ ...(this.providerShareDirectSignalEnabled ? [PROVIDER_SHARE_DIRECT_SIGNAL_CAPABILITY] : [])] } : {}) },
},
});
return;
@@ -1069,6 +1079,19 @@ class MemoryRelay {
return;
}
if (!env.dst) return;
+ // A mixed cluster can acknowledge on a new node, then route through an old
+ // provider-share node that rejects the guest's best-effort SDP answer.
+ if (this.rejectGuestProviderShareDirectSignals && senderId === 'viewer'
+ && env.providerShare !== undefined && env.kind === 'push'
+ && (env.payload as { channel?: string } | undefined)?.channel === DIRECT_LINK_SIGNAL) {
+ this.rejectedDirectSignals.push(env);
+ this.queue.push({ kind: 'direct', ws, env: {
+ v: PROTOCOL_VERSION, kind: 'relay-error', id: env.id,
+ providerShare: env.providerShare,
+ payload: { code: 'DEVICE_OFFLINE', message: 'providerShare peer unavailable', dst: env.dst },
+ } });
+ return;
+ }
const dropIndex = this.dropNextPredicates.findIndex((predicate) => predicate(senderId, env));
if (dropIndex >= 0) {
this.dropNextPredicates.splice(dropIndex, 1);
@@ -1076,7 +1099,12 @@ class MemoryRelay {
}
// 入口即判定在线与否:离线目的地直接丢帧,不缓存、不重排
if (!this.members.get(env.dst)?.ws) return;
- this.queue.push({ kind: 'routed', dstId: env.dst, env: { ...env, src: senderId } });
+ const share = env.providerShare;
+ this.queue.push({ kind: 'routed', dstId: env.dst, env: {
+ ...env, src: senderId,
+ ...(share ? { providerShare: { ...share, source: share.target.role === 'host'
+ ? { role: 'guest', memberId: 'member' } : { role: 'host' } } } : {}),
+ } });
}
/** 按顺序逐帧投递直到静默;每帧之间让微任务(drain/ACK)跑完。 */
@@ -10887,6 +10915,201 @@ class MemoryDirectRuntime {
}
describe('automatic LAN connection through platform bridges', () => {
+ // Unit, provider-sharing-direct-execution.md authorization contract: a renewed
+ // scoped link must survive the former deadline on the same RTC session. The
+ // relay-restart cases below do not advance through a successful lease renewal.
+ it.each(['success', 'retry-after-lost-accept'] as const)(
+ 'extends a provider-share lease without replacing its established WebRTC session: %s', async mode => {
+ vi.useFakeTimers();
+ const relay = new MemoryRelay(true), rtc = new MemoryDirectRuntime();
+ const sockets = vi.spyOn(relay, 'makeWebSocket');
+ const host = makeRelayClient(relay, 'desktop', undefined, { directRuntime: rtc.createRuntime() });
+ const guest = makeRelayClient(relay, 'viewer', undefined, { directRuntime: rtc.createRuntime() });
+ const hostPeer = providerShareHostPeer('share', 'desktop');
+ const guestPeer = providerShareGuestPeer('share', 'member', 'viewer');
+ const pump = () => relay.settle(async () => { await vi.advanceTimersByTimeAsync(1); });
+ const advance = async (ms: number) => {
+ for (let remaining = ms; remaining > 0; remaining -= 30_000) {
+ await vi.advanceTimersByTimeAsync(Math.min(remaining, 30_000));
+ await pump();
+ }
+ };
+ let executions = 0;
+ const changes: string[] = [];
+ guest.onPeerPathChanged(change => changes.push(change.path));
+ host.onFrame(env => {
+ if (env.kind === 'link-open') host.sendLinkAccept(env.src!, env.id!, { appVersion: '1', allowlistHash: 'hash' });
+ if (env.kind === 'invoke') {
+ executions++;
+ host.sendInvokeResult(env.src!, env.id!, { ok: true, result: 'renewed direct result' });
+ }
+ });
+ try {
+ host.start(); guest.start(); await pump();
+ const opening = guest.openLink(hostPeer, { controllerName: 'Guest', protocolVersion: 1, appVersion: '1' });
+ await pump(); await opening;
+ expect(guest.getPeerPath(hostPeer)).toBe('direct');
+ const originalSessions = [...rtc.sessions.entries()];
+ expect(originalSessions).toHaveLength(1);
+ await advance(20 * 60_000);
+ if (mode === 'retry-after-lost-accept') {
+ relay.dropNext((sender, env) => sender === 'desktop' && env.kind === 'link-accept');
+ const rejected = expect(guest.openLink(hostPeer, {
+ controllerName: 'Guest', protocolVersion: 1, appVersion: '1',
+ })).rejects.toThrow();
+ await pump();
+ await advance(2_100);
+ await rejected;
+ expect(guest.getPeerPath(hostPeer)).toBe('direct');
+ expect(host.getPeerPath(guestPeer)).toBe('direct');
+ expect(originalSessions[0]![1].every(session => !session.closed)).toBe(true);
+ }
+ const renewal = guest.openLink(hostPeer, { controllerName: 'Guest', protocolVersion: 1, appVersion: '1' });
+ await pump(); await renewal;
+ await advance(11 * 60_000);
+ expect(guest.getPeerPath(hostPeer)).toBe('direct');
+ expect(host.getPeerPath(guestPeer)).toBe('direct');
+ expect([...rtc.sessions.entries()]).toEqual(originalSessions);
+ expect(originalSessions[0]![1].every(session => !session.closed)).toBe(true);
+ expect(changes).toEqual(['direct']);
+ expect(sockets).toHaveBeenCalledTimes(2);
+ const relayed = reliableKinds(relay.deliveredTo.get('desktop'), 'invoke');
+ const result = guest.invoke(hostPeer, { channel: 'maker:remote-agent:v1', args: [{ op: 'poll', runId: 'task' }] });
+ await pump();
+ expect(await result).toEqual({ ok: true, result: 'renewed direct result' });
+ expect(executions).toBe(1);
+ expect(reliableKinds(relay.deliveredTo.get('desktop'), 'invoke')).toBe(relayed);
+ // Business traffic and heartbeats cannot prolong the renewed authority.
+ await advance(20 * 60_000);
+ expect(guest.getPeerPath(hostPeer)).toBe('relay');
+ expect(host.getPeerPath(guestPeer)).toBe('relay');
+ expect(sockets).toHaveBeenCalledTimes(2);
+ } finally { host.stop(); guest.stop(); vi.useRealTimers(); }
+ });
+
+ // Production entry points: relay-authenticated scoped link, WebRTC negotiation,
+ // and remote Agent invoke. Previously any scoped peer was excluded from direct.
+ it('keeps an authorized provider share working over WebRTC during a relay restart', async () => {
+ vi.useFakeTimers();
+ const relay = new MemoryRelay(true), rtc = new MemoryDirectRuntime();
+ const host = makeRelayClient(relay, 'desktop', { requestTimeoutMs: 5_000 }, { directRuntime: rtc.createRuntime() });
+ const guest = makeRelayClient(relay, 'viewer', { requestTimeoutMs: 5_000 }, { directRuntime: rtc.createRuntime() });
+ const hostPeer = providerShareHostPeer('share', 'desktop');
+ const guestPeer = providerShareGuestPeer('share', 'member', 'viewer');
+ const pump = () => relay.settle(async () => { await vi.advanceTimersByTimeAsync(1); });
+ let executions = 0;
+ host.onFrame(env => {
+ if (env.kind === 'link-open') host.sendLinkAccept(env.src!, env.id!, { appVersion: '1', allowlistHash: 'hash' });
+ if (env.kind === 'invoke') {
+ executions++;
+ host.sendInvokeResult(env.src!, env.id!, { ok: true, result: 'direct result' });
+ }
+ });
+ try {
+ host.start(); guest.start(); await pump();
+ const opening = guest.openLink(hostPeer, { controllerName: 'Guest', protocolVersion: 1, appVersion: '1' });
+ await pump(); await opening;
+ expect(guest.getPeerPath(hostPeer)).toBe('direct');
+ expect(host.getPeerPath(guestPeer)).toBe('direct');
+ const relayedInvokes = reliableKinds(relay.deliveredTo.get('desktop'), 'invoke');
+ relay.disconnect('desktop'); relay.disconnect('viewer');
+ expect(guest.getStatus()).not.toBe('online');
+ expect(host.getStatus()).not.toBe('online');
+ const result = guest.invoke(hostPeer, { channel: 'maker:remote-agent:v1', args: [{ op: 'poll', runId: 'task' }] });
+ await pump();
+ expect(await result).toEqual({ ok: true, result: 'direct result' });
+ expect(executions).toBe(1);
+ expect(reliableKinds(relay.deliveredTo.get('desktop'), 'invoke')).toBe(relayedInvokes);
+ host.closeLink(guestPeer, 'revoked', 'inbound');
+ expect(host.getPeerPath(guestPeer)).toBe('relay');
+ } finally { host.stop(); guest.stop(); vi.useRealTimers(); }
+ });
+ it.each(['old-relay', 'mixed-relay'] as const)(
+ 'keeps provider-share invokes on the reliable relay when signaling meets a %s', async mode => {
+ vi.useFakeTimers();
+ const relay = new MemoryRelay(true), rtc = new MemoryDirectRuntime();
+ relay.providerShareDirectSignalEnabled = mode === 'mixed-relay';
+ relay.rejectGuestProviderShareDirectSignals = true;
+ const host = makeRelayClient(relay, 'desktop', undefined, { directRuntime: rtc.createRuntime() });
+ const guest = makeRelayClient(relay, 'viewer', undefined, { directRuntime: rtc.createRuntime() });
+ const hostPeer = providerShareHostPeer('share', 'desktop');
+ const guestPeer = providerShareGuestPeer('share', 'member', 'viewer');
+ const pump = () => relay.settle(async () => { await vi.advanceTimersByTimeAsync(1); });
+ let executions = 0;
+ const guestRouteChanges: string[] = [];
+ guest.onPeerRouteStateChanged(change => guestRouteChanges.push(change.state));
+ host.onFrame(env => {
+ if (env.kind === 'link-open') host.sendLinkAccept(env.src!, env.id!, { appVersion: '1', allowlistHash: 'hash' });
+ if (env.kind === 'invoke') {
+ executions++;
+ host.sendInvokeResult(env.src!, env.id!, { ok: true, result: 'relay result' });
+ }
+ });
+ try {
+ host.start(); guest.start(); await pump();
+ const opening = guest.openLink(hostPeer, { controllerName: 'Guest', protocolVersion: 1, appVersion: '1' });
+ await pump(); await opening;
+ expect(guest.getPeerPath(hostPeer)).toBe('relay');
+ expect(host.getPeerPath(guestPeer)).toBe('relay');
+ expect(guest.isLinkReady(hostPeer)).toBe(true);
+ expect(host.isLinkReady(guestPeer)).toBe(true);
+ expect(guestRouteChanges).not.toContain('offline');
+ expect(relay.rejectedDirectSignals.length).toBe(mode === 'mixed-relay' ? 1 : 0);
+ if (mode === 'mixed-relay') {
+ expect(relay.rejectedDirectSignals[0]?.id).toEqual(expect.any(String));
+ expect(guest.getStatus()).toBe('online');
+ } else {
+ expect([...relay.deliveredTo.values()].flat().some(env => env.kind === 'push'
+ && (env.payload as { channel?: string } | undefined)?.channel === DIRECT_LINK_SIGNAL)).toBe(false);
+ }
+ const result = guest.invoke(hostPeer, { channel: 'maker:remote-agent:v1', args: [{ op: 'poll', runId: 'task' }] });
+ await pump();
+ expect(await result).toEqual({ ok: true, result: 'relay result' });
+ expect(executions).toBe(1);
+ expect(reliableKinds(relay.deliveredTo.get('desktop'), 'invoke')).toBe(1);
+ } finally { host.stop(); guest.stop(); vi.useRealTimers(); }
+ },
+ );
+
+ it('keeps an established provider-share WebRTC path after reconnecting to an old relay', async () => {
+ vi.useFakeTimers();
+ const relay = new MemoryRelay(true), rtc = new MemoryDirectRuntime();
+ const host = makeRelayClient(relay, 'desktop', undefined, { directRuntime: rtc.createRuntime() });
+ const guest = makeRelayClient(relay, 'viewer', undefined, { directRuntime: rtc.createRuntime() });
+ const hostPeer = providerShareHostPeer('share', 'desktop');
+ const guestPeer = providerShareGuestPeer('share', 'member', 'viewer');
+ const pump = () => relay.settle(async () => { await vi.advanceTimersByTimeAsync(1); });
+ let executions = 0;
+ host.onFrame(env => {
+ if (env.kind === 'link-open') host.sendLinkAccept(env.src!, env.id!, { appVersion: '1', allowlistHash: 'hash' });
+ if (env.kind === 'invoke') {
+ executions++;
+ host.sendInvokeResult(env.src!, env.id!, { ok: true, result: 'still direct' });
+ }
+ });
+ try {
+ host.start(); guest.start(); await pump();
+ const opening = guest.openLink(hostPeer, { controllerName: 'Guest', protocolVersion: 1, appVersion: '1' });
+ await pump(); await opening;
+ expect(guest.getPeerPath(hostPeer)).toBe('direct');
+ relay.providerShareDirectSignalEnabled = false;
+ relay.disconnect('desktop'); relay.disconnect('viewer');
+ for (let n = 0; n < 10 && (host.getStatus() !== 'online' || guest.getStatus() !== 'online'); n++) {
+ await vi.advanceTimersByTimeAsync(20); await pump();
+ }
+ expect(host.getStatus()).toBe('online');
+ expect(guest.getStatus()).toBe('online');
+ expect(guest.hasServerCapability(PROVIDER_SHARE_DIRECT_SIGNAL_CAPABILITY)).toBe(false);
+ expect(guest.getPeerPath(hostPeer)).toBe('direct');
+ expect(host.getPeerPath(guestPeer)).toBe('direct');
+ const relayedInvokes = reliableKinds(relay.deliveredTo.get('desktop'), 'invoke');
+ const result = guest.invoke(hostPeer, { channel: 'maker:remote-agent:v1', args: [{ op: 'poll', runId: 'task' }] });
+ await pump();
+ expect(await result).toEqual({ ok: true, result: 'still direct' });
+ expect(executions).toBe(1);
+ expect(reliableKinds(relay.deliveredTo.get('desktop'), 'invoke')).toBe(relayedInvokes);
+ } finally { host.stop(); guest.stop(); vi.useRealTimers(); }
+ });
it.each(['both', 'old-host', 'old-viewer', 'unavailable'] as const)('negotiates automatically and keeps %s compatible', async mode => {
vi.useFakeTimers();
const relay = new MemoryRelay(), rtc = new MemoryDirectRuntime();
diff --git a/packages/device-link/src/__tests__/remoteAgent.test.ts b/packages/device-link/src/__tests__/remoteAgent.test.ts
index bbae9c7735..8f84e50163 100644
--- a/packages/device-link/src/__tests__/remoteAgent.test.ts
+++ b/packages/device-link/src/__tests__/remoteAgent.test.ts
@@ -37,9 +37,50 @@ describe('subscription Fast policy wire compatibility', () => {
expect(() => parseRemoteAgentRequest({ ...command, ...patch })).toThrow();
}
});
+ it('preserves only the bounded direct guest task binding', () => {
+ const guest = { shareId: 'share', memberId: 'member', guestDeviceId: 'laptop' };
+ const command = { op: 'fast-policy', group: 'openai', revision: 1, allowFast: false,
+ binding: { sessionId: runId, providerShareGuest: guest } };
+ expect(parseRemoteAgentRequest(command)).toEqual(command);
+ expect(() => parseRemoteAgentRequest({ ...command,
+ binding: { ...command.binding, controllerDeviceId: 'owner' } })).toThrow();
+ expect(() => parseRemoteAgentRequest({ ...command,
+ binding: { ...command.binding, providerShareGuest: { ...guest, shareId: '../share' } } })).toThrow();
+ });
});
describe('remote agent channel', () => {
+ // Production parser / unit: locating history is scoped by the authenticated
+ // peer, never a guest-supplied share/member/device. Legacy allocate is unchanged.
+ it('parses only the bounded direct-location task and preserves legacy requests', () => {
+ expect(parseRemoteAgentRequest({ op: 'direct-locate', sessionId: runId, memberId: 'other', deviceId: 'other' }))
+ .toEqual({ op: 'direct-locate', sessionId: runId });
+ for (const sessionId of ['', '../task', 'x'.repeat(129)]) {
+ expect(() => parseRemoteAgentRequest({ op: 'direct-locate', sessionId })).toThrow('REMOTE_AGENT_INVALID');
+ }
+ const legacy = { op: 'allocate', agentKind: 'pi', model: 'model', sessionId: runId };
+ expect(parseRemoteAgentRequest(legacy)).toEqual(legacy);
+ expect(() => parseRemoteAgentRequest({ op: 'future-direct-op', sessionId: runId })).toThrow('REMOTE_AGENT_INVALID');
+ });
+
+ // Unit / production parser: after O restarts, dropping this wire field would
+ // silently assign M2 while G's existing task and reliable link still live on M1.
+ it('preserves the current executor when parsing a direct-task renewal', () => {
+ const request = { op: 'allocate', agentKind: 'pi', model: 'model-b',
+ sessionId: runId, preferredExecutorDeviceId: 'executor-1' };
+ expect(parseRemoteAgentRequest(request)).toEqual(request);
+ expect(() => parseRemoteAgentRequest({ ...request, preferredExecutorDeviceId: '' })).toThrow('REMOTE_AGENT_INVALID');
+ });
+
+ it('binds a failed direct-open release to one allocation generation', () => {
+ const release = { op: 'direct-release', sessionId: runId,
+ generation: '11111111-1111-4111-8111-111111111111' };
+ expect(parseRemoteAgentRequest(release)).toEqual(release);
+ expect(() => parseRemoteAgentRequest({ ...release, generation: '../newer' })).toThrow('REMOTE_AGENT_INVALID');
+ expect(() => parseRemoteAgentRequest({ ...release, sessionId: '../other' })).toThrow('REMOTE_AGENT_INVALID');
+ expect(isRemoteAgentReadInvoke(REMOTE_AGENT_CHANNEL, [release])).toBe(false);
+ });
+
// Shared-model fork wire: old peers must not gain write support by default; task IDs
// include group-relay IDs, while filesystem roots are never accepted from callers.
it('validates native fork boundaries and never retries a fork as a read', () => {
@@ -73,6 +114,14 @@ describe('remote agent channel', () => {
expect(parseRemoteAgentRequest({ op: 'forget', relay, extra: 1 })).toEqual({ op: 'forget', relay });
expect(() => parseRemoteAgentRequest({ op: 'forget', relay: 'short' })).toThrow('REMOTE_AGENT_INVALID');
expect(() => parseRemoteAgentRequest({ op: 'forget' })).toThrow('REMOTE_AGENT_INVALID');
+ const directGuest = { shareId: 'share', memberId: 'member', guestDeviceId: 'laptop',
+ forgetId: runId, cleanupEpoch: 1 };
+ expect(parseRemoteAgentRequest({ op: 'forget', directGuest })).toEqual({ op: 'forget', directGuest });
+ expect(() => parseRemoteAgentRequest({ op: 'forget', relay, directGuest })).toThrow('REMOTE_AGENT_INVALID');
+ expect(() => parseRemoteAgentRequest({ op: 'forget', directGuest: { ...directGuest, forgetId: 'short' } }))
+ .toThrow('REMOTE_AGENT_INVALID');
+ expect(() => parseRemoteAgentRequest({ op: 'forget', directGuest: { ...directGuest, cleanupEpoch: -1 } }))
+ .toThrow('REMOTE_AGENT_INVALID');
const caps = { version: 1, agents: [], maxRuns: 16, uploadChunkBytes: 1024, maxPayloadBytes: 2048 };
expect(parseRemoteAgentCaps({ ...caps, guestRelay: true }).guestRelay).toBe(true);
expect(parseRemoteAgentCaps({ ...caps, guestRelay: 'yes' })).not.toHaveProperty('guestRelay');
@@ -225,6 +274,20 @@ describe('remote agent channel', () => {
.toEqual({ op: 'upload', uploadId: otherId, index: 0, data: 'AAAA' });
});
+ // A delayed usage receipt must identify the exact server grant; a new grant for the same M cannot relabel it.
+ it('requires a grant generation on delegated usage and grant installation', () => {
+ const generation = '11111111-1111-4111-8111-111111111111';
+ const identity = { shareId: 'share-1', memberId: 'member-1', guestDeviceId: 'guest-pc', sessionId: 'task-1' };
+ const grant = { op: 'delegate', action: 'grant', ...identity, providerId: 'openai', model: 'gpt', generation };
+ expect(parseRemoteAgentRequest(grant)).toMatchObject(grant);
+ expect(() => parseRemoteAgentRequest({ ...grant, generation: undefined })).toThrow('REMOTE_AGENT_INVALID');
+ const usage = { op: 'direct-usage', ...identity, agentKind: 'codex', generation,
+ usageId: '22222222-2222-4222-8222-222222222222', samples: [{ model: 'gpt', turns: 1,
+ inputTokens: 7, outputTokens: 3, cacheReadTokens: 0, cacheCreateTokens: 0, sdkCostUsd: 0 }] };
+ expect(parseRemoteAgentRequest(usage)).toMatchObject(usage);
+ expect(() => parseRemoteAgentRequest({ ...usage, generation: undefined })).toThrow('REMOTE_AGENT_INVALID');
+ });
+
it('rejects malformed identities, unknown methods and oversize payloads', () => {
const bad: unknown[] = [
null,
diff --git a/packages/device-link/src/client.ts b/packages/device-link/src/client.ts
index d3c76c6e15..f31a6a41aa 100644
--- a/packages/device-link/src/client.ts
+++ b/packages/device-link/src/client.ts
@@ -8,9 +8,9 @@ import {
type DeviceLinkTransferCodec,
} from './invokeTransfer.js';
import { decodeScopedEnvelope, encodeScopedEnvelope, type ScopeSupport } from './providerShareEnvelope.js';
-import { isProviderSharePeer } from './providerSharePeer.js';
+import { isProviderSharePeer, parseProviderSharePeer } from './providerSharePeer.js';
import { isSharedTaskPeer } from './sharedTaskPeer.js';
-import { PROVIDER_SHARE_RELAY_CAPABILITY, ROUTED_KINDS, SHARED_TASK_RELAY_CAPABILITY } from '@cindy/device-link-protocol';
+import { PROVIDER_SHARE_RELAY_CAPABILITY, PROVIDER_SHARE_DIRECT_SIGNAL_CAPABILITY, ROUTED_KINDS, SHARED_TASK_RELAY_CAPABILITY } from '@cindy/device-link-protocol';
import {
requestSessionTagCatalog,
decodeSessionTagCatalog,
@@ -71,11 +71,12 @@ import {
} from './transport.js';
import { PLUGIN_SYNC_CHANNEL } from './pluginSyncProtocol.js';
import { RELAY_AUTH_CHANNEL, relayAuthHandshake } from './selfHostedRelayAuth.js';
-import { DIRECT_LINK_CAPABILITY, DIRECT_LINK_SIGNAL, DirectLinkNegotiator, parseDirectSignal,
+import { DIRECT_LINK_CAPABILITY, DIRECT_LINK_SIGNAL, PROVIDER_SHARE_DIRECT_CAPABILITY, DirectLinkNegotiator, parseDirectSignal,
type DirectRuntime } from './directNegotiation.js';
import { MAKER_EVENT_BATCH_CHANNEL } from './topics.js';
import {
DIRECT_PATH_HIGH_WATER_BYTES,
+ PROVIDER_SHARE_DIRECT_LEASE_MS,
type DeviceLinkDirectChannel,
type DeviceLinkDirectCloseReason,
type DeviceLinkDirectPathHandle,
@@ -129,6 +130,9 @@ const MAX_OUTBOUND_ROUTE_GENERATION_RUNS_PER_ID = 256;
/** 已结算记录不占发送额度;仅保留近期代次供迟到 relay-error 归属。 */
const MAX_SETTLED_OUTBOUND_ROUTE_IDS_PER_PEER = 1_024;
const MAX_SETTLED_OUTBOUND_ROUTE_IDS_TOTAL = 16_384;
+/** Signals are best-effort, but their route errors must never tear down a reliable link. */
+const MAX_PROVIDER_SHARE_SIGNAL_ROUTE_IDS = 16_384;
+const PROVIDER_SHARE_SIGNAL_ROUTE_TTL_MS = 2 * 60_000;
/**
* 该 push channel 是否属于可驱逐档(latest-wins 腾位的唯一判据入口)。
@@ -908,12 +912,20 @@ export class DeviceLinkClient {
string,
Map<string, Array<{ linkGeneration: number; count: number }>>
>();
+ /** Signal request id -> scoped peer, retained for this socket's relay-error correlation. */
+ private readonly providerShareSignalRouteIds = new Map<string, { dst: string; expiresAt: number }>();
/**
* 每台同账号设备至多一条直连通道(见 directPath.ts)。只承载已建立可靠链路上的
* 数据面帧;没有通道或通道失效时,同一批帧照常走 relay。
*/
private readonly directPaths = new Map<string, DeviceLinkDirectChannel>();
private readonly directPeerSupport = new Set<string>();
+ /** Relay-authenticated provider-share path leases never survive process/account replacement. */
+ private readonly providerShareDirectLeases = new Map<string, {
+ wallUntil: number; monotonicUntil: number; timer: ReturnType<typeof setTimeout>;
+ }>();
+ /** Local scoped address learned from the relay, not from an untrusted direct frame. */
+ private readonly providerShareLocalAddresses = new Map<string, string>();
private readonly directNegotiator?: DirectLinkNegotiator;
private peerPathHandlers = new Set<(change: DeviceLinkPeerPathChanged) => void>();
@@ -922,9 +934,12 @@ export class DeviceLinkClient {
if (opts.directRuntime) this.directNegotiator = new DirectLinkNegotiator({
runtime: opts.directRuntime,
identity: () => this.selfDeviceId,
+ peerDeviceId: (id) => parseProviderSharePeer(id)?.deviceId ?? (isScopedPeer(id) ? null : id),
+ canSignal: (peer) => this.status === 'online'
+ && (!isProviderSharePeer(peer) || this.hasServerCapability(PROVIDER_SHARE_DIRECT_SIGNAL_CAPABILITY)),
streams: (id) => {
const peer = this.peerTransport.get(id);
- return !this.stopped && this.status === 'online' && !isScopedPeer(id)
+ return !this.stopped && (!isScopedPeer(id) || this.hasProviderShareDirectLease(id))
&& this.directPeerSupport.has(id) && peer?.reliable && peer.receiveReady
&& this.isPeerSendReady(peer) && peer.remoteStreamId
? { local: peer.streamId, remote: peer.remoteStreamId } : null;
@@ -932,8 +947,24 @@ export class DeviceLinkClient {
id: createRequestId,
signal: (dst, payload) => {
// Signaling is a control plane: never put SDP or close notices onto the direct path.
- this.sendBestEffortRoutedEnvelope({ v: PROTOCOL_VERSION, kind: 'push', dst,
- payload: { channel: DIRECT_LINK_SIGNAL, payload } });
+ const scoped = isProviderSharePeer(dst);
+ const now = performance.now();
+ while (this.providerShareSignalRouteIds.size) {
+ const first = this.providerShareSignalRouteIds.entries().next().value!;
+ if (first[1].expiresAt > now) break;
+ this.providerShareSignalRouteIds.delete(first[0]);
+ }
+ if (scoped && (!this.hasServerCapability(PROVIDER_SHARE_DIRECT_SIGNAL_CAPABILITY)
+ || this.providerShareSignalRouteIds.size >= MAX_PROVIDER_SHARE_SIGNAL_ROUTE_IDS)) return;
+ const id = scoped ? createRequestId() : undefined;
+ if (id) this.providerShareSignalRouteIds.set(id, { dst, expiresAt: now + PROVIDER_SHARE_SIGNAL_ROUTE_TTL_MS });
+ try {
+ this.sendBestEffortRoutedEnvelope({ v: PROTOCOL_VERSION, kind: 'push', id, dst,
+ payload: { channel: DIRECT_LINK_SIGNAL, payload } });
+ } catch (err) {
+ if (id) this.providerShareSignalRouteIds.delete(id);
+ throw err;
+ }
},
attach: (id, channel) => this.attachDirectPath(id, channel),
});
@@ -1320,7 +1351,8 @@ export class DeviceLinkClient {
},
isActive,
};
- if (this.stopped || !deviceId || deviceId === this.selfDeviceId || isScopedPeer(deviceId)) {
+ if (this.stopped || !deviceId || deviceId === this.selfDeviceId
+ || (isScopedPeer(deviceId) && !this.hasProviderShareDirectLease(deviceId))) {
this.closeDirectChannel(deviceId, channel, 'not-eligible');
return handle;
}
@@ -1333,7 +1365,53 @@ export class DeviceLinkClient {
/** 该设备的数据面路径:接入了直连通道即为 'direct'(链路就绪后启用),否则走 relay。 */
getPeerPath(deviceId: string): DeviceLinkPeerPath {
- return this.directPaths.has(deviceId) ? 'direct' : 'relay';
+ return this.usableDirectPath(deviceId) ? 'direct' : 'relay';
+ }
+
+ /** Existing, leased data path usable while the relay is reconnecting. */
+ hasOfflineDirectPath(deviceId: string): boolean {
+ return !!this.usableDirectPath(deviceId) && isProviderSharePeer(deviceId)
+ && this.isLinkReady(deviceId);
+ }
+
+ private hasProviderShareDirectLease(deviceId: string): boolean {
+ if (!isProviderSharePeer(deviceId)) return false;
+ const lease = this.providerShareDirectLeases.get(deviceId);
+ if (!lease) return false;
+ if (Date.now() < lease.wallUntil && this.monotonicNow() < lease.monotonicUntil) return true;
+ this.expireProviderShareDirectLease(deviceId);
+ return false;
+ }
+
+ private usableDirectPath(deviceId: string): DeviceLinkDirectChannel | null {
+ if (isScopedPeer(deviceId) && !this.hasProviderShareDirectLease(deviceId)) return null;
+ return this.directPaths.get(deviceId) ?? null;
+ }
+
+ private issueProviderShareDirectLease(deviceId: string): void {
+ if (!isProviderSharePeer(deviceId) || !this.directPeerSupport.has(deviceId)
+ || !this.providerShareLocalAddresses.has(deviceId)) return;
+ this.clearProviderShareDirectLease(deviceId);
+ const wallUntil = Date.now() + PROVIDER_SHARE_DIRECT_LEASE_MS;
+ const monotonicUntil = this.monotonicNow() + PROVIDER_SHARE_DIRECT_LEASE_MS;
+ const timer = setTimeout(() => this.expireProviderShareDirectLease(deviceId), PROVIDER_SHARE_DIRECT_LEASE_MS);
+ (timer as { unref?: () => void }).unref?.();
+ this.providerShareDirectLeases.set(deviceId, { wallUntil, monotonicUntil, timer });
+ }
+
+ private clearProviderShareDirectLease(deviceId: string): void {
+ const lease = this.providerShareDirectLeases.get(deviceId);
+ if (lease) clearTimeout(lease.timer);
+ this.providerShareDirectLeases.delete(deviceId);
+ }
+
+ private expireProviderShareDirectLease(deviceId: string): void {
+ this.clearProviderShareDirectLease(deviceId);
+ this.detachDirectPath(deviceId, 'link-closed');
+ if (this.status !== 'online') {
+ const peer = this.peerTransport.get(deviceId);
+ if (peer) this.markPeerLinkDown(peer);
+ }
}
/** 订阅直连与 relay 之间的切换;平台据此在切回 relay 后安排重新建立直连。 */
@@ -1526,6 +1604,10 @@ export class DeviceLinkClient {
this.pendingInboundLinkOffers.delete(dst);
const peer = this.peerTransport.get(dst);
if (direction === 'inbound') {
+ if (isProviderSharePeer(dst)) {
+ this.clearProviderShareDirectLease(dst);
+ this.detachDirectPath(dst, 'link-closed');
+ }
// 入站方向关闭(撤权/踢控制端):PeerTransportState 按 deviceId 共享两个
// 方向,互控时仍存续的**出站**可靠层不得陪葬——不置 explicitlyClosed、
// 不拆 reliable/stream、不清 pending、不 reject 在途请求与出站 openLink 等待,
@@ -1590,7 +1672,9 @@ export class DeviceLinkClient {
timeoutMs?: number,
options?: { preSend?: () => void; background?: boolean },
): Promise<InvokeResultPayload> {
- if (this.status !== 'online') throw new DeviceLinkError('NOT_CONNECTED', 'not connected to relay');
+ if (this.status !== 'online' && !this.hasOfflineDirectPath(dst)) {
+ throw new DeviceLinkError('NOT_CONNECTED', 'not connected to relay');
+ }
const send = async () => {
// Admission may wait: validate caller ownership/cancellation after dequeue,
// synchronously before creating the request or retaining a transport frame.
@@ -1703,7 +1787,12 @@ export class DeviceLinkClient {
? {
capabilities: this.mergeCapabilities(payload?.capabilities, [
DEVICE_LINK_CAPABILITY_RELIABLE_TRANSPORT,
- ...(this.directNegotiator && !isScopedPeer(dst) ? [DIRECT_LINK_CAPABILITY] : []),
+ ...(this.directNegotiator && (!isScopedPeer(dst)
+ || (isProviderSharePeer(dst) && matchingOffer?.capabilities?.includes(PROVIDER_SHARE_DIRECT_CAPABILITY)))
+ ? [DIRECT_LINK_CAPABILITY] : []),
+ ...(this.directNegotiator && isProviderSharePeer(dst)
+ && matchingOffer?.capabilities?.includes(PROVIDER_SHARE_DIRECT_CAPABILITY)
+ ? [PROVIDER_SHARE_DIRECT_CAPABILITY] : []),
...(peerSupportsLinkConfirm
? [DEVICE_LINK_CAPABILITY_RELIABLE_LINK_CONFIRM]
: []),
@@ -1729,6 +1818,7 @@ export class DeviceLinkClient {
matchingOffer.transportStreamId,
matchingOffer.transportBaseSeq,
);
+ if (peerSupportsReliable) this.issueProviderShareDirectLease(dst);
}
peer.linkAcceptedInbound = true;
peer.duplicateOpenRepair = null;
@@ -1752,7 +1842,7 @@ export class DeviceLinkClient {
ownerStamp?: import('./protocol.js').PushOwnerStamp,
): void {
payload = encodeModelSpeedPayload(channel, payload);
- if (this.status !== 'online') return;
+ if (this.status !== 'online' && !this.hasOfflineDirectPath(dst)) return;
const pushPayload = {
channel,
payload,
@@ -1800,7 +1890,7 @@ export class DeviceLinkClient {
timeoutMs?: number,
allowPeerResetRetry = true,
): Promise<Envelope> {
- if (this.status !== 'online') {
+ if (this.status !== 'online' && !(env.kind === 'invoke' && env.dst && this.hasOfflineDirectPath(env.dst))) {
return Promise.reject(new DeviceLinkError('NOT_CONNECTED', 'not connected to relay'));
}
const id = createRequestId();
@@ -2035,7 +2125,8 @@ export class DeviceLinkClient {
peer: PeerTransportState,
pending: PendingReliableMessage,
): void {
- if (!peer.reliable || !this.isPeerSendReady(peer) || this.stopped || this.status !== 'online') return;
+ if (!peer.reliable || !this.isPeerSendReady(peer) || this.stopped
+ || (this.status !== 'online' && !this.hasOfflineDirectPath(dst))) return;
try {
this.sendReliableFrames(peer, pending);
} catch (err) {
@@ -2189,7 +2280,10 @@ export class DeviceLinkClient {
// 保留它的物理发送记录只会让新连接重放产生的错误先消费旧代次,误判为 stale。
this.outboundRouteGenerationByPeer.clear();
this.settledOutboundRouteGenerationByPeer.clear();
- for (const peer of this.peerTransport.values()) {
+ this.providerShareSignalRouteIds.clear();
+ for (const [deviceId, peer] of this.peerTransport) {
+ // An authenticated direct provider-share path has an independent, bounded lease.
+ if (this.hasOfflineDirectPath(deviceId)) continue;
this.markPeerLinkDown(peer);
peer.recoveryNeedsAck = true;
peer.recoveryFramesSent = 0;
@@ -2585,6 +2679,12 @@ export class DeviceLinkClient {
}
private dispatchEnvelope(env: Envelope): boolean | Promise<boolean> {
+ if ((env.kind === 'link-open' || env.kind === 'link-accept') && env.src && env.dst) {
+ const remote = parseProviderSharePeer(env.src);
+ const local = parseProviderSharePeer(env.dst);
+ if (remote && local && remote.shareId === local.shareId && remote.role !== local.role
+ && local.deviceId === this.selfDeviceId) this.providerShareLocalAddresses.set(env.src, env.dst);
+ }
switch (env.kind) {
case 'hello-ack': {
const ack = env.payload as HelloAckPayload;
@@ -2670,6 +2770,7 @@ export class DeviceLinkClient {
accepted?.transportBaseSeq,
'outbound-accept',
);
+ this.issueProviderShareDirectLease(env.src);
const peer = this.getPeerTransport(env.src);
const acceptedLinkGeneration = this.markPeerRouteOnline(env.src);
this.logRecoveryStage(env.src, 'link-accept-received', ` baseSeq=${peer.remoteBaseSeq}`);
@@ -2717,6 +2818,15 @@ export class DeviceLinkClient {
}
case 'relay-error': {
const payload = env.payload as RelayErrorPayload;
+ // During a rolling deploy, a newer ingress can advertise signaling while an
+ // older provider-share relay hop still rejects the scoped push. It is only
+ // this best-effort signal that failed, not the already-open reliable link.
+ if (env.id && env.providerShare !== undefined && payload.dst
+ && this.providerShareSignalRouteIds.get(env.id)?.dst === payload.dst) {
+ this.providerShareSignalRouteIds.delete(env.id);
+ this.discardOutboundRouteAttemptsForId(payload.dst, env.id);
+ return true;
+ }
const terminalRouteFailure = (
payload.code === 'DEVICE_OFFLINE'
|| payload.code === 'REMOTE_DISABLED'
@@ -3175,7 +3285,9 @@ export class DeviceLinkClient {
private emitFrame(env: Envelope): boolean | Promise<boolean> {
if (env.kind === 'push' && (env.payload as { channel?: string })?.channel === DIRECT_LINK_SIGNAL) {
const signal = parseDirectSignal((env.payload as { payload?: unknown }).payload);
- if (signal && env.src && !isScopedPeer(env.src)) this.directNegotiator?.receive(env.src, signal);
+ if (signal && env.src && (!isScopedPeer(env.src) || this.hasProviderShareDirectLease(env.src))) {
+ this.directNegotiator?.receive(env.src, signal);
+ }
return true;
}
if (env.kind === 'invoke' && env.src && env.id && !isScopedPeer(env.src)) {
@@ -3478,6 +3590,10 @@ export class DeviceLinkClient {
const head = peer.pending.values().next().value;
if (head && head !== pending && !head.sent) return 0;
}
+ if (this.status !== 'online') {
+ pending.lastBlockedBy = 'socket';
+ return 0;
+ }
if (frameAuth?.peerChallenge && frameAuth.peerChallenge.state(pending.envelope.dst!) !== 'ready') {
// 逻辑消息保留在已有可靠 pending;分片不能挤进认证队列或被误记为物理已发送。
const dst = pending.envelope.dst!;
@@ -3571,7 +3687,7 @@ export class DeviceLinkClient {
/** 可靠帧此刻能否走直连:双方已提交可靠链路、本机发送方向就绪且接入了通道。 */
private directChannelForSend(dst: string, peer: PeerTransportState): DeviceLinkDirectChannel | null {
if (!peer.reliable || !this.isPeerSendReady(peer)) return null;
- return this.directPaths.get(dst) ?? null;
+ return this.usableDirectPath(dst);
}
/**
@@ -3705,6 +3821,10 @@ export class DeviceLinkClient {
private handleDirectFrame(deviceId: string, text: string): void {
if (this.stopped) return;
const self = this.selfDeviceId;
+ const sharePeer = parseProviderSharePeer(deviceId);
+ const localAddress = sharePeer && this.hasProviderShareDirectLease(deviceId)
+ ? this.providerShareLocalAddresses.get(deviceId) : undefined;
+ if (isScopedPeer(deviceId) && !localAddress) return;
let parsed: unknown;
try {
if (byteLength(text) > MAX_FRAME_BYTES) throw new Error('direct frame too large');
@@ -3721,7 +3841,7 @@ export class DeviceLinkClient {
|| parsed.sharedTask !== undefined
|| parsed.providerShare !== undefined
|| !self
- || parsed.dst !== self
+ || parsed.dst !== (localAddress ?? self)
|| (parsed.id !== undefined && typeof parsed.id !== 'string')
) {
this.log.warn(`dropping disallowed direct frame from ${deviceId.slice(0, 8)}`);
@@ -3732,7 +3852,7 @@ export class DeviceLinkClient {
kind: parsed.kind as Envelope['kind'],
...(typeof parsed.id === 'string' ? { id: parsed.id } : {}),
src: deviceId,
- dst: self,
+ dst: localAddress ?? self,
payload: parsed.payload,
};
if (!isValidInboundEnvelope(env)) {
@@ -3745,6 +3865,10 @@ export class DeviceLinkClient {
this.handleTransportAck(deviceId, ack.streamId, ack.ackSeq);
return;
}
+ // The relay enforces this direction for provider shares. A direct channel
+ // must enforce it again before any reliable payload reaches dispatch.
+ if (sharePeer && !(sharePeer.role === 'guest' ? env.kind === 'invoke'
+ : env.kind === 'invoke-result' || env.kind === 'push')) return;
if (!parseTransportPayload(env.payload)) {
this.log.warn(`dropping non-reliable direct frame kind=${env.kind} from ${deviceId.slice(0, 8)}`);
return;
@@ -4240,6 +4364,8 @@ export class DeviceLinkClient {
private markPeerLinkDown(peer: PeerTransportState): void {
for (const [id, state] of this.peerTransport) if (state === peer) {
this.detachDirectPath(id, 'link-closed');
+ this.clearProviderShareDirectLease(id);
+ this.providerShareLocalAddresses.delete(id);
break;
}
peer.duplicateOpenRepair = null;
@@ -4382,11 +4508,15 @@ export class DeviceLinkClient {
source: 'inbound-open' | 'outbound-accept' = 'inbound-open',
): void {
const peer = this.getPeerTransport(dst);
- if (this.directNegotiator && !isScopedPeer(dst) && capabilities?.includes(DIRECT_LINK_CAPABILITY)) {
+ if (this.directNegotiator && capabilities?.includes(DIRECT_LINK_CAPABILITY)
+ && (!isScopedPeer(dst) || (isProviderSharePeer(dst)
+ && capabilities.includes(PROVIDER_SHARE_DIRECT_CAPABILITY)))) {
this.directPeerSupport.add(dst);
} else {
this.directPeerSupport.delete(dst);
this.directNegotiator?.forget(dst);
+ if (isProviderSharePeer(dst)) this.clearProviderShareDirectLease(dst);
+ this.detachDirectPath(dst, 'not-eligible');
}
const reliable = (
Array.isArray(capabilities)
@@ -4446,7 +4576,9 @@ export class DeviceLinkClient {
DEVICE_LINK_CAPABILITY_RELIABLE_LINK_CONFIRM,
DEVICE_LINK_CAPABILITY_RELIABLE_TRANSPORT,
DEVICE_LINK_CAPABILITY_TRANSPORT_TIMEOUT_CLOSE,
- ...(this.directNegotiator && !isScopedPeer(dst) ? [DIRECT_LINK_CAPABILITY] : []),
+ ...(this.directNegotiator && (!isScopedPeer(dst) || isProviderSharePeer(dst))
+ ? [DIRECT_LINK_CAPABILITY] : []),
+ ...(this.directNegotiator && isProviderSharePeer(dst) ? [PROVIDER_SHARE_DIRECT_CAPABILITY] : []),
]),
transportStreamId: typeof payload.transportStreamId === 'string'
? payload.transportStreamId
@@ -4488,7 +4620,7 @@ export class DeviceLinkClient {
const ack = makeTransportAck(dst, streamId, ackSeq, effectiveLinkRequestId);
// 累计 ACK 原路返回;链路确认 ACK 属于控制面,始终走 relay。
const direct = !effectiveLinkRequestId && this.peerTransport.get(dst)?.lastInboundPath === 'direct'
- ? this.directPaths.get(dst)
+ ? this.usableDirectPath(dst)
: undefined;
if (direct) {
try {
@@ -4937,7 +5069,7 @@ export class DeviceLinkClient {
|| !peer.reliable
|| !this.isPeerSendReady(peer)
|| this.stopped
- || this.status !== 'online'
+ || (this.status !== 'online' && !this.hasOfflineDirectPath(dst))
) return;
const now = Date.now();
// pending 是按 seq 递增插入的 Map,迭代天然旧→新 —— 正是累计 ACK 需要推进的顺序。
@@ -5565,6 +5697,8 @@ export class DeviceLinkClient {
private clearPeerTransport(): void {
this.directNegotiator?.clear();
this.directPeerSupport.clear();
+ for (const id of this.providerShareDirectLeases.keys()) this.clearProviderShareDirectLease(id);
+ this.providerShareLocalAddresses.clear();
this.opts.directRuntime?.suspend?.();
for (const peer of this.peerTransport.values()) {
if (peer.retryTimer) clearInterval(peer.retryTimer);
@@ -5577,6 +5711,7 @@ export class DeviceLinkClient {
this.peerOfflineNotifiedGeneration.clear();
this.outboundRouteGenerationByPeer.clear();
this.settledOutboundRouteGenerationByPeer.clear();
+ this.providerShareSignalRouteIds.clear();
for (const timer of this.timeoutCloseNotifyTimers.values()) clearTimeout(timer);
this.timeoutCloseNotifyTimers.clear();
}
diff --git a/packages/device-link/src/directNegotiation.ts b/packages/device-link/src/directNegotiation.ts
index 9075ac9c2a..72309a92a3 100644
--- a/packages/device-link/src/directNegotiation.ts
+++ b/packages/device-link/src/directNegotiation.ts
@@ -2,6 +2,8 @@ import type { DeviceLinkDirectChannel, DeviceLinkDirectPathHandle } from './dire
/** Optional, end-to-end capability. Signaling always stays on the authenticated relay. */
export const DIRECT_LINK_CAPABILITY = 'direct-link-v1';
+/** Provider-share peers require both this capability and the ordinary direct-link capability. */
+export const PROVIDER_SHARE_DIRECT_CAPABILITY = 'provider-share-direct-v1';
export const DIRECT_LINK_SIGNAL = 'device-link:direct-signal';
export const DIRECT_LINK_MAX_PEERS = 16;
export const DIRECT_LINK_TIMEOUT_MS = 15_000;
@@ -66,6 +68,10 @@ export class DirectLinkNegotiator {
constructor(private readonly deps: {
runtime: DirectRuntime;
identity(): string | null;
+ /** Physical identity for scoped peer keys; the scoped key itself is never an ordering identity. */
+ peerDeviceId?(peer: string): string | null;
+ /** Signaling needs the relay even when an established data channel remains usable. */
+ canSignal?(peer: string): boolean;
streams(peer: string): { local: string; remote: string } | null;
id(): string;
signal(peer: string, signal: DirectSignal): void;
@@ -73,11 +79,12 @@ export class DirectLinkNegotiator {
}) {}
ready(peerId: string): void {
- if (!this.deps.streams(peerId)) return;
+ if (!this.deps.streams(peerId) || this.deps.canSignal?.(peerId) === false) return;
// Both endpoints run this, including a Mobile which only initiated a control link.
// Exactly one creates offers, so mutual control cannot create glare or two channels.
const self = this.deps.identity();
- if (!self || self >= peerId) return;
+ const physicalPeer = this.deps.peerDeviceId ? this.deps.peerDeviceId(peerId) : peerId;
+ if (!self || !physicalPeer || self >= physicalPeer) return;
let peer = this.peers.get(peerId);
if (!peer) {
if (this.peers.size >= DIRECT_LINK_MAX_PEERS) return;
@@ -93,12 +100,14 @@ export class DirectLinkNegotiator {
}
receive(peerId: string, signal: DirectSignal): void {
+ if (this.deps.canSignal?.(peerId) === false) return;
const streams = this.deps.streams(peerId);
if (!streams || signal.stream !== streams.remote || signal.targetStream !== streams.local) return;
let peer = this.peers.get(peerId);
if (signal.action === 'offer') {
const self = this.deps.identity();
- if (!self || peerId >= self) return;
+ const physicalPeer = this.deps.peerDeviceId ? this.deps.peerDeviceId(peerId) : peerId;
+ if (!self || !physicalPeer || physicalPeer >= self) return;
if (!peer) {
if (this.peers.size >= DIRECT_LINK_MAX_PEERS) return;
peer = { failures: 0 };
@@ -115,7 +124,7 @@ export class DirectLinkNegotiator {
} else if (peer?.attempt?.id === signal.id) {
const attempt = peer.attempt;
if (signal.action === 'close') this.fail(peerId, peer, attempt, false);
- else if (this.deps.identity()! < peerId) {
+ else if (this.deps.identity()! < (this.deps.peerDeviceId ? this.deps.peerDeviceId(peerId) ?? '' : peerId)) {
void attempt.session.answer(signal.sdp!).catch(() => this.fail(peerId, peer!, attempt));
}
}
@@ -191,7 +200,7 @@ export class DirectLinkNegotiator {
}
private retry(peerId: string, peer: Peer): void {
if (this.peers.get(peerId) !== peer || peer.retry || !this.deps.streams(peerId)
- || !this.deps.identity() || this.deps.identity()! >= peerId) return;
+ || !this.deps.identity() || this.deps.identity()! >= (this.deps.peerDeviceId ? this.deps.peerDeviceId(peerId) ?? '' : peerId)) return;
const backoff = Math.min(60_000, 5_000 * 2 ** Math.min(peer.failures++, 4));
// Spread simultaneous peer failures even at the cap, without exceeding the retry ceiling.
const delay = Math.floor(backoff * (0.8 + Math.random() * 0.2));
diff --git a/packages/device-link/src/directPath.ts b/packages/device-link/src/directPath.ts
index 5185d350d1..24bd23119e 100644
--- a/packages/device-link/src/directPath.ts
+++ b/packages/device-link/src/directPath.ts
@@ -1,5 +1,5 @@
/**
- * Device Link 直连优先、中继兜底的选路契约(同账号设备之间)。
+ * Device Link 直连优先、中继兜底的选路契约。
*
* relay 仍是控制面:登录、在线状态、link-open / link-accept / link-close 与
* 授权都只走 relay。直连通道(例如局域网内的 WebRTC DataChannel)只承载已建立
@@ -8,8 +8,8 @@
* 两条路径上各到一次也只会执行一次;直连失效时未确认的帧原样改走 relay 重发。
*
* 平台(Desktop / Mobile)负责经已授权的信令建立通道,再交给
- * `DeviceLinkClient.attachDirectPath`。跨账号的共享任务与供应商分享不走直连:
- * 它们的逐帧授权仍由 relay 执行。
+ * `DeviceLinkClient.attachDirectPath`。跨账号供应商分享只在 relay 已建立链路、
+ * 双端声明支持且本地 30 分钟许可有效时可走直连;共享任务仍只走 relay。
*/
/** 平台提供的一条直连通道。 */
@@ -71,3 +71,5 @@ export interface DeviceLinkPeerPathChanged {
/** 直连发送缓冲软上限:暂留可靠队列等 `drained()`,持续无进展则回退 relay。 */
export const DIRECT_PATH_HIGH_WATER_BYTES = 1024 * 1024;
+/** An established provider-share direct path may outlive the relay only for this long. */
+export const PROVIDER_SHARE_DIRECT_LEASE_MS = 30 * 60_000;
diff --git a/packages/device-link/src/remoteAgent.ts b/packages/device-link/src/remoteAgent.ts
index 4338641b68..2a6bc00022 100644
--- a/packages/device-link/src/remoteAgent.ts
+++ b/packages/device-link/src/remoteAgent.ts
@@ -154,6 +154,24 @@ export type RemoteAgentRequest =
| { op: 'caps' }
/** Same-account native history transfer. The host validates commands before accessing storage. */
| { op: 'native-history'; sessionId: string; command: unknown }
+ /** G→O: durable task location only; every use still needs a fresh allocation. */
+ | { op: 'direct-locate'; sessionId: string }
+ /** A shared guest asks the group owner to choose a same-account executor for a short-lived direct route. */
+ | { op: 'allocate'; agentKind: RemoteAgentKind; model: string; sessionId: string;
+ /** Renewal and model changes must stay on the executor holding this task. */
+ preferredExecutorDeviceId?: string }
+ /** Content-free running state for the group's load balancer; expires if reports stop. */
+ | { op: 'direct-status'; sessionId: string; running: boolean }
+ /** G releases only the exact allocation whose direct open failed; a later generation is untouched. */
+ | { op: 'direct-release'; sessionId: string; generation: string }
+ /** A direct guest asks O for its one-use group failover token after a machine-scoped failure. */
+ | { op: 'direct-switch'; sessionId: string }
+ /** Executor reports content-free metering to the group owner with an idempotency key. */
+ | { op: 'direct-usage'; shareId: string; memberId: string; guestDeviceId: string;
+ sessionId: string; generation: string; usageId: string; agentKind: RemoteAgentKind; samples: RemoteAgentUsageSample[] }
+ /** Authenticated same-account group owner installs or removes a guest grant on the executor. */
+ | { op: 'delegate'; action: 'grant' | 'revoke'; shareId: string; memberId: string; guestDeviceId: string;
+ providerId: string; model: string; sessionId: string; generation?: string; cleanupEpoch?: number }
/** Authenticated group owner updates only its own task speed constraints, never model grants. */
| ({ op: 'fast-policy' } & RemoteAgentFastPolicy)
| ({ op: 'fork' } & RemoteAgentForkRequest)
@@ -182,6 +200,9 @@ export type RemoteAgentRequest =
* 只作用于调用方自己的 relay。旧版组内电脑回 REMOTE_AGENT_INVALID(它从没接过被中转的任务)。
*/
| { op: 'forget'; relay: string }
+ /** O asks M to purge a direct G→M guest only when M has persisted O's verified delegation. */
+ | { op: 'forget'; directGuest: { shareId: string; memberId: string; guestDeviceId: string;
+ forgetId: string; cleanupEpoch: number } }
/**
* 供应商组转分享(组所在电脑 → 分享来的组内电脑,调用方是那台的受邀者):组所在电脑把自己分享的人
* 经组使用这台电脑的请求整体报上来(整体替换调用方上一份),那台的主人逐人同意。回包是每一项此刻的结果
@@ -195,7 +216,9 @@ export interface RemoteAgentFastPolicy {
revision: number;
allowFast: boolean;
/** Registration precedes opening the task; omitted for a group policy update. */
- binding?: { sessionId: string; controllerDeviceId?: string; relay?: string };
+ binding?: { sessionId: string; controllerDeviceId?: string; relay?: string;
+ /** Owner-approved direct guest task. The executor verifies its delegation before binding. */
+ providerShareGuest?: { shareId: string; memberId: string; guestDeviceId: string } };
}
/** 供应商组为受邀者取的不透明键(组所在电脑按受邀者派生,不含身份信息);「需要换一台」凭证同一格式。 */
@@ -274,6 +297,8 @@ export interface RemoteAgentCaps {
/** Preserves external-application tools and runtime storage across every relay. */
localApplication?: boolean;
nativeHistoryTransfer?: boolean;
+ /** Executor accepts bounded same-account group-owner delegation for a shared guest. */
+ directGuestExecution?: boolean;
subscriptionFastPolicy?: true;
nativeFork?: boolean;
imageRecovery?: boolean;
@@ -364,6 +389,21 @@ function id(value: unknown): string {
return value;
}
+export interface RemoteAgentUsageSample {
+ model: string; turns: number; inputTokens: number; outputTokens: number;
+ cacheReadTokens: number; cacheCreateTokens: number; sdkCostUsd: number;
+}
+
+function providerShareId(value: unknown): string {
+ if (typeof value !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value)) invalid();
+ return value;
+}
+
+function deviceId(value: unknown): string {
+ if (typeof value !== 'string' || !value || value.length > 128) invalid();
+ return value;
+}
+
function count(value: unknown, max: number): number {
if (!Number.isSafeInteger(value) || (value as number) < 0 || (value as number) > max) invalid();
return value as number;
@@ -450,6 +490,59 @@ export function parseRemoteAgentRequest(value: unknown): RemoteAgentRequest {
if (typeof v.sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(v.sessionId)) invalid();
return { op: 'native-history', sessionId: v.sessionId as string, command: record(v.command) };
}
+ case 'direct-locate':
+ if (typeof v.sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(v.sessionId)) invalid();
+ return { op: 'direct-locate', sessionId: v.sessionId };
+ case 'allocate':
+ if (typeof v.model !== 'string' || !v.model || v.model.length > 512 || v.model.includes('\0')) invalid();
+ if (typeof v.sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(v.sessionId)) invalid();
+ return { op: 'allocate', agentKind: oneOf(v.agentKind, REMOTE_AGENT_KINDS), model: v.model, sessionId: v.sessionId,
+ ...(v.preferredExecutorDeviceId === undefined ? {} : { preferredExecutorDeviceId: deviceId(v.preferredExecutorDeviceId) }) };
+ case 'direct-status':
+ if (typeof v.sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(v.sessionId)
+ || typeof v.running !== 'boolean') invalid();
+ return { op: 'direct-status', sessionId: v.sessionId, running: v.running };
+ case 'direct-release':
+ if (typeof v.sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(v.sessionId)
+ || typeof v.generation !== 'string' || !ID.test(v.generation)) invalid();
+ return { op: 'direct-release', sessionId: v.sessionId, generation: v.generation };
+ case 'direct-switch':
+ if (typeof v.sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(v.sessionId)) invalid();
+ return { op: 'direct-switch', sessionId: v.sessionId };
+ case 'direct-usage': {
+ if (typeof v.sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(v.sessionId)
+ || typeof v.generation !== 'string' || !ID.test(v.generation)
+ || typeof v.usageId !== 'string' || !ID.test(v.usageId)
+ || !Array.isArray(v.samples) || !v.samples.length || v.samples.length > 64) invalid();
+ const samples = v.samples.map((item): RemoteAgentUsageSample => {
+ const sample = record(item);
+ if (typeof sample.model !== 'string' || !sample.model || sample.model.length > 512) invalid();
+ const counters = ['turns', 'inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheCreateTokens', 'sdkCostUsd'] as const;
+ for (const key of counters) if (typeof sample[key] !== 'number' || !Number.isFinite(sample[key])
+ || (sample[key] as number) < 0 || (sample[key] as number) > 1e15) invalid();
+ return { model: sample.model, turns: sample.turns as number, inputTokens: sample.inputTokens as number,
+ outputTokens: sample.outputTokens as number, cacheReadTokens: sample.cacheReadTokens as number,
+ cacheCreateTokens: sample.cacheCreateTokens as number, sdkCostUsd: sample.sdkCostUsd as number };
+ });
+ return { op: 'direct-usage', shareId: providerShareId(v.shareId), memberId: providerShareId(v.memberId),
+ guestDeviceId: deviceId(v.guestDeviceId), sessionId: v.sessionId, generation: v.generation,
+ usageId: v.usageId, agentKind: oneOf(v.agentKind, REMOTE_AGENT_KINDS), samples };
+ }
+ case 'delegate': {
+ const shareId = providerShareId(v.shareId);
+ const memberId = providerShareId(v.memberId);
+ const guestDeviceId = deviceId(v.guestDeviceId);
+ if (typeof v.providerId !== 'string' || !v.providerId || v.providerId.length > 256 || v.providerId.includes('\0')) invalid();
+ if (typeof v.model !== 'string' || !v.model || v.model.length > 512 || v.model.includes('\0')) invalid();
+ if (typeof v.sessionId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(v.sessionId)) invalid();
+ if (v.action === 'grant' && (typeof v.generation !== 'string' || !ID.test(v.generation))) invalid();
+ if (v.generation !== undefined && (typeof v.generation !== 'string' || !ID.test(v.generation))) invalid();
+ if (v.cleanupEpoch !== undefined) count(v.cleanupEpoch, Number.MAX_SAFE_INTEGER);
+ return { op: 'delegate', action: oneOf(v.action, ['grant', 'revoke'] as const), shareId, memberId, guestDeviceId,
+ providerId: v.providerId, model: v.model, sessionId: v.sessionId,
+ ...(typeof v.generation === 'string' ? { generation: v.generation } : {}),
+ ...(v.cleanupEpoch !== undefined ? { cleanupEpoch: v.cleanupEpoch as number } : {}) };
+ }
case 'fast-policy': {
if (typeof v.group !== 'string' || !/^[A-Za-z0-9_.:-]{1,256}$/.test(v.group)
|| typeof v.allowFast !== 'boolean') invalid();
@@ -460,9 +553,20 @@ export function parseRemoteAgentRequest(value: unknown): RemoteAgentRequest {
if (b.controllerDeviceId !== undefined && (typeof b.controllerDeviceId !== 'string'
|| !/^[A-Za-z0-9_.-]{1,128}$/.test(b.controllerDeviceId))) invalid();
if (b.relay !== undefined && (typeof b.relay !== 'string' || !REMOTE_AGENT_RELAY_KEY_PATTERN.test(b.relay))) invalid();
+ let providerShareGuest: { shareId: string; memberId: string; guestDeviceId: string } | undefined;
+ if (b.providerShareGuest !== undefined) {
+ const guest = record(b.providerShareGuest);
+ if (b.controllerDeviceId !== undefined || b.relay !== undefined
+ || typeof guest.shareId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(guest.shareId)
+ || typeof guest.memberId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(guest.memberId)
+ || typeof guest.guestDeviceId !== 'string' || guest.guestDeviceId.length < 1
+ || guest.guestDeviceId.length > 128) invalid();
+ providerShareGuest = { shareId: guest.shareId, memberId: guest.memberId, guestDeviceId: guest.guestDeviceId };
+ }
binding = { sessionId: b.sessionId as string,
...(typeof b.controllerDeviceId === 'string' ? { controllerDeviceId: b.controllerDeviceId } : {}),
- ...(typeof b.relay === 'string' ? { relay: b.relay } : {}) };
+ ...(typeof b.relay === 'string' ? { relay: b.relay } : {}),
+ ...(providerShareGuest ? { providerShareGuest } : {}) };
}
return { op: 'fast-policy', group: v.group as string, allowFast: v.allowFast as boolean,
revision: count(v.revision, Number.MAX_SAFE_INTEGER), ...(binding ? { binding } : {}) };
@@ -567,6 +671,15 @@ export function parseRemoteAgentRequest(value: unknown): RemoteAgentRequest {
reason: oneOf(v.reason, REMOTE_AGENT_TEARDOWN_REASONS),
};
case 'forget':
+ if (v.directGuest !== undefined) {
+ if (v.relay !== undefined) invalid();
+ const guest = record(v.directGuest);
+ return { op: 'forget', directGuest: {
+ shareId: providerShareId(guest.shareId), memberId: providerShareId(guest.memberId),
+ guestDeviceId: deviceId(guest.guestDeviceId), forgetId: id(guest.forgetId),
+ cleanupEpoch: count(guest.cleanupEpoch, Number.MAX_SAFE_INTEGER),
+ } };
+ }
if (typeof v.relay !== 'string' || !REMOTE_AGENT_RELAY_KEY_PATTERN.test(v.relay)) invalid();
return { op: 'forget', relay: v.relay };
case 'reshare': {
@@ -676,6 +789,7 @@ export function parseRemoteAgentCaps(value: unknown): RemoteAgentCaps {
...(v.imageRecovery === true ? { imageRecovery: true } : {}),
...(v.imageRecoveryRelay === true ? { imageRecoveryRelay: true } : {}),
...(v.guestRelay === true ? { guestRelay: true } : {}),
+ ...(v.directGuestExecution === true ? { directGuestExecution: true } : {}),
...(v.relayModelAccess === true ? { relayModelAccess: true } : {}),
...(v.reshareConsent === true ? { reshareConsent: true } : {}),
...(v.reshareBatch === true ? { reshareBatch: true } : {}),
diff --git a/packages/maker-core/src/maker.test.ts b/packages/maker-core/src/maker.test.ts
index 4155562c64..147c035224 100644
--- a/packages/maker-core/src/maker.test.ts
+++ b/packages/maker-core/src/maker.test.ts
@@ -13,7 +13,7 @@ import { tmpdir } from 'node:os';
import path from 'node:path';
import { snapshotDisabledSkillPaths } from './agents/shared/skill-activation.js';
-import { Maker, type CreateSessionOptions, type SessionStartFailureContext } from './maker.js';
+import { Maker, SessionCreationCleanupPendingError, type CreateSessionOptions, type SessionStartFailureContext } from './maker.js';
import { Session } from './session.js';
import { createAsyncQueue } from './agents/shared/async-queue.js';
import {
@@ -882,7 +882,9 @@ describe('Maker session creation singleflight', () => {
};
await expect(maker.createSession(options)).rejects.toThrow('db lock');
- await expect(maker.createSession(options)).rejects.toThrow('termination unconfirmed');
+ const pendingCleanup = await maker.createSession(options).catch(error => error);
+ expect(pendingCleanup).toBeInstanceOf(SessionCreationCleanupPendingError);
+ expect(pendingCleanup.cause).toMatchObject({ message: 'termination unconfirmed' });
expect(startSession).toHaveBeenCalledTimes(1);
cleanupCanSucceed = true;
@@ -4505,3 +4507,175 @@ describe('Maker invalid-resume persistence bridge', () => {
await maker.closeSession('session-1');
});
});
+
+// F6-A, unit: cancellation must fence real Maker dedup/publication, not only
+// Desktop's outer promise. Deferred native/storage boundaries are the inputs.
+describe('cancelled creation ownership', () => {
+ it.each(['prepare', 'native', 'storage', 'succeeded'] as const)(
+ 'cleans a cancelled %s attempt before starting its replacement', async stage => {
+ const gate = createDeferred();
+ const entered = createDeferred();
+ const storage = createStorage();
+ const oldHandle = createHandle({ id: 'old-native' });
+ const newHandle = createHandle({ id: 'new-native' });
+ const closed = vi.spyOn(oldHandle, 'close');
+ let starts = 0;
+ const pause = async () => { entered.resolve(); await gate.promise; };
+ const write = storage.create.bind(storage);
+ if (stage === 'storage') storage.create = async input => {
+ const row = await write(input);
+ if (starts === 1) await pause();
+ return row;
+ };
+ let prepared = 0;
+ const maker = new Maker({
+ agents: { codex: createAgent(async () => {
+ starts++;
+ if (stage === 'native' && starts === 1) await pause();
+ return starts === 1 ? oldHandle : newHandle;
+ }) }, storage, logger: createLogger(),
+ lifecycleHooks: {
+ prepareStartOptions: async () => { if (stage === 'prepare' && prepared++ === 0) await pause(); },
+ onStartSucceeded: async () => { if (stage === 'succeeded' && starts === 1) await pause(); },
+ },
+ });
+ const created = vi.fn();
+ maker.on(e => { if (e.type === 'session:created') created(e.session); });
+ const opts: CreateSessionOptions = { id: 'cancelled-task', agentKind: 'codex', workingDir: '/repo', model: 'm' };
+ const signal = new AbortController();
+ const old = maker.createSession(opts, signal.signal).catch(e => e);
+ await entered.promise;
+ signal.abort(new Error('cancelled attempt'));
+ const replacement = maker.createSession(opts);
+ gate.resolve();
+ expect(String(await old)).toContain('cancelled attempt');
+ const current = await replacement;
+ expect(current.getStatus()).toBe('active');
+ expect(maker.getSession(opts.id!)).toBe(current);
+ expect(created).toHaveBeenCalledTimes(1);
+ expect(starts).toBe(stage === 'prepare' ? 1 : 2);
+ expect(closed).toHaveBeenCalledTimes(stage === 'prepare' ? 0 : 1);
+ if (stage === 'storage' || stage === 'succeeded') {
+ expect(await storage.get(opts.id!)).toMatchObject({ sdkSessionId: 'new-native' });
+ }
+ await maker.shutdown();
+ },
+ );
+
+ it('bounds replacement waits without losing the old cleanup barrier or another task', async () => {
+ vi.useFakeTimers();
+ const gate = createDeferred();
+ const oldHandle = createHandle({ id: 'old-native' });
+ const closed = vi.spyOn(oldHandle, 'close');
+ let starts = 0;
+ const maker = new Maker({ agents: { codex: createAgent(async () => {
+ if (++starts === 1) { await gate.promise; return oldHandle; }
+ return createHandle({ id: 'native-' + starts });
+ }) }, storage: createStorage(), logger: createLogger() });
+ const opts: CreateSessionOptions = { id: 'cancelled-task', agentKind: 'codex', workingDir: '/repo', model: 'm' };
+ const cancel = new AbortController();
+ const old = maker.createSession(opts, cancel.signal).catch(e => e);
+ cancel.abort(new Error('cancelled attempt'));
+ try {
+ const waiting = maker.createSession(opts).catch(e => e);
+ await vi.advanceTimersByTimeAsync(1000);
+ expect(String(await waiting)).toContain('cleanup is still pending; retry');
+ expect(starts).toBe(1);
+ expect(vi.getTimerCount()).toBe(0);
+ const sibling = await maker.createSession({ ...opts, id: 'sibling' });
+ expect(sibling.getStatus()).toBe('active');
+ const nextCancel = new AbortController();
+ const nextWait = maker.createSession(opts, nextCancel.signal).catch(e => e);
+ const abortReason = new Error('replacement cancelled');
+ nextCancel.abort(abortReason);
+ const aborted = await nextWait;
+ expect(aborted).toBe(abortReason);
+ expect(String(aborted)).toContain('replacement cancelled');
+ expect(vi.getTimerCount()).toBe(0);
+ gate.resolve();
+ expect(String(await old)).toContain('cancelled attempt');
+ expect(closed).toHaveBeenCalledTimes(1);
+ const replacement = await maker.createSession(opts);
+ expect(replacement.getStatus()).toBe('active');
+ expect(maker.getSession('sibling')).toBe(sibling);
+ await maker.shutdown();
+ } finally { gate.resolve(); vi.useRealTimers(); }
+ });
+
+ it('does not begin an already cancelled creation, including anonymous starts', async () => {
+ const start = vi.fn(async () => createHandle({ id: 'native' }));
+ const maker = new Maker({ agents: { codex: createAgent(start) }, storage: createStorage(), logger: createLogger() });
+ const abort = new AbortController(); abort.abort(new Error('cancelled attempt'));
+ await expect(maker.createSession({ agentKind: 'codex', workingDir: '/repo', model: 'm' }, abort.signal)).rejects.toThrow('cancelled attempt');
+ expect(start).not.toHaveBeenCalled();
+ const normal = await maker.createSession({ agentKind: 'codex', workingDir: '/repo', model: 'm' });
+ expect(normal.getStatus()).toBe('active');
+ await maker.shutdown();
+ });
+});
+
+// F6-A handoff: Maker may have published before Desktop's final role await.
+it('does not reuse a published session while cancelled creation cleanup is pending', async () => {
+ const gate = createDeferred();
+ const firstHandle = createHandle({ id: 'first-native' });
+ const close = vi.spyOn(firstHandle, 'close').mockImplementation(() => gate.promise);
+ const start = vi.fn().mockResolvedValueOnce(firstHandle).mockResolvedValueOnce(createHandle({ id: 'second-native' }));
+ const maker = new Maker({ agents: { codex: createAgent(start) }, storage: createStorage(), logger: createLogger() });
+ const opts: CreateSessionOptions = { id: 'cancelled-role-task', agentKind: 'codex', workingDir: '/repo', model: 'm' };
+ const first = await maker.createSession(opts);
+ const closing = maker.closeSessionIfCurrent(first);
+ const replacement = maker.createSession(opts);
+ expect(start).toHaveBeenCalledTimes(1);
+ gate.resolve(); await closing;
+ const second = await replacement;
+ expect(second).not.toBe(first);
+ expect(second.getStatus()).toBe('active');
+ expect(maker.getSession(opts.id!)).toBe(second);
+ expect(close).toHaveBeenCalledTimes(1);
+ await maker.shutdown();
+});
+
+// F6-C, unit: rejected cleanup (not only timeout) must remain distinguishable
+// from a failed native startup; otherwise hosts may relocate route/history.
+it.each(['unpublished', 'published'] as const)(
+ 'classifies rejected %s cleanup without losing ownership or its cause', async publication => {
+ const gate = createDeferred();
+ const cleanupError = new Error('termination unconfirmed');
+ const oldHandle = createHandle({ id: 'old-native' });
+ let cleanupAllowed = false;
+ const close = vi.spyOn(oldHandle, 'close').mockImplementation(async () => {
+ if (!cleanupAllowed) throw cleanupError;
+ });
+ let starts = 0;
+ const storage = createStorage();
+ const maker = new Maker({ agents: { codex: createAgent(async () => {
+ if (++starts === 1) { await gate.promise; return oldHandle; }
+ return createHandle({ id: 'replacement-native' });
+ }) }, storage, logger: createLogger() });
+ const options: CreateSessionOptions = { id: 'cleanup-owner', agentKind: 'codex', workingDir: '/repo', model: 'm' };
+ const abort = new AbortController();
+ const starting = maker.createSession(options, abort.signal);
+ const settled = starting.catch(error => error);
+ if (publication === 'unpublished') abort.abort(new Error('cancelled startup'));
+ gate.resolve();
+ if (publication === 'published') {
+ const session = await starting;
+ await expect(maker.closeSessionIfCurrent(session)).rejects.toBe(cleanupError);
+ } else {
+ expect(String(await settled)).toContain('cancelled startup');
+ }
+ const beforeRetry = await storage.get(options.id!);
+ const failed = await maker.createSession(options).catch(error => error);
+ expect(failed).toBeInstanceOf(SessionCreationCleanupPendingError);
+ expect(failed.cause).toBe(cleanupError);
+ expect(starts).toBe(1);
+ expect(close).toHaveBeenCalledTimes(2);
+ expect(await storage.get(options.id!)).toEqual(beforeRetry);
+ cleanupAllowed = true;
+ const replacement = await maker.createSession(options);
+ expect(starts).toBe(2);
+ expect(replacement.getStatus()).toBe('active');
+ expect(maker.getSession(options.id!)).toBe(replacement);
+ await maker.shutdown();
+ },
+);
diff --git a/packages/maker-core/src/maker.ts b/packages/maker-core/src/maker.ts
index 4aad186be7..9ded1cb953 100644
--- a/packages/maker-core/src/maker.ts
+++ b/packages/maker-core/src/maker.ts
@@ -161,6 +161,14 @@ export interface MakerDeps {
toolLoopReviewer?: import('./agents/shared/tool-loop-review.js').ToolLoopReviewer;
}
+/** A previous attempt still owns native resources; retry without changing route/history. */
+export class SessionCreationCleanupPendingError extends Error {
+ constructor(options?: ErrorOptions) {
+ super('Previous session startup cleanup is still pending; retry the task.', options);
+ this.name = 'SessionCreationCleanupPendingError';
+ }
+}
+
export interface CreateSessionOptions extends StartSessionOptions {
/** Host caller preferences before generated context; retained only by the live Session. */
hostStartupPreferences?: SessionStartupPreferences;
@@ -497,7 +505,7 @@ export class Maker {
*/
private readonly inFlightSessionCreations = new Map<
string,
- { promise: Promise<Session> }
+ { promise: Promise<Session>; signal?: AbortSignal }
>();
/** All create paths, including anonymous ids, that may still publish or quarantine a handle. */
private readonly pendingSessionCreations = new Set<Promise<Session>>();
@@ -643,11 +651,12 @@ export class Maker {
* 同 id 已有 active Session 或正在创建时直接复用 —— 适配"用户切回老 session
* 继续聊"以及多个后台入口同时恢复同一会话的场景。
*/
- async createSession(opts: CreateSessionOptions): Promise<Session> {
+ async createSession(opts: CreateSessionOptions, signal?: AbortSignal): Promise<Session> {
+ signal?.throwIfAborted();
if (this.shutdownStarted) {
throw new Error('Maker is shutting down; refusing to create a new session');
}
- const creation = this.createSessionWhileRunning(opts);
+ const creation = this.createSessionWhileRunning(opts, signal);
this.pendingSessionCreations.add(creation);
try {
return await creation;
@@ -656,15 +665,48 @@ export class Maker {
}
}
- private async createSessionWhileRunning(opts: CreateSessionOptions): Promise<Session> {
+ /** Keep replacement startup bounded without abandoning native cleanup ownership. */
+ private waitForSessionCleanup(cleanup: Promise<unknown>, signal?: AbortSignal): Promise<void> {
+ return new Promise<void>((resolve, reject) => {
+ let done = false;
+ const finish = (failed: boolean, error?: unknown) => {
+ if (done) return;
+ done = true;
+ clearTimeout(timeout);
+ signal?.removeEventListener('abort', abort);
+ if (failed) reject(error); else resolve();
+ };
+ const timeout = setTimeout(() => finish(true, new SessionCreationCleanupPendingError()), 1000);
+ const abort = () => finish(true, signal?.reason);
+ signal?.addEventListener('abort', abort, { once: true });
+ if (signal?.aborted) abort();
+ // Cleanup rejection still means native ownership is unresolved. Keep it
+ // distinct from the caller's abort reason so hosts cannot enter fallback.
+ void cleanup.then(() => finish(false), error => finish(true,
+ new SessionCreationCleanupPendingError({ cause: error })));
+ });
+ }
+
+ private async createSessionWhileRunning(opts: CreateSessionOptions, signal?: AbortSignal): Promise<Session> {
+ signal?.throwIfAborted();
if (!opts.id) {
- return this.createSessionOnce(opts);
+ return this.createSessionOnce(opts, signal);
}
// Any handle that failed cleanup before publication still owns this
// business id. Confirm its shutdown before checking/starting live state.
if (this.failedHandleCleanups.has(opts.id)) {
- await this.retryFailedHandleCleanup(opts.id);
+ await this.waitForSessionCleanup(this.retryFailedHandleCleanup(opts.id), signal);
+ signal?.throwIfAborted();
+ }
+
+ // A cancelled creation still owns its native startup until cleanup settles.
+ // Never hand that promise to a replacement. Bound this wait so a hung
+ // adapter cannot indefinitely hold a new caller; retries retain the barrier.
+ const cancelled = this.inFlightSessionCreations.get(opts.id);
+ if (cancelled?.signal?.aborted) {
+ await this.waitForSessionCleanup(cancelled.promise.then(() => undefined, () => undefined), signal);
+ return this.createSessionWhileRunning(opts, signal);
}
// 进程内已经活着或正在启动的 session, 直接复用 (避免 spawn 第二个 SDK)。
@@ -672,8 +714,13 @@ export class Maker {
// 摘掉并与可能仍存活的底层 transport 并存。先重试同一个 close;只有真实
// 关闭成功、status listener 将其移除后,才允许创建新的 handle。
const existing = this.activeSessions.get(opts.id);
+ if (existing?.hasStartedClosing()) {
+ await this.waitForSessionCleanup(existing.close(), signal);
+ return this.createSessionWhileRunning(opts, signal);
+ }
if (existing?.getStatus() === 'error') {
await existing.close();
+ signal?.throwIfAborted();
}
const reusable = this.activeSessions.get(opts.id);
if (reusable) return reusable;
@@ -681,7 +728,7 @@ export class Maker {
const inFlight = this.inFlightSessionCreations.get(opts.id);
if (inFlight) return inFlight.promise;
- const creation = { promise: this.createSessionOnce(opts) };
+ const creation = { promise: this.createSessionOnce(opts, signal), signal };
this.inFlightSessionCreations.set(opts.id, creation);
try {
return await creation.promise;
@@ -694,7 +741,8 @@ export class Maker {
}
/** 执行一次真实 session startup;带 id 的并发去重由 createSession 统一负责。 */
- private async createSessionOnce(opts: CreateSessionOptions): Promise<Session> {
+ private async createSessionOnce(opts: CreateSessionOptions, signal?: AbortSignal): Promise<Session> {
+ signal?.throwIfAborted();
// Visible application tasks use the ordinary persistence path, but their
// remote engine need not be installed on this controller either.
const agent = opts[LOCAL_AGENT_CLIENT] && opts.agentDeviceId
@@ -757,6 +805,7 @@ export class Maker {
if (this.lifecycleHooks.prepareStartOptions) {
try {
await this.lifecycleHooks.prepareStartOptions(id, startOpts);
+ signal?.throwIfAborted();
} catch (error) {
await notifyStartFailed('prepare', error);
throw error;
@@ -814,6 +863,7 @@ export class Maker {
? (expectedSdkSessionId) => this.invalidateAndClearSdkSessionId(id, expectedSdkSessionId)
: undefined;
try {
+ signal?.throwIfAborted();
if (opts.agentKind === 'codex' && isClaimableCodexThreadId(startOpts.resumeSessionId)) {
codexThreadClaim = this.claimCodexThread({
sessionId: id,
@@ -881,6 +931,26 @@ export class Maker {
}
throw startupError;
}
+ const rejectCancelledStartup = async (): Promise<never> => {
+ let cleanupFailed = false;
+ try {
+ await handle.close({ reason: 'navigation' });
+ } catch (closeError) {
+ cleanupFailed = true;
+ this.failedHandleCleanups.set(id, {
+ handle, promise: null,
+ onCleaned: () => { codexThreadClaim?.release(); notifyStartCleanupSucceeded(); },
+ });
+ this.logger.warn('failed to close cancelled startup', { sessionId: id, error: String(closeError) });
+ }
+ if (!cleanupFailed) codexThreadClaim?.release();
+ // Keep already-assigned native history. This unpublished handle must not
+ // run ordinary Session.onClose or release durable task/worktree ownership.
+ const error = signal?.reason ?? new Error('Session startup cancelled');
+ await notifyStartFailed('agent-start', error, cleanupFailed);
+ throw error;
+ };
+ if (signal?.aborted) return rejectCancelledStartup();
if (opts.agentKind === 'codex' && isClaimableCodexThreadId(handle.id)) {
try {
if (codexThreadClaim) {
@@ -952,6 +1022,7 @@ export class Maker {
let updatedSdkSessionId = false;
try {
existingRowBeforePersistence = opts.id ? await this.storage.get(opts.id) : null;
+ signal?.throwIfAborted();
if (existingRowBeforePersistence) {
updatedSdkSessionId = handle.id !== '<pending>'
&& existingRowBeforePersistence.sdkSessionId !== handle.id;
@@ -1010,6 +1081,8 @@ export class Maker {
throw error;
}
+ if (signal?.aborted) return rejectCancelledStartup();
+
const rollbackStaleLocalPiMetadata = async (): Promise<void> => {
const current = await this.storage.get(id);
if (createdMetadata) {
@@ -1088,6 +1161,7 @@ export class Maker {
}
}
+ if (signal?.aborted) return rejectCancelledStartup();
if (this.lifecycleHooks.onStartSucceeded) {
try {
await this.lifecycleHooks.onStartSucceeded(id, startOpts);
@@ -1106,6 +1180,7 @@ export class Maker {
return rejectStaleLocalPiAfterPersistence();
}
+ if (signal?.aborted) return rejectCancelledStartup();
const session = new Session({
id: meta.id,
sessionInstanceId,
diff --git a/scripts/__tests__/restart-desktop-remote.test.mjs b/scripts/__tests__/restart-desktop-remote.test.mjs
index 530ad4363f..faa9a5dcf4 100644
--- a/scripts/__tests__/restart-desktop-remote.test.mjs
+++ b/scripts/__tests__/restart-desktop-remote.test.mjs
@@ -1041,6 +1041,16 @@ test("devEnvPrefix passes harness envs through on Windows cmd with quote strippi
);
});
+test("devEnvPrefix forwards only the requested local relay override and unsets stale macOS values", () => {
+ const env = { XDT_DEVICE_LINK_LOCAL_URL: "http://127.0.0.1:33355", XDT_DEVICE_LINK_CN_LOCAL_URL: "http://127.0.0.1:33355", XDT_DEVICE_LINK_GLOBAL_LOCAL_URL: "http://127.0.0.1:33356" };
+ assert.ok(devEnvPrefix(env, "darwin").includes("XDT_DEVICE_LINK_LOCAL_URL='http://127.0.0.1:33355'"));
+ assert.ok(devEnvPrefix(env, "win32").includes('set "XDT_DEVICE_LINK_LOCAL_URL=http://127.0.0.1:33355"'));
+ assert.ok(darwinStaleDevEnvUnset({}).includes("XDT_DEVICE_LINK_LOCAL_URL"));
+ assert.ok(devEnvPrefix(env, "darwin").includes("XDT_DEVICE_LINK_GLOBAL_LOCAL_URL='http://127.0.0.1:33356'"));
+ assert.ok(devEnvPrefix(env, "win32").includes('set "XDT_DEVICE_LINK_CN_LOCAL_URL=http://127.0.0.1:33355"'));
+ assert.ok(darwinStaleDevEnvUnset({}).includes("XDT_DEVICE_LINK_GLOBAL_LOCAL_URL"));
+});
+
test("devEnvPrefix carries the Cindy Make test-window marker through restart", () => {
assert.equal(
devEnvPrefix({ XDT_CINDY_MAKE_TEST: "1" }, "darwin"),
diff --git a/scripts/provider-share-direct-smoke.mjs b/scripts/provider-share-direct-smoke.mjs
new file mode 100644
index 0000000000..1b775db28d
--- /dev/null
+++ b/scripts/provider-share-direct-smoke.mjs
@@ -0,0 +1,346 @@
+// Real Chromium WebRTC with four production DeviceLinkClient instances.
+// The relay and allocation fixture authenticates a pre-approved guest and short executor routes.
+// Usage: node scripts/provider-share-direct-smoke.mjs <Chrome executable>
+// Native mDNS regression: node scripts/provider-share-direct-smoke.mjs --electron-mdns
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { networkInterfaces, tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+
+const require = createRequire(new URL('../apps/desktop/package.json', import.meta.url));
+const { build } = require('esbuild');
+const { chromium, _electron: electron } = require('playwright-core');
+if (process.argv[2] === '--electron-mdns') {
+ await electronMdnsSmoke();
+} else {
+const executablePath = process.argv[2];
+if (!executablePath) throw new Error('Pass a Chrome executable');
+const output = await build({ stdin: {
+ contents: `export { DeviceLinkClient } from './packages/device-link/src/client.ts';
+ export { createDirectRtcRuntime } from './packages/device-link/src/directRtcRuntime.ts';
+ export { providerShareHostPeer, providerShareGuestPeer } from './packages/device-link/src/providerSharePeer.ts';
+ export { parseRemoteAgentRequest } from './packages/device-link/src/remoteAgent.ts';`,
+ resolveDir: fileURLToPath(new URL('../', import.meta.url)),
+}, bundle: true, write: false, format: 'iife', globalName: 'ProviderShareSmoke', platform: 'browser' });
+
+const browser = await chromium.launch({ executablePath, headless: true, chromiumSandbox: true });
+try {
+ const page = await browser.newPage();
+ await page.addScriptTag({ content: output.outputFiles[0].text });
+ const result = await page.evaluate(async () => {
+ const { DeviceLinkClient, createDirectRtcRuntime, providerShareHostPeer, providerShareGuestPeer,
+ parseRemoteAgentRequest } = ProviderShareSmoke;
+ const sockets = new Map(), physical = [], rtcSessions = [], errors = [];
+ const guest = providerShareGuestPeer('share', 'member', 'guest');
+ const owner = providerShareHostPeer('share', 'owner');
+ const executor = providerShareHostPeer('share', 'executor');
+ let relayOnline = true, granted = false, executorAvailable = true, executed = 0, ownerContent = 0;
+ let ownerRoute = null, defaultExecutor = 'executor';
+ const wait = async (predicate, label) => {
+ const deadline = Date.now() + 20_000;
+ while (!predicate()) {
+ if (Date.now() > deadline) throw new Error(`timeout ${label}: ${JSON.stringify(errors)}`);
+ await new Promise(resolve => setTimeout(resolve, 10));
+ }
+ };
+ function runtime() {
+ const rtc = createDirectRtcRuntime();
+ return { create(id, events) {
+ const session = rtc.create(id, events);
+ rtcSessions.push(session);
+ return session;
+ } };
+ }
+ function client(id) {
+ return new DeviceLinkClient({ directRuntime: runtime(), getWsUrl: () => 'ws://fixture.invalid',
+ getToken: async () => 'fixture',
+ getHello: () => ({ deviceName: id, platform: 'browser', appVersion: '1', remoteControlEnabled: true, busy: false,
+ capabilities: ['provider-share-v1'] }),
+ logger: { debug() {}, info() {}, warn: (...args) => errors.push(args.join(' ')),
+ error: (...args) => errors.push(args.join(' ')) },
+ createWebSocket() {
+ const handlers = new Map();
+ const ws = { bufferedAmount: 0, on(event, callback) { handlers.set(event, callback); },
+ close() { sockets.delete(id); handlers.get('close')?.({ code: 1012, reason: 'restart' }); },
+ deliver(env) { handlers.get('message')?.({ toString: () => JSON.stringify(env) }); },
+ send(text) {
+ if (!relayOnline) return;
+ const env = JSON.parse(text);
+ physical.push({ from: id, ...env });
+ if (env.kind === 'hello') {
+ setTimeout(() => ws.deliver({ v: 1, kind: 'hello-ack', payload: {
+ serverProtocolVersion: 1, deviceId: id, userId: id === 'guest' ? 'guest-account' : 'owner-account',
+ capabilities: ['provider-share-v1', 'provider-share-direct-signal-v1'],
+ } }), 0);
+ } else if (env.kind === 'ping') setTimeout(() => ws.deliver({ v: 1, kind: 'pong' }), 0);
+ else {
+ const scoped = env.providerShare;
+ if (scoped && ((id === 'guest' && env.dst === 'owner')
+ || (id === 'guest' && env.dst === 'executor' && granted)
+ || (id === 'owner' && env.dst === 'guest')
+ || (id === 'executor' && env.dst === 'guest' && granted))) {
+ const source = id === 'guest' ? { role: 'guest', memberId: 'member' } : { role: 'host' };
+ setTimeout(() => sockets.get(env.dst)?.deliver({ ...env, src: id,
+ providerShare: { ...scoped, source } }), 0);
+ } else if (!scoped && id === 'owner' && env.dst === 'executor') {
+ setTimeout(() => sockets.get('executor')?.deliver({ ...env, src: id }), 0);
+ }
+ }
+ },
+ };
+ if (relayOnline) { sockets.set(id, ws); setTimeout(() => handlers.get('open')?.(), 0); }
+ else setTimeout(() => handlers.get('close')?.({ code: 1012, reason: 'restart' }), 0);
+ return ws;
+ }, timing: { transportRetryIntervalMs: 500, requestTimeoutMs: 20_000 },
+ });
+ }
+ const g = client('guest'), m = client('executor'), m2 = client('executor2');
+ let o = client('owner');
+ function attachOwner(ownerClient) { ownerClient.onFrame(env => {
+ if (env.kind === 'link-open') ownerClient.sendLinkAccept(env.src, env.id, {
+ appVersion: '1', allowlistHash: 'fixture', capabilities: ['provider-share-v1'],
+ });
+ if (env.kind === 'invoke') {
+ const command = env.payload?.args?.[0];
+ if (command?.op === 'allocate') {
+ const request = parseRemoteAgentRequest(command);
+ const selected = request.preferredExecutorDeviceId ?? ownerRoute ?? defaultExecutor;
+ if (selected === 'executor' && executorAvailable) {
+ granted = true;
+ ownerRoute = selected;
+ ownerClient.sendInvokeResult(env.src, env.id, { ok: true, result: { deviceId: selected } });
+ } else if (selected === 'executor2' && !request.preferredExecutorDeviceId) {
+ ownerRoute = selected;
+ ownerClient.sendInvokeResult(env.src, env.id, { ok: true, result: { deviceId: selected } });
+ } else ownerClient.sendInvokeResult(env.src, env.id, { ok: true, result: null });
+ } else { ownerContent++; ownerClient.sendInvokeResult(env.src, env.id, { ok: false, error: { code: 'DENIED', message: 'owner is control only' } }); }
+ }
+ }); }
+ attachOwner(o);
+ m.onFrame(env => {
+ if (env.kind === 'link-open' && granted) m.sendLinkAccept(env.src, env.id, {
+ appVersion: '1', allowlistHash: 'fixture', capabilities: ['provider-share-v1'],
+ });
+ if (env.kind === 'invoke' && granted) {
+ executed++;
+ m.sendInvokeResult(env.src, env.id, { ok: true, result: env.payload?.args?.[0] });
+ }
+ });
+ let stage = 'startup';
+ try {
+ for (const client of [g, o, m, m2]) client.start();
+ await wait(() => [g, o, m, m2].every(client => client.getStatus() === 'online'), 'online');
+ await g.openLink(owner, { controllerName: 'Guest', protocolVersion: 1, appVersion: '1', capabilities: ['provider-share-v1'] });
+ const allocate = (preferredExecutorDeviceId) => g.invoke(owner, { channel: 'maker:remote-agent:v1', args: [{
+ op: 'allocate', agentKind: 'pi', model: 'model-a', sessionId: 'task-1',
+ ...(preferredExecutorDeviceId ? { preferredExecutorDeviceId } : {}),
+ }] });
+ stage = 'initial allocation';
+ const allocation = await allocate();
+ if (allocation.result?.deviceId !== 'executor') throw new Error('group owner did not assign executor');
+ await g.openLink(executor, { controllerName: 'Guest', protocolVersion: 1, appVersion: '1', capabilities: ['provider-share-v1'] });
+ await wait(() => g.getPeerPath(executor) === 'direct' && m.getPeerPath(guest) === 'direct', 'G-M direct');
+ const large = '三台电脑局域网😀'.repeat(50_000);
+ const before = physical.length;
+ const direct = await g.invoke(executor, { channel: 'maker:remote-agent:v1', args: [large] });
+ const relayBusiness = physical.slice(before).filter(frame => frame.kind === 'invoke' || frame.kind === 'invoke-result');
+ if (direct.result !== large || relayBusiness.length || ownerContent) throw new Error('content traversed group owner or relay');
+ relayOnline = false;
+ for (const ws of sockets.values()) ws.close();
+ await wait(() => [g, o, m, m2].every(client => client.getStatus() !== 'online'), 'relay restart');
+ const outage = await g.invoke(executor, { channel: 'maker:remote-agent:v1', args: ['during 1012'] });
+ if (outage.result !== 'during 1012') throw new Error('direct path did not survive relay restart');
+ // A fresh O process has lost its in-memory route and would now prefer M2.
+ o.stop();
+ ownerRoute = null;
+ defaultExecutor = 'executor2';
+ relayOnline = true;
+ o = client('owner');
+ attachOwner(o);
+ o.start();
+ for (const client of [g, m, m2]) client.connectNow();
+ await wait(() => [g, o, m, m2].every(client => client.getStatus() === 'online'), 'relay recovery');
+ await g.openLink(owner, { controllerName: 'Guest', protocolVersion: 1, appVersion: '1', capabilities: ['provider-share-v1'] });
+ stage = 'allocation after owner restart';
+ const renewal = await allocate('executor');
+ if (renewal.result?.deviceId !== 'executor') throw new Error('owner restart moved the live task to M2');
+ executorAvailable = false;
+ stage = 'unavailable executor refusal';
+ const refused = await allocate('executor');
+ if (refused.result !== null) throw new Error('unavailable current executor silently switched to M2');
+ executorAvailable = true;
+ for (const session of rtcSessions) session.close();
+ await wait(() => g.getPeerPath(executor) === 'relay', 'direct path close');
+ const fallbackBefore = physical.length;
+ stage = 'relay fallback';
+ const fallback = await g.invoke(executor, { channel: 'maker:remote-agent:v1', args: ['relay fallback'] });
+ if (fallback.result !== 'relay fallback' || executed !== 3) throw new Error('relay fallback duplicated or lost work');
+ const fallbackFrames = physical.slice(fallbackBefore).filter(frame => frame.kind === 'invoke' && frame.dst === 'executor');
+ if (!fallbackFrames.length) throw new Error('fallback did not use G-M device-link relay');
+ return { peers: 4, directBytes: new TextEncoder().encode(large).length, relayBusinessDuringDirect: relayBusiness.length,
+ outageResult: outage.result, renewalExecutor: renewal.result.deviceId, unavailableExecutorRefused: refused.result === null,
+ fallbackFrames: fallbackFrames.length, executorRuns: executed, ownerContent, errors };
+ } catch (error) { throw new Error(`${stage}: ${String(error)}; warnings=${JSON.stringify(errors)}`); }
+ finally { for (const client of [g, o, m, m2]) client.stop(); }
+ });
+ assert.equal(result.ownerContent, 0);
+ console.log(JSON.stringify(result, null, 2));
+} finally { await browser.close(); }
+}
+
+/** Real production Desktop runtime -> isolated capture window -> preload -> RTC.
+ * Only the logger is replaced to avoid touching any Cindy user/log directory.
+ * Each endpoint has its own Electron process and TEMP profile. Signal names are
+ * deliberately unresolvable, so same-host mDNS cannot make the baseline pass.
+ * This is a transport experiment; the Chrome mode above tests authorized relay
+ * routing with a server fixture, neither mode substitutes for real-account E2E.
+ */
+async function electronMdnsSmoke() {
+ const root = fileURLToPath(new URL('../', import.meta.url));
+ const dir = await mkdtemp(join(tmpdir(), 'cindy-direct-mdns-'));
+ await mkdir(join(dir, 'main'), { recursive: true });
+ await mkdir(join(dir, 'renderer/mdns/assets'), { recursive: true });
+ await writeFile(join(dir, 'package.json'), JSON.stringify({ name: 'cindy-mdns-smoke', version: '1.0.0', main: 'main/main.cjs' }));
+ await writeFile(join(dir, 'renderer/mdns/index.html'), '<!doctype html><script src="assets/runtime.js"></script>');
+ await build({ entryPoints: [join(root, 'apps/desktop/src/preload/desktopCapturePreload.ts')],
+ bundle: true, platform: 'node', format: 'cjs', external: ['electron'], outfile: join(dir, 'main/desktopCapturePreload.js') });
+ await build({ stdin: { resolveDir: root, contents: `
+ import { startDirectLinkHost } from './apps/desktop/src/capture-renderer/directLinkHost.ts';
+ const NativeRTC = window.RTCPeerConnection;
+ window.probeConnections = [];
+ window.RTCPeerConnection = class extends NativeRTC {
+ constructor(config) { super(config); window.probeConnections.push(this); }
+ };
+ startDirectLinkHost(window.directLinkHost);
+ ` }, bundle: true, platform: 'browser', format: 'iife', outfile: join(dir, 'renderer/mdns/assets/runtime.js') });
+ await build({ stdin: { resolveDir: root, contents: `
+ import { app, protocol } from 'electron';
+ import { mkdirSync } from 'node:fs';
+ import { desktopDirectRuntime } from './apps/desktop/src/main/device-link/directLink.ts';
+ const profile = process.env.CINDY_MDNS_SMOKE_PROFILE;
+ if (!profile) throw new Error('ISOLATED_PROFILE_REQUIRED');
+ mkdirSync(profile, { recursive: true });
+ app.setPath('userData', profile);
+ app.setPath('sessionData', profile);
+ protocol.registerSchemesAsPrivileged([{ scheme: 'cindy-desktop-capture',
+ privileges: { standard: true, secure: true, supportFetchAPI: true } }]);
+ app.on('window-all-closed', () => {});
+ globalThis.probe = { runtime: desktopDirectRuntime };
+ ` }, bundle: true, platform: 'node', format: 'cjs', external: ['electron'],
+ define: { DESKTOP_CAPTURE_VITE_DEV_SERVER_URL: 'undefined', DESKTOP_CAPTURE_VITE_NAME: JSON.stringify('mdns') },
+ plugins: [{ name: 'isolated-logger', setup(b) {
+ b.onResolve({ filter: /(?:^|\/)logger$/ }, () => ({ path: 'logger', namespace: 'smoke' }));
+ b.onLoad({ filter: /.*/, namespace: 'smoke' }, () => ({ contents: 'export const createLogger = () => ({warn(){},error(){},info(){},debug(){}});' }));
+ } }], outfile: join(dir, 'main/main.cjs') });
+ const env = { ...process.env };
+ delete env.ELECTRON_RUN_AS_NODE;
+ const apps = [];
+ try {
+ for (const endpoint of ['a', 'b']) apps.push(await electron.launch({ executablePath: require('electron'),
+ args: [dir], env: { ...env, CINDY_MDNS_SMOKE_PROFILE: join(dir, `profile-${endpoint}`) }, timeout: 20_000 }));
+ console.log(JSON.stringify({ experiment: 'electron-mdns', temp: dir,
+ // Counts only: never print SDP, interface names or addresses.
+ externalIpv4Interfaces: Object.values(networkInterfaces()).filter(entries =>
+ entries?.some(entry => entry.family === 'IPv4' && !entry.internal)).length,
+ versions: await apps[0].evaluate(() => ({ electron: process.versions.electron, chromium: process.versions.chrome })) }));
+ const describe = async (app, action, sdp, policy) => app.evaluate(async ({ BrowserWindow }, input) => {
+ const state = globalThis.probe;
+ state.messages = [];
+ state.opened = false;
+ state.session = state.runtime.create('mdns-smoke', {
+ open() { state.opened = true; }, closed() {}, drained() {}, message(text) { state.messages.push(text); },
+ });
+ const pending = input.action === 'offer' ? state.session.offer() : state.session.accept(input.sdp);
+ // Override only in the experiment to reproduce the original behavior.
+ // Null uses the policy installed by the actual production window factory.
+ const win = BrowserWindow.getAllWindows()[0];
+ if (input.policy) win.webContents.setWebRTCIPHandlingPolicy(input.policy);
+ const result = await pending;
+ const prefs = win.webContents.getLastWebPreferences();
+ if (win.isVisible() || !prefs.sandbox || !prefs.contextIsolation || prefs.nodeIntegration)
+ throw new Error('WINDOW_ISOLATION_REGRESSION');
+ return result;
+ }, { action, sdp, policy });
+ const candidates = sdp => sdp.split('\r\n').filter(line => line.startsWith('a=candidate:'));
+ const stats = sdp => {
+ const addresses = candidates(sdp).map(line => line.split(' ')[4]);
+ return { total: addresses.length, mdns: addresses.filter(address => address.endsWith('.local')).length,
+ ipv4: addresses.filter(address => /^\d+\.\d+\.\d+\.\d+$/.test(address)).length };
+ };
+ const obscure = sdp => sdp.split('\r\n').map(line => {
+ if (!line.startsWith('a=candidate:')) return line;
+ const fields = line.split(' ');
+ if (fields[4].endsWith('.local')) fields[4] = `${randomUUID()}.local`;
+ return fields.join(' ');
+ }).join('\r\n');
+ const waitOpen = app => app.evaluate(async () => {
+ const state = globalThis.probe;
+ const until = Date.now() + 16_000; // exceeds production negotiation's 15s budget
+ while (!state.opened && Date.now() < until) await new Promise(resolve => setTimeout(resolve, 20));
+ return state.opened;
+ });
+ const payload = '0123456789abcdef'.repeat(16_384); // exactly 256 KiB; compare every byte
+ for (const [name, policies, shouldOpen] of [
+ ['unresolvable-mdns-baseline', ['default', 'default'], false],
+ ['both-native-policy', [null, null], true],
+ ['offerer-only-native-policy', [null, 'default'], true],
+ ['answerer-only-native-policy', ['default', null], true],
+ ['no-host-candidates', ['default_public_interface_only', 'default_public_interface_only'], false],
+ ]) {
+ const offer = await describe(apps[0], 'offer', undefined, policies[0]);
+ const answer = await describe(apps[1], 'accept', obscure(offer), policies[1]);
+ await apps[0].evaluate((_, sdp) => globalThis.probe.session.answer(sdp), obscure(answer));
+ const counts = [stats(offer), stats(answer)];
+ if (name === 'unresolvable-mdns-baseline') assert.ok(counts.every(c => c.mdns > 0 && c.ipv4 === 0), 'baseline must contain mDNS only');
+ if (name === 'both-native-policy') assert.ok(counts.every(c => c.ipv4 > 0 && c.mdns === 0), 'native policy must produce literal candidates');
+ if (name === 'no-host-candidates') assert.ok(counts.every(c => c.total === 0), 'no-host fixture must have no candidates');
+ const opened = await Promise.all(apps.map(waitOpen));
+ assert.deepEqual(opened, [shouldOpen, shouldOpen], name);
+ if (name === 'both-native-policy') {
+ // Malformed and oversized remote descriptions must fail only their own
+ // connection, leaving the already established pair able to send below.
+ const rejected = await apps[0].evaluate(async () => {
+ const runtime = globalThis.probe.runtime;
+ const results = [];
+ for (const [id, sdp] of [['malformed', 'v=0\r\ninvalid'], ['oversized', 'x'.repeat(128 * 1024 + 1)]]) {
+ const bad = runtime.create(id, { open() {}, closed() {}, drained() {}, message() {} });
+ try { await bad.accept(sdp); results.push(false); }
+ catch { results.push(true); }
+ finally { bad.close(); }
+ }
+ return results;
+ });
+ assert.deepEqual(rejected, [true, true], 'invalid remote SDP must not gain candidates or break healthy peers');
+ }
+ if (shouldOpen) {
+ for (const app of apps) await app.evaluate((_, text) => globalThis.probe.session.send(text), payload);
+ const received = await Promise.all(apps.map(app => app.evaluate(async () => {
+ const until = Date.now() + 10_000;
+ while (!globalThis.probe.messages.length && Date.now() < until) await new Promise(resolve => setTimeout(resolve, 20));
+ return globalThis.probe.messages;
+ })));
+ for (const messages of received) assert.deepEqual(messages, [payload], `${name}: bytes or duplicate delivery`);
+ }
+ const paths = await Promise.all(apps.map(app => app.evaluate(async ({ BrowserWindow }) =>
+ BrowserWindow.getAllWindows()[0].webContents.executeJavaScript(`(async () => {
+ const pc = window.probeConnections.find(connection => connection.signalingState !== 'closed');
+ const stats = await pc.getStats();
+ const transport = [...stats.values()].find(s => s.type === 'transport');
+ const pair = stats.get(transport?.selectedCandidatePairId);
+ const local = stats.get(pair?.localCandidateId), remote = stats.get(pair?.remoteCandidateId);
+ return { ice: pc.iceConnectionState, local: local?.candidateType, remote: remote?.candidateType, protocol: local?.protocol };
+ })()`))));
+ if (shouldOpen) assert.ok(paths.every(path => ['connected', 'completed'].includes(path.ice)
+ && path.protocol === 'udp' && path.local === 'host' && ['host', 'prflx'].includes(path.remote)), 'expected actual host UDP path');
+ console.log(JSON.stringify({ name, candidates: counts, opened, paths,
+ ...(name === 'both-native-policy' ? { malformedAndOversizedRejected: true, healthyPeerSurvived: true } : {}),
+ bytesEachWay: shouldOpen ? Buffer.byteLength(payload) : 0,
+ sha256: shouldOpen ? createHash('sha256').update(payload).digest('hex') : undefined }));
+ for (const app of apps) await app.evaluate(() => { globalThis.probe.session.close(); globalThis.probe.runtime.suspend(); });
+ }
+ console.log('ELECTRON_MDNS_SMOKE=PASS');
+ } finally { for (const app of apps) await app.close(); }
+}
diff --git a/scripts/restart-desktop-remote.mjs b/scripts/restart-desktop-remote.mjs
index 15d7a7ef9d..23def523b3 100644
--- a/scripts/restart-desktop-remote.mjs
+++ b/scripts/restart-desktop-remote.mjs
@@ -1017,6 +1017,10 @@ function devEnvEntries(env) {
// endpoint.local.json 文件路径,均由主进程 clientEndpointsService 消费。
['XDT_ENDPOINTS_CDN', env.XDT_ENDPOINTS_CDN],
['XDT_ENDPOINT_MANIFEST_FILE', env.XDT_ENDPOINT_MANIFEST_FILE],
+ // Partial local relay testing preserves the normal authentication realm discovery.
+ ['XDT_DEVICE_LINK_LOCAL_URL', env.XDT_DEVICE_LINK_LOCAL_URL],
+ ['XDT_DEVICE_LINK_CN_LOCAL_URL', env.XDT_DEVICE_LINK_CN_LOCAL_URL],
+ ['XDT_DEVICE_LINK_GLOBAL_LOCAL_URL', env.XDT_DEVICE_LINK_GLOBAL_LOCAL_URL],
// 模型目录闭环调试覆写。dev 默认仍不联网;只有显式给 URL 时,主进程才允许
// 从该地址拉取 Catalog。PATH / DISABLE 同步透传,避免 runner 吞掉已有契约。
['XDT_MODELS_URL', env.XDT_MODELS_URL],