Skip to content

armgit / cindy

Public Imported from GitHub
0

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

fix(device-link): 同一物理设备的共享任务共用并发配额

Dashd8c75ccacdc6
diff --git a/docs/dev-rules/remote-and-mobile-adaptation.md b/docs/dev-rules/remote-and-mobile-adaptation.md
index 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.ts
index 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.ts
index 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.ts
index 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 {