Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
fix(device-link): 同一物理设备的共享任务共用并发配额
Dashd8c75ccacdc6
diff --git a/docs/dev-rules/remote-and-mobile-adaptation.md b/docs/dev-rules/remote-and-mobile-adaptation.mdindex d7f9c93a11..00a1aee24a 100644--- a/docs/dev-rules/remote-and-mobile-adaptation.md+++ b/docs/dev-rules/remote-and-mobile-adaptation.md@@ -72,6 +72,8 @@ relay 以 close 1013 `inbound backpressure` 主动断连,此时任何「立即普通出站 invoke 在共享 `InvokeScheduler` 中按目标设备排队:每台最多 12 个在途,其中 PR 引用/状态、定时任务侧栏和用量同步等后台查询最多 4 个。+同一真实设备的普通远控与多个共享任务共用并发和等待配额;取消仍按各自 scoped peer+隔离,关闭一个任务不会取消其他任务或普通远控请求,transport 的任务范围保持不变。任务列表同时用于首拉与恢复探测,统一走前台配额(仍受总并发 12 限制),不被后台配额阻塞。前台请求优先于尚未发送的后台请求;不同设备独立推进。PR 的重复聚焦/注册沿用`PrRefsContext` 的单任务在途合并,不额外重试或保存结果。握手、订阅控制与远控心跳diff --git a/packages/device-link/src/__tests__/client.test.ts b/packages/device-link/src/__tests__/client.test.tsindex fb5faf7556..1b73d4d26e 100644--- a/packages/device-link/src/__tests__/client.test.ts+++ b/packages/device-link/src/__tests__/client.test.ts@@ -126,6 +126,37 @@ function makeHarness(opts?: {const tick = (ms = 0): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));describe('outbound invoke admission', () => {+ it('shares 12/4 across ordinary and shared-task destinations while preserving wire scope', async () => {+ vi.useFakeTimers();+ const h = makeHarness({ timing: { pingIntervalMs: 60_000, requestTimeoutMs: 30_000 } });+ const calls: Promise<unknown>[] = [];+ const peers = ['desktop', sharedTaskHostPeer('task-a', 'desktop'), sharedTaskHostPeer('task-b', 'desktop')];+ try {+ h.client.start(); await vi.advanceTimersByTimeAsync(1); h.current().ack([SHARED_TASK_RELAY_CAPABILITY]);+ for (let i = 0; i < 6; i++) calls.push(h.client.invoke(peers[i % 3], {+ channel: 'git-context:pr-refs:list', args: [i],+ }).catch(e => e));+ for (let i = 0; i < 10; i++) calls.push(h.client.invoke(peers[i % 3], {+ channel: 'maker:send', args: [i],+ }).catch(e => e));+ const sent = () => h.current().sent.filter(e => e.kind === 'invoke' && e.dst === 'desktop');+ expect(sent()).toHaveLength(12);+ expect(sent().filter(e => (e.payload as { channel: string }).channel === 'git-context:pr-refs:list')).toHaveLength(4);+ expect(sent().slice(0, 3).map(e => e.sharedTask?.sharedTaskId)).toEqual([undefined, 'task-a', 'task-b']);+ calls.push(h.client.invoke(sharedTaskHostPeer('task-c', 'other'), { channel: 'maker:send', args: [] }).catch(e => e));+ expect(h.current().sent.filter(e => e.kind === 'invoke' && e.dst === 'other')).toHaveLength(1);+ // A normal-stream response releases shared capacity; the next task keeps its scoped route.+ h.current().push({ v: PROTOCOL_VERSION, kind: 'invoke-result', src: 'desktop', id: sent()[4].id,+ payload: { ok: true, result: null } });+ await vi.advanceTimersByTimeAsync(1);+ expect(sent()).toHaveLength(13);+ expect(sent().at(-1)).toMatchObject({ dst: 'desktop', sharedTask: { sharedTaskId: 'task-b', target: { role: 'host' } },+ payload: { channel: 'maker:send', args: [8] } });+ } finally {+ h.client.stop(); await Promise.all(calls); vi.useRealTimers();+ }+ });+it('rechecks a queued write before dispatch and releases its slot when the caller cancels', async () => {vi.useFakeTimers();const h = makeHarness({ timing: { pingIntervalMs: 60_000, requestTimeoutMs: 30_000 } });diff --git a/packages/device-link/src/__tests__/invokeScheduler.test.ts b/packages/device-link/src/__tests__/invokeScheduler.test.tsindex 39815958fc..b6d26d52b8 100644--- a/packages/device-link/src/__tests__/invokeScheduler.test.ts+++ b/packages/device-link/src/__tests__/invokeScheduler.test.ts@@ -2,6 +2,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";import { InvokeScheduler } from "../invokeScheduler.js";import { DeviceLinkError } from "../protocol.js";import { isBackgroundInvoke, bypassInvokeScheduling } from "../invokePolicy.js";+import { sharedTaskGuestPeer, sharedTaskHostPeer } from "../sharedTaskPeer.js";function deferred() {let resolve!: () => void;@@ -16,6 +17,46 @@ const flush = async () => {afterEach(() => vi.useRealTimers());describe("invoke admission", () => {+ const sameHost = ["host", sharedTaskHostPeer("task-a", "host"), sharedTaskGuestPeer("task-b", "member", "host")];++ it.each([false, true])("shares physical-host active and waiting limits across scoped peers (background=%s)", async (background) => {+ const scheduler = new InvokeScheduler();+ const active = deferred();+ const send = vi.fn(() => active.promise);+ const activeLimit = background ? 4 : 12;+ const waitingLimit = background ? 96 : 128;+ const pending = Array.from({ length: activeLimit + waitingLimit }, (_, i) =>+ scheduler.run(sameHost[i % sameHost.length], background, 30_000, send).catch(e => e),+ );+ expect(send).toHaveBeenCalledTimes(activeLimit);+ for (const peer of sameHost) {+ await expect(scheduler.run(peer, background, 30_000, send)).rejects.toMatchObject({ code: "BACKPRESSURE" });+ }+ await expect(scheduler.run(sharedTaskHostPeer("task-c", "other"), background, 30_000, async () => 42)).resolves.toBe(42);+ scheduler.clear(new DeviceLinkError("NOT_CONNECTED", "stop"));+ active.resolve();+ const results = await Promise.all(pending);+ expect(send).toHaveBeenCalledTimes(activeLimit);+ expect(results.slice(activeLimit)).toEqual(Array.from({ length: waitingLimit }, () => expect.objectContaining({ code: "NOT_CONNECTED", inFlight: undefined })));+ });++ it.each(sameHost)("cancels only %s while retaining shared capacity until active work settles", async (cancelledPeer) => {+ const scheduler = new InvokeScheduler();+ const active = deferred();+ const running = Array.from({ length: 12 }, (_, i) => scheduler.run(sameHost[i % sameHost.length], false, 30_000, () => active.promise));+ const started: string[] = [];+ const pending = sameHost.map(peer => scheduler.run(peer, false, 30_000, async () => { started.push(peer); }).catch(e => e));+ const error = new DeviceLinkError("NOT_CONNECTED", "scope closed");+ scheduler.cancel(cancelledPeer, error);+ error.inFlight = true;+ expect(await pending[sameHost.indexOf(cancelledPeer)]).toMatchObject({ code: "NOT_CONNECTED", inFlight: undefined });+ const fresh = scheduler.run(cancelledPeer, false, 30_000, async () => { started.push("fresh"); });+ expect(started).toEqual([]);+ active.resolve();+ await Promise.all([...running, ...pending, fresh]);+ expect(started).toEqual([...sameHost.filter(peer => peer !== cancelledPeer), "fresh"]);+ });+it("runs a 32-request burst in bounded batches and prioritizes current work", async () => {const scheduler = new InvokeScheduler();const started: string[] = [];diff --git a/packages/device-link/src/invokeScheduler.ts b/packages/device-link/src/invokeScheduler.tsindex 2bf2ade085..994f6e5e91 100644--- a/packages/device-link/src/invokeScheduler.ts+++ b/packages/device-link/src/invokeScheduler.ts@@ -1,4 +1,5 @@import { DeviceLinkError } from "./protocol.js";+import { parseSharedTaskPeer } from "./sharedTaskPeer.js";const MAX_ACTIVE = 12;const MAX_BACKGROUND_ACTIVE = 4;@@ -7,6 +8,7 @@ const MAX_QUEUED = 128;const MAX_BACKGROUND_QUEUED = 96;interface Job {+ peerId: string;background: boolean;start(): void;cancel(error: DeviceLinkError): void;@@ -22,11 +24,14 @@ export class InvokeScheduler {private readonly peers = new Map<string, PeerQueue>();run<T>(- deviceId: string,+ peerId: string,background: boolean,waitMs: number,run: () => Promise<T>,): Promise<T> {+ // Shared-task handles share the physical host's capacity, but keep their+ // scoped peer identity for cancellation and all transport bookkeeping.+ const deviceId = parseSharedTaskPeer(peerId)?.deviceId ?? peerId;let peer = this.peers.get(deviceId);if (!peer) {peer = { active: 0, background: 0, jobs: [] };@@ -46,10 +51,12 @@ export class InvokeScheduler {return new Promise<T>((resolve, reject) => {const queuedAt = Date.now();const job: Job = {+ peerId,background,cancel: (error) => {clearTimeout(timer);- reject(error);+ // The transport may mark its error inFlight later; queued calls were never sent.+ reject(new DeviceLinkError(error.code, error.message));},start: () => {clearTimeout(timer);@@ -96,18 +103,21 @@ export class InvokeScheduler {}/** Keep active slots until their promises settle, including across reconnects. */- cancel(deviceId: string, error: DeviceLinkError): void {+ cancel(peerId: string, error: DeviceLinkError): void {+ const deviceId = parseSharedTaskPeer(peerId)?.deviceId ?? peerId;const state = this.peers.get(deviceId);if (!state) return;- for (const job of state.jobs.splice(0)) {- // The transport may mark its error inFlight later; queued calls were never sent.- job.cancel(new DeviceLinkError(error.code, error.message));- }+ const cancelled = state.jobs.filter((job) => job.peerId === peerId);+ state.jobs = state.jobs.filter((job) => job.peerId !== peerId);+ for (const job of cancelled) job.cancel(error);this.drain(deviceId, state);}clear(error: DeviceLinkError): void {- for (const deviceId of this.peers.keys()) this.cancel(deviceId, error);+ for (const [deviceId, state] of this.peers) {+ for (const job of state.jobs.splice(0)) job.cancel(error);+ this.drain(deviceId, state);+ }}private drain(deviceId: string, state: PeerQueue): void {