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(remote-agent): preserve unknown paths and close startup race gaps

MagicLizi146376103434
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 c6b8da9ff6..96eaa9ca76 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/mirror.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/mirror.test.ts
@@ -516,14 +516,13 @@ describe('shadow on the other computer', () => {
host.dispose();
});
- // 2026-10-22 远程供应商调查:Codex 建线程时沿虚拟工作区逐级向上找 .git、Skill 目录与插件清单。垫出来的层级与
- // 这台电脑自己的上级目录在任务所在电脑上没有对应目录,转过去只会得到「不存在」,却每条都要跨机往返一次,
- // 现场启动因此拖到几分钟。这些查询由这台电脑直接回答;真实上级目录里任务所在电脑报了「没有」的标记同样直接
- // 回答;其余(工作区本身、报了「有」的标记、其它名字)照常转过去。
+ // 2026-10-22 远程供应商调查:Codex 沿虚拟工作区逐级查找,虚拟垫层与任务电脑已报「没有」的标记可以本机回答。
+ // 镜像外的隐藏文件可能在任务电脑同一路径真实存在(#6844 review),没有确认不存在的一律照常转发。
it('answers lookups the task computer cannot map on this computer and forwards the rest', async () => {
const project = path.join(root, 'work', 'proj');
write(path.join(project, 'hello.txt'), 'hi');
write(path.join(root, 'work', '.git', 'HEAD'), 'ref: refs/heads/main\n');
+ write(path.join(root, '.bashrc'), 'export TASK_SHELL_CONFIG=1\n');
const inputs: HostedStartInput[] = [];
let stop!: () => void;
const stopped = new Promise<void>((resolve) => { stop = resolve; });
@@ -594,12 +593,16 @@ describe('shadow on the other computer', () => {
{ target: path.join(top, 'not-a-marker'), local: false },
{ target: path.join(input.mirrorRoot, 'home', '.agents', 'skills'), local: false },
{ target: path.join(path.parse(input.mirrorRoot).root, 'not-a-cindy-dir', 'tool'), local: false },
+ // 镜像外的绝对路径会原样交给任务电脑;同一路径下的隐藏文件/已存在标记不能凭点前缀判不存在。
+ { target: path.join(root, '.bashrc'), local: false },
+ { target: path.join(root, 'work', '.git', 'HEAD'), local: false },
+ { target: path.join(root, 'work', '.codex-plugin', 'plugin.json'), local: true },
{ target: path.join(grandparent, '.git'), local: true },
{ target: path.join(grandparent, '.cursor-plugin', 'plugin.json'), local: true },
{ target: path.join(padded, '.git'), local: true },
{ target: path.join(padded, '.codex-plugin', 'plugin.json'), local: true },
{ target: path.join(input.mirrorRoot, 'workspace', '.agents', 'skills'), local: true },
- { target: path.join(path.dirname(path.dirname(input.mirrorRoot)), '.claude-plugin', 'plugin.json'), local: true },
+ { target: path.join(path.dirname(path.dirname(input.mirrorRoot)), '.claude-plugin', 'plugin.json'), local: false },
];
const ws = new WebSocket(`${input.tunnel.url.replace(/^http/, 'ws')}/ws/exec-server`, { headers: { authorization: `Bearer ${input.tunnel.token}` } });
const replies = new Map<number, { error?: { code?: number } }>();
@@ -608,24 +611,26 @@ describe('shadow on the other computer', () => {
replies.set(message.id, message);
});
await once(ws, 'open');
- cases.forEach(({ target }, index) => ws.send(JSON.stringify({ id: index + 1, method: 'fs/getMetadata', params: { path: pathToFileURL(target).href } })));
- const localIds = cases.flatMap(({ local }, index) => local ? [index + 1] : []);
- const forwardedIds = cases.flatMap(({ local }, index) => local ? [] : [index + 1]);
- await vi.waitFor(() => {
- expect([...replies.keys()].sort((a, b) => a - b)).toEqual(localIds);
- expect([...forwarded].sort((a, b) => a - b)).toEqual(forwardedIds);
- });
- for (const id of localIds) expect(replies.get(id)?.error?.code).toBe(EXEC_SERVER_NOT_FOUND_CODE);
- // 本机回答的路径在任务所在电脑上确实不存在:要么映射不到(转过去会被原样当成那台电脑的路径查),要么映射到的
- // 真实路径不在。存在的(上级目录里的 .git)照常转过去。
- for (const { target } of cases.filter(({ local }) => local)) {
- const real = mapped.localPathFromAgent(target);
- expect(real === null || !fs.existsSync(real)).toBe(true);
+ try {
+ cases.forEach(({ target }, index) => ws.send(JSON.stringify({ id: index + 1, method: 'fs/getMetadata', params: { path: pathToFileURL(target).href } })));
+ const localIds = cases.flatMap(({ local }, index) => local ? [index + 1] : []);
+ const forwardedIds = cases.flatMap(({ local }, index) => local ? [] : [index + 1]);
+ await vi.waitFor(() => {
+ expect([...replies.keys()].sort((a, b) => a - b)).toEqual(localIds);
+ expect([...forwarded].sort((a, b) => a - b)).toEqual(forwardedIds);
+ });
+ for (const id of localIds) expect(replies.get(id)?.error?.code).toBe(EXEC_SERVER_NOT_FOUND_CODE);
+ // 映射不到的绝对路径会原样转发;本机回答的所有目标在任务电脑上都确实不存在。
+ for (const { target } of cases.filter(({ local }) => local)) {
+ const real = mapped.localPathFromAgent(target) ?? target;
+ expect(fs.existsSync(real)).toBe(false);
+ }
+ expect(fs.existsSync(mapped.localPathFromAgent(path.join(parent, '.git', 'HEAD'))!)).toBe(true);
+ expect(fs.readFileSync(path.join(root, '.bashrc'), 'utf8')).toContain('TASK_SHELL_CONFIG');
+ } finally {
+ ws.close();
+ await handle.close({ reason: 'navigation' });
+ host.dispose();
}
- expect(fs.existsSync(mapped.localPathFromAgent(path.join(parent, '.git', 'HEAD'))!)).toBe(true);
-
- ws.close();
- await handle.close({ reason: 'navigation' });
- host.dispose();
});
});
diff --git a/apps/desktop/src/main/remote-agent/__tests__/poll.test.ts b/apps/desktop/src/main/remote-agent/__tests__/poll.test.ts
index 4d3f021e91..26b113fe69 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/poll.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/poll.test.ts
@@ -113,7 +113,7 @@ afterEach(() => {
});
describe('multiplexed poll', () => {
- // 长等待最多两个,另有一个只给还没被带上过的新任务的补位名额,合计不超过 3 个(远低于共享的 12 个在途配额)。
+ // 长等待最多两个,另留一个给没有在途覆盖的任务,持续到普通 poll 接手;合计不超过 3 个。
it.each([130, 1000])('refreshes all %i idle runs before host expiry with at most three polls', async count => {
vi.useFakeTimers();
const host = fakeHost(REMOTE_AGENT_READ_WAIT_MS);
@@ -184,10 +184,13 @@ describe('multiplexed poll', () => {
poller.register(sinks[1].run);
await vi.advanceTimersByTimeAsync(1);
poller.register(sinks[2].run);
- const appendedAt = Date.now();
- host.runs.get(sinks[2].run.runId)!.log.append({ t: 'ws', kind: 'message', data: 'initialize' });
- await vi.waitFor(() => expect(sinks[2].text()).toContain('initialize'));
- expect(Date.now() - appendedAt).toBeLessThan(1_000);
+ // #6844 review:首包只有连接打开,initialize 与后续文件查询分别到达;补位必须持续到普通 poll 接手。
+ for (const data of ['open', 'initialize', 'fs/getMetadata']) {
+ const appendedAt = Date.now();
+ host.runs.get(sinks[2].run.runId)!.log.append({ t: 'ws', kind: 'message', data });
+ await vi.waitFor(() => expect(sinks[2].text()).toContain(data));
+ expect(Date.now() - appendedAt).toBeLessThan(1_000);
+ }
for (const run of host.runs.values()) run.log.end();
await vi.advanceTimersByTimeAsync(REMOTE_AGENT_READ_WAIT_MS);
expect(sinks.every((sink) => sink.done)).toBe(true);
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 f8af74530f..ab5eca409c 100644
--- a/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts
+++ b/apps/desktop/src/main/remote-agent/__tests__/roundtrip.test.ts
@@ -617,6 +617,41 @@ describe('remote agent round trip', () => {
// 2026-10-22 远程供应商调查:慢启动期间任务被删除,控制端不再等了,对方却在几分钟后仍启动 Agent 并跑完
// 这一轮(供应商组还会换电脑接着启动)。删除或归档时要让对方结束这个任务,迟到完成的启动也立刻关掉。
+ // #6844 review:旧用例只覆盖远端已开始启动;MCP 准备是更早的异步等待,删除后不得发出 open,已准备资源要释放。
+ it('does not open a remote run after the task was removed while preparing MCP', async () => {
+ const host = createHost();
+ const base = makeDeps(host);
+ let finishPrepare!: () => void;
+ const prepareGate = new Promise<void>((resolve) => { finishPrepare = resolve; });
+ const dispose = vi.fn();
+ const prepareMcp = vi.fn(async () => {
+ await prepareGate;
+ return { servers: new Map(), dispose };
+ });
+ const invoke = vi.fn(base.invoke);
+ const sessionId = randomUUID();
+ const starting = startRemoteAgentSession('claude-code', { sessionId, workingDir: project, model: 'm' }, {
+ ...base, invoke, prepareMcp,
+ });
+ void starting.catch(() => undefined);
+ let handle: AgentSessionHandle | undefined;
+ try {
+ expect(prepareMcp).toHaveBeenCalledTimes(1);
+ cancelPendingRemoteStart(sessionId);
+ finishPrepare();
+ const result = await starting.then((value) => { handle = value; return null; }, (error: unknown) => error);
+ expect(result).toBeInstanceOf(Error);
+ expect(String(result)).toContain('[REMOTE_AGENT_EXPIRED]');
+ expect(invoke).not.toHaveBeenCalled();
+ expect(dispose).toHaveBeenCalledTimes(1);
+ expect(host.limitUsage().total).toBe(0);
+ } finally {
+ finishPrepare();
+ await handle?.close({ reason: 'navigation' });
+ host.dispose();
+ }
+ });
+
it('ends the run on the other computer when the task is removed while it is still starting', async () => {
let finishStart!: () => void;
const startGate = new Promise<void>((resolve) => { finishStart = resolve; });
diff --git a/apps/desktop/src/main/remote-agent/controller/poller.ts b/apps/desktop/src/main/remote-agent/controller/poller.ts
index 8c1a1786e3..202293b7af 100644
--- a/apps/desktop/src/main/remote-agent/controller/poller.ts
+++ b/apps/desktop/src/main/remote-agent/controller/poller.ts
@@ -3,7 +3,7 @@
*
* 同一台电脑上的全部任务共用一个拉取器:每个 `poll` 最多携带 64 个任务的游标,按整批轮转,
* 对方没有新数据时挂起最多 READ_WAIT_MS。新任务登记时可另发一个 poll,长等待同时在途最多两个;
- * 两个都被只含旧任务的长等待占着时,再留一个名额给还没被任何 poll 带上过的新任务(排在最前),
+ * 两个都被旧任务的长等待占着时,再留一个名额给没有在途 poll 覆盖的任务(排在最前),
* 否则新任务要等旧长等待超时(恰好等于 Codex 执行环境握手的 10 秒上限)才有人拉。
* 几个 poll 返回的数据可能重叠,按 from 去重,游标只前进不后退。
*
@@ -26,7 +26,7 @@ const RETRY_BASE_MS = 500;
const RETRY_MAX_MS = 5_000;
/** 同时在途的 poll 上限:一个长等待 + 一个覆盖新任务的。 */
const MAX_INFLIGHT_POLLS = 2;
-/** 有还没被任何 poll 带上过的新任务时,多留的一个补位名额。 */
+/** 有任务没有被在途 poll 覆盖时,多留一个补位名额,直到普通 poll 接手。 */
const FRESH_RUN_EXTRA_POLLS = 1;
/** 对方连续几次立刻返回、却没有任何新数据时,放慢重拉(防止对方行为异常时空转)。 */
const EMPTY_FAST_STREAK = 3;
@@ -70,8 +70,6 @@ export function remoteAgentErrorFrom(error: unknown, fallbackCode = 'REMOTE_AGEN
export class RemoteAgentPoller {
private readonly entries = new Map<string, Entry>();
- /** 登记后还没被任何 poll 带上过的任务:下一个 poll 先带它们,必要时用补位名额。 */
- private readonly unpolled = new Set<string>();
private inflight = 0;
/** 有任务还没被任何在途 poll 覆盖。 */
private needFresh = false;
@@ -93,14 +91,12 @@ export class RemoteAgentPoller {
register(run: PolledRun): void {
if (this.entries.has(run.runId)) return;
this.entries.set(run.runId, { run, cursor: 0 });
- this.unpolled.add(run.runId);
this.needFresh = true;
this.ensure();
}
unregister(runId: string): void {
this.entries.delete(runId);
- this.unpolled.delete(runId);
}
get size(): number {
@@ -110,7 +106,7 @@ export class RemoteAgentPoller {
private ensure(): void {
if (this.entries.size === 0 || this.retryTimer) return;
if (this.inflight > 0 && !this.needFresh) return;
- const limit = this.unpolled.size > 0 ? MAX_INFLIGHT_POLLS + FRESH_RUN_EXTRA_POLLS : MAX_INFLIGHT_POLLS;
+ const limit = this.hasUncoveredRun() ? MAX_INFLIGHT_POLLS + FRESH_RUN_EXTRA_POLLS : MAX_INFLIGHT_POLLS;
if (this.inflight >= limit) return;
this.needFresh = false;
void this.pollOnce();
@@ -120,17 +116,18 @@ export class RemoteAgentPoller {
const all = [...this.entries.values()].map((entry) => ({ runId: entry.run.runId, cursor: entry.cursor }));
let wanted = all;
if (all.length > REMOTE_AGENT_MAX_POLL_RUNS) {
- // 按整批推进,避免大量空闲任务在下次被拉取前超过 host 的存活期限;还没被带上过的新任务排在最前。
+ // 按整批推进,避免大量空闲任务在下次被拉取前超过 host 的存活期限;没有在途覆盖的任务排在最前。
const start = this.rotation % all.length;
- const fresh = all.filter((item) => this.unpolled.has(item.runId)).slice(0, REMOTE_AGENT_MAX_POLL_RUNS);
- const rotated = [...all.slice(start), ...all.slice(0, start)]
- .filter((item) => !this.unpolled.has(item.runId))
+ const ordered = [...all.slice(start), ...all.slice(0, start)];
+ const uncovered = new Set(all.filter((item) => !this.isCovered(item.runId)).map((item) => item.runId));
+ const fresh = ordered.filter((item) => uncovered.has(item.runId)).slice(0, REMOTE_AGENT_MAX_POLL_RUNS);
+ const rotated = ordered
+ .filter((item) => !uncovered.has(item.runId))
.slice(0, REMOTE_AGENT_MAX_POLL_RUNS - fresh.length);
- this.rotation = (start + rotated.length) % all.length;
+ this.rotation = (start + fresh.length + rotated.length) % all.length;
this.needFresh = true;
wanted = [...fresh, ...rotated];
}
- for (const { runId } of wanted) this.unpolled.delete(runId);
return wanted;
}
@@ -191,14 +188,14 @@ export class RemoteAgentPoller {
private hasUncoveredRun(): boolean {
for (const runId of this.entries.keys()) {
- let covered = false;
- for (const coverage of this.inflightCoverage) {
- if (coverage.has(runId)) {
- covered = true;
- break;
- }
- }
- if (!covered) return true;
+ if (!this.isCovered(runId)) return true;
+ }
+ return false;
+ }
+
+ private isCovered(runId: string): boolean {
+ for (const coverage of this.inflightCoverage) {
+ if (coverage.has(runId)) return true;
}
return false;
}
@@ -284,7 +281,6 @@ export class RemoteAgentPoller {
private lose(entry: Entry, reason: string, error: RemoteAgentErrorInfo): void {
if (this.entries.get(entry.run.runId) !== entry) return;
this.entries.delete(entry.run.runId);
- this.unpolled.delete(entry.run.runId);
try {
entry.run.onLost(reason, error);
} catch (handlerError) {
diff --git a/apps/desktop/src/main/remote-agent/controller/startRemote.ts b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
index c542521384..20e038cdf4 100644
--- a/apps/desktop/src/main/remote-agent/controller/startRemote.ts
+++ b/apps/desktop/src/main/remote-agent/controller/startRemote.ts
@@ -300,6 +300,27 @@ export async function startRemoteAgentSession(
deps: StartRemoteAgentDeps,
): Promise<AgentSessionHandle> {
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);
+ try {
+ return await prepareAndStartRemoteAgentSession(kind, opts, deps, abort.signal);
+ } finally {
+ cancels.delete(cancel);
+ if (!cancels.size && pendingStarts.get(sessionId) === cancels) pendingStarts.delete(sessionId);
+ }
+}
+
+async function prepareAndStartRemoteAgentSession(
+ kind: RemoteAgentKind,
+ opts: StartSessionOptions,
+ deps: StartRemoteAgentDeps,
+ signal: AbortSignal,
+): Promise<AgentSessionHandle> {
// 附加目录(只读引用)与可写目录分开跟踪,运行中任一侧变化都重算执行器根目录:
// 否则新授予的目录过不了本机 shell/root 判定,撤掉的还被本机上限当可信根。
let extraDirs = [...new Set(opts.extraDirs ?? [])];
@@ -352,6 +373,10 @@ export async function startRemoteAgentSession(
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.');
+ }
const router = createReverseHttpRouter({ executor, mcpTarget: (name) => mcp.servers.get(name) });
// 连回对方时按最新值打开(换模型、推理强度等在已让出名额时只记在这里)。
@@ -824,7 +849,6 @@ export async function startRemoteAgentSession(
// 第一次启动期间任务被删除或归档:标成已关闭(还没发出的打开不再发),已发出的立即让对方结束;
// 在等的打开随之以「任务已结束」失败。
- const sessionId = opts.sessionId;
const cancelStart = () => {
if (linkState === 'closed') return;
linkState = 'closed';
@@ -835,9 +859,7 @@ export async function startRemoteAgentSession(
});
if (client) void client.close('close', 'navigation').catch(() => undefined);
};
- const cancels = pendingStarts.get(sessionId) ?? new Set<() => void>();
- pendingStarts.set(sessionId, cancels);
- cancels.add(cancelStart);
+ signal.addEventListener('abort', cancelStart, { once: true });
try {
await connect(false, (started) => {
firstStarted = started;
@@ -899,8 +921,7 @@ export async function startRemoteAgentSession(
await disposeLocal();
throw localizeRemoteError(error);
} finally {
- cancels.delete(cancelStart);
- if (!cancels.size && pendingStarts.get(sessionId) === cancels) pendingStarts.delete(sessionId);
+ signal.removeEventListener('abort', cancelStart);
}
touch();
deps.log?.info('remote agent session started', { kind, runId: activeNow()?.runId });
diff --git a/apps/desktop/src/main/remote-agent/host/execServerShortcut.ts b/apps/desktop/src/main/remote-agent/host/execServerShortcut.ts
index fa2863f5d2..de623cbb17 100644
--- a/apps/desktop/src/main/remote-agent/host/execServerShortcut.ts
+++ b/apps/desktop/src/main/remote-agent/host/execServerShortcut.ts
@@ -3,9 +3,9 @@
*
* Codex 建线程时沿工作目录逐级向上找 `.git`、Skill 目录与插件清单(`.codex-plugin/plugin.json` 等),
* 每一次都经设备互联往返一次,且上一条回来才发下一条。虚拟工作区固定垫了 MAX_ANCESTOR_LEVELS 层
- * (`workspace/p/…`),再往上是这台电脑自己的目录。任务所在电脑只认工作区及其真实上级、home、tmp 与
- * additional(见 controller/startRemote 的 shadowAliases),其余路径原样当成它自己的路径去查,只会得到
- * 「不存在」。2026-10-22 现场:一次启动 277 次文件操作里约 150 次是这类查询,每次跨机 0.5–3 秒,启动
+ * (`workspace/p/…`),再往上是这台电脑自己的目录。工作区及其真实上级、home、tmp 与 additional
+ * 有显式映射(见 controller/startRemote 的 shadowAliases),镜像根内的其余层级在任务电脑没有对应目录。
+ * 镜像外的绝对路径则会原样转发,不能仅凭以点开头就判不存在。2026-10-22 现场:每次跨机 0.5–3 秒,启动
* 拖到几分钟、甚至撞上 5 分钟上限。
*
* 工作区的真实上级目录在任务所在电脑上是存在的,Codex 在每一级查 `.git` 与三种插件清单(实测每级 6 次)。
@@ -35,6 +35,8 @@ export interface ExecServerShortcutLayout {
mappedRoot: string;
/** 工作区各级真实上级目录(影子里的位置)里,任务所在电脑报了「没有」的名字。 */
ancestorAbsence?: ReadonlyArray<{ dir: string; absent: ReadonlySet<string> }>;
+ /** 任务电脑确认不存在的原始绝对路径;仅两端路径格式相同时提供,供镜像外查询核对。 */
+ taskAncestorAbsence?: ReadonlyArray<{ dir: string; absent: ReadonlySet<string> }>;
}
function isWithin(target: string, root: string): boolean {
@@ -42,12 +44,17 @@ function isWithin(target: string, root: string): boolean {
return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
}
+function reportedAbsent(target: string, ancestors: ExecServerShortcutLayout['ancestorAbsence']): boolean {
+ return (ancestors ?? []).some(({ dir, absent }) => (
+ target !== dir && isWithin(target, dir) && absent.has(path.relative(dir, target).split(path.sep)[0])
+ ));
+}
+
/**
* 这个本机路径在任务所在电脑上是否注定不存在:
* - 镜像根内:不在已映射的工作区(及其真实上级)、home、tmp、additional 之下的,都是虚拟工作区垫出来的层级;
* 在真实上级目录里、任务所在电脑报了「没有」的名字之下的,同样不存在;
- * - 镜像根外:只认这台电脑上级目录下直接以点开头的标记(`.git`、`.agents`、`.codex-plugin` …),
- * 它们是 Codex 沿上级目录查找的产物;其它路径(如那台电脑的 shell 路径)照常转发。
+ * - 镜像根外:只按任务电脑确认不存在的原始绝对路径回答;其余路径照常转发,包括隐藏文件与未知的标记。
*/
function unreachableOnTaskComputer(target: string, layout: ExecServerShortcutLayout): boolean {
if (!path.isAbsolute(target)) return false;
@@ -58,21 +65,9 @@ function unreachableOnTaskComputer(target: string, layout: ExecServerShortcutLay
const first = path.relative(mirrorRoot, resolved).split(path.sep)[0];
if (MAPPED_TOP_LEVEL.has(first)) return false;
if (!isWithin(resolved, path.resolve(layout.mappedRoot))) return true;
- return (layout.ancestorAbsence ?? []).some(({ dir, absent }) => {
- if (resolved === dir || !isWithin(resolved, dir)) return false;
- return absent.has(path.relative(dir, resolved).split(path.sep)[0]);
- });
- }
- // 镜像根外:找出与镜像根最深的共同上级。
- let common = path.dirname(mirrorRoot);
- while (!isWithin(resolved, common)) {
- const parent = path.dirname(common);
- if (parent === common) return false;
- common = parent;
+ return reportedAbsent(resolved, layout.ancestorAbsence);
}
- if (resolved === common) return false;
- const first = path.relative(common, resolved).split(path.sep)[0];
- return first.length > 1 && first.startsWith('.');
+ return reportedAbsent(resolved, layout.taskAncestorAbsence);
}
/**
diff --git a/apps/desktop/src/main/remote-agent/host/runHost.ts b/apps/desktop/src/main/remote-agent/host/runHost.ts
index b9920ad58c..e457bbdd40 100644
--- a/apps/desktop/src/main/remote-agent/host/runHost.ts
+++ b/apps/desktop/src/main/remote-agent/host/runHost.ts
@@ -1030,12 +1030,14 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
let virtualParent = shadowDir;
/** 控制端有对应目录的各级上级目录在影子里的位置(下标 = 向上几级)。 */
const mappedAncestors: string[] = [];
+ const taskAncestors: string[] = [payload.workspace.workingDir];
for (let up = 1; up <= MAX_ANCESTOR_LEVELS; up += 1) {
const nextReal = foreignPath.dirname(realParent);
if (nextReal === realParent) break;
realParent = nextReal;
virtualParent = path.dirname(virtualParent);
mappedAncestors[up] = virtualParent;
+ taskAncestors[up] = realParent;
pathAliases.push({ from: realParent, to: virtualParent });
}
// 控制端报来的各级上级目录里不存在的标记名(只认有对应目录的级别;通往工作区的那一级目录名不算)。
@@ -1047,6 +1049,17 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
return dir && absent.length ? [{ dir, absent: new Set(absent) }] : [];
})
: [];
+ // 镜像外的绝对路径原样交给任务电脑:只复用它已确认不存在的标记,不猜这台电脑上级目录里隐藏文件的存在性。
+ // Windows 与 POSIX 的路径格式不同,不能拿一边的绝对路径直接匹配另一边的 file URI。
+ const samePathFormat = (payload.workspace.platform === 'win32') === (process.platform === 'win32');
+ const taskAncestorAbsence = payload.virtualWorkspace && payload.ancestorMarkers && samePathFormat
+ ? payload.ancestorMarkers.levels.flatMap(({ up, present }) => {
+ const dir = taskAncestors[up];
+ const towardWorkspace = foreignPath.basename(taskAncestors[up - 1] ?? '');
+ const absent = payload.ancestorMarkers!.names.filter((name) => !present.includes(name) && name !== towardWorkspace);
+ return dir && absent.length ? [{ dir, absent: new Set(absent) }] : [];
+ })
+ : [];
[...payload.workspace.extraDirs, ...payload.workspace.writableDirs].forEach((from, index) => {
pathAliases.push({ from, to: virtualAll[index] });
});
@@ -1104,7 +1117,7 @@ export function createRemoteAgentHost(deps: RemoteAgentHostDeps) {
}
if (personal.permissions) await mergeLocalPermissions(path.join(shadowDir, '.claude', 'settings.local.json'), Object.fromEntries(Object.entries(personal.permissions).map(([key, rules]) => [key, rules?.map(projectText)])));
// virtualParent 停在控制端有对应目录的最上一级(与控制端 shadowAliases 逐级映射的范围一致)。
- const shortcutLayout: ExecServerShortcutLayout = { mirrorRoot, mappedRoot: virtualParent, ancestorAbsence };
+ const shortcutLayout: ExecServerShortcutLayout = { mirrorRoot, mappedRoot: virtualParent, ancestorAbsence, taskAncestorAbsence };
return { shadowDir, mirrorRoot, shortcutLayout, sessionRoot, extraDirs: virtualAll.slice(0, extraCount), writableDirs: virtualAll.slice(extraCount), projectText };
}
diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.md
index 759329043f..26bab8adc0 100644
--- a/docs/dev-rules/protocol-compatibility.md
+++ b/docs/dev-rules/protocol-compatibility.md
@@ -1305,8 +1305,9 @@ Codex 原生图片恢复(#6412)在既有 `maker:remote-agent:v1` 上追加
`fs/readFile`、`fs/open` 的缺省/read 模式与目录读取按读取,显式非 read 的 open 模式仍从严按写入;`fs/walk` 按
目录级读取,`fs/getMetadata`、`fs/canonicalize` 等只看元数据的不过闸门,其余 `fs/` 方法按写入;
升级 Codex 后核对 exec-server 新增的方法,只读的要显式归类,否则会被当成写入拒掉(#5764)。
- B 的隧道对 A 映射不到的路径(虚拟工作区垫出的层级、B 自己上级目录下的点开头标记),以及 A 在 `open` 的
- `ancestorMarkers` 里报了「没有」的上级目录标记,只读查询直接回 exec-server
+ B 的隧道对镜像根内 A 映射不到的虚拟垫层,以及 A 在 `open` 的 `ancestorMarkers` 里明确报了「没有」的上级目录
+ 标记,只读查询由 B 本机回答。镜像根外的绝对路径照常转发,只有两端路径格式相同且 A 明确报告其缺失的标记
+ 才可本机回答;隐藏文件和未知外部标记不能凭名字判不存在。本机回答使用
原生的不存在错误 `-32004`(固定版本 `codex-rs/exec-server/src/remote_file_system.rs` 按 NotFound 处理),不转给 A;
B 的 Codex 在执行环境断开时按同一个 id 重新 `environment/add`,先用实验接口 `environment/status` 判断。两者都随
Codex 版本可能变化,升级时一并核对(见 [`remote-and-mobile-adaptation.md`](remote-and-mobile-adaptation.md)
diff --git a/docs/dev-rules/remote-and-mobile-adaptation.md b/docs/dev-rules/remote-and-mobile-adaptation.md
index e2f900ce5b..ca6eb23f04 100644
--- a/docs/dev-rules/remote-and-mobile-adaptation.md
+++ b/docs/dev-rules/remote-and-mobile-adaptation.md
@@ -150,10 +150,10 @@ relay 以 close 1013 `inbound backpressure` 主动断连,此时任何「立即
被控端和普通远控请求。被控端侧对无人拉取的任务按任务超时(3 分钟)收尾,不波及其它任务。
3. **多 peer**:被控端按 `(控制端, runId)` 隔离任务;默认每台控制设备最多 16 个任务、整机最多 64 个,
主人可在「远程与分享」调整(最多 1000)。控制端每台被控端一个拉取器,每次 `poll` 最多带 64 个任务,
- 按整批轮转,挂起最多 10s,长等待同时在途最多两个;另留一个补位名额,只在有「登记后还没被任何 poll
- 带上过」的新任务时使用(新任务排在最前),合计不超过 3 个,任务再多也不占满共享的 12 个在途配额。
- 补位名额解决的是:两个长等待都只含空闲的旧任务时,新任务的第一个事件(Codex 执行环境的 initialize
- 握手)要等旧长等待超时 10s 才有人拉,正好撞上 Codex 握手的 10s 上限(2026-10-22 调查)。
+ 按整批轮转,挂起最多 10s,长等待同时在途最多两个;另留一个补位名额给没有被在途 poll 覆盖的任务,直到
+ 普通 poll 接手(未覆盖任务排在最前并继续轮转),合计不超过 3 个,不占满共享的 12 个在途配额。
+ 补位名额解决的是:两个长等待都只含空闲的旧任务时,新任务的第一个事件及后续事件要等旧长等待超时 10s 才有人拉,
+ 正好撞上 Codex 执行环境 initialize 握手的 10s 上限(2026-10-22 调查)。
`poll.test.ts` 用 130 / 1000 个空闲任务验证拉取间隔始终短于 3 分钟的回收期限,并复现上述新任务等待。
被控端连续立即返回空结果时控制端放慢到 1s 一次,防止空转。2 台控制端共享被控端、
其中一台静默的回归仍需在双实例实机验证中补测。
@@ -185,12 +185,12 @@ relay 以 close 1013 `inbound backpressure` 主动断连,此时任何「立即
0.5–3s,启动几分钟、撞 5 分钟上限;握手失败后「能聊天但没有 Shell 与文件工具」):
- **不可能存在的路径在 Agent 所在电脑直接回答**(`host/execServerShortcut.ts`):Codex 沿工作目录逐级向上找
- `.git`、Skill 目录与插件清单。虚拟工作区垫出的层级(真实根目录以上的 `workspace/p/…`)、镜像根本身,以及镜像根
- 之外这台电脑上级目录下以点开头的标记(`.git`、`.agents`、`.codex-plugin` …)在任务所在电脑上没有对应目录
- (只认工作区及其真实上级、`home`、`tmp`、`additional`,见 `controller/startRemote.ts` 的 `shadowAliases`),
- 转过去只会被当作它自己的路径查、得到「不存在」。这类 `fs/getMetadata`、`fs/canonicalize`、`fs/readFile`、
+ `.git`、Skill 目录与插件清单。镜像根内的虚拟垫层(真实根目录以上的 `workspace/p/…`)及镜像根本身在任务电脑没有
+ 对应目录(已映射的工作区及真实上级、`home`、`tmp`、`additional` 除外,见 `controller/startRemote.ts` 的
+ `shadowAliases`)。镜像根外的绝对路径会原样转发,可能在任务电脑真实存在;只能按任务电脑明确报告的原始绝对路径
+ 标记缺失来回答,不能凭点前缀判断不存在,两端路径格式不同时不套用原始路径。可确认不存在的 `fs/getMetadata`、`fs/canonicalize`、`fs/readFile`、
`fs/readDirectory` 由隧道直接回 exec-server 原生的不存在错误(`-32004`,Codex 按 NotFound 处理,固定 0.159.2
- 源码与实测),不进事件流;其余照常转发。现场样本中约 150 次查询属于此类。
+ 源码与实测),不进事件流;其余照常转发。
工作区的**真实上级目录**在任务所在电脑上存在,Codex 在每一级查 `.git` 与三种插件清单(实测每级 6 次,项目在
9 层深处时 54 次)。任务所在电脑打开任务时报来各级有没有 `ANCESTOR_MARKER_NAMES` 里的名字(`open` 的可选字段
`ancestorMarkers`,`controller/projectFiles.ts` 的 `collectAncestorMarkers`,只看名字在不在、查不准按「有」),
@@ -199,10 +199,11 @@ relay 以 close 1013 `inbound backpressure` 主动断连,此时任何「立即
故障半径:只改这一个任务隧道上的只读查询,不动 link 与其它任务;`ancestorMarkers` 是可选字段,旧被控端解码时
丢弃、旧控制端不带,都退回逐个转发。回归:`mirror.test.ts` 用真实隧道、控制端映射与磁盘核对「本机回答的路径
在任务所在电脑上确实不存在,存在的照常转发」;`plumbing.test.ts` 核对格式不对整段丢弃。升级 Codex 时核对
- `-32004`、查询方法名与上级目录查找的名字。实测(2026-10-22,Windows 本机真实 Codex 0.159.2,项目 9 层深、
- 3 个 Skill,poll 与 push 各加延迟模拟链路):启动跨机请求 244 → 82(只回答垫出层级)→ 28(再加上级目录标记);
- 每次往返约 200ms 时启动 15.1s → 6.1s → 3.1s,约 800ms 时 53.9s → 21.9s → 10.1s。剩下的是工作区本身的查找
- 与真实 Skill 文件读取。
+ `-32004`、查询方法名与上级目录查找的名字。实测(2026-10-22,Windows 本机真实 Codex 0.159.2,临时项目含
+ 3 个 Skill,poll 与 push 各加 100/400ms 延迟模拟链路):启动转发消息 173 → 105(只回答镜像内垫层)→ 41
+ (再加已确认缺失的上级标记,含 1 条 initialized 通知)。模拟约 200ms 往返时启动 16.1s → 9.7s → 4.5s,
+ 约 800ms 时 56.8s → 34.9s → 15.5s;每组单次,计时到启动句柄返回,不含首个模型回复。先前 244 → 82 → 28
+ 的样本使用了镜像外点前缀推断,审查修复后不再作为最终代码数据。剩余包括工作区、真实 Skill 与未确认的外部查询。
- **执行环境断开后自动重新登记**(`codex/index.ts` 的 `repairHostedEnvironmentIfDisconnected`):首次握手失败的
环境,Codex 只记一次结果、之后每轮都跳过,链路恢复也不会自己重连。每轮 `turn/start` 前,隧道上已没有开着的
WebSocket 连接(`linkActivity` 的 `wsConnectionsOpen` 为 0)时问一次 `environment/status`;`disconnected` 或
@@ -210,7 +211,8 @@ relay 以 close 1013 `inbound backpressure` 主动断连,此时任何「立即
`failed_resolution_is_replaced_from_the_environment_manager` 同一路径)。连接开着时不发任何请求,正常发送不多一次
往返;查询或重新登记失败只记日志,照常发送。回归:`device-hosted-guest.test.ts`。
- **第一次启动期间删除或归档任务就让对方停下**(`controller/startRemote.ts` 的 `cancelPendingRemoteStart`,由
- 任务的运行期清理调用):控制端把连接标成已关闭,已发出的打开立即 `close`;被控端收到后不再换电脑、不再启动,
+ 任务的运行期清理调用):在第一处异步准备前登记取消状态;MCP 准备期间被取消的,准备完成后释放资源、不发 `open`。
+ 已开始连接时控制端把连接标成已关闭,已发出的打开立即 `close`;被控端收到后不再换电脑、不再启动,
迟到完成的 Agent 立刻关闭。此前启动阶段没有取消入口,对方会在几分钟后仍启动并跑完这一轮。回归:`roundtrip.test.ts`。
- **诊断**:任务所在电脑的本机 exec-server 首次输出超过 2s、或进程自己退出时记一条(退出码、信号、stderr 字节数、
运行时长,不记内容);供应商组中转的一批帧排队加推送超过 2s 时每个任务记第一次(排队与推送两段耗时)。