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(pi): 披露按 schema 指纹判定并按会话落盘,Pi 升级不再整片失效

Zhang Yunjin029a518fc1ad
diff --git a/packages/maker-core/src/agents/pi/__tests__/cindyBridgeSource.test.ts b/packages/maker-core/src/agents/pi/__tests__/cindyBridgeSource.test.ts
index 806a22b808..a11df57834 100644
--- a/packages/maker-core/src/agents/pi/__tests__/cindyBridgeSource.test.ts
+++ b/packages/maker-core/src/agents/pi/__tests__/cindyBridgeSource.test.ts
@@ -14,6 +14,7 @@ import {
writeFileSync,
} from 'node:fs';
import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
import { tmpdir } from 'node:os';
import * as path from 'node:path';
import { createInterface } from 'node:readline';
@@ -1623,8 +1624,13 @@ describe('cindy-bridge extension source', () => {
);
expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain("qualifiedName: 'mcp__' + serverName + '__' + toolName");
expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain('private readonly disclosedSchemas');
+ // 披露判定按 schema 指纹(Pi 升级不再整片失效)+ 按会话落盘;门本身保持上游的
+ // 严格 fail closed:未披露的调用被拦下、不触达 MCP、不记账。
+ expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain('private schemaFingerprint(');
+ expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain('markSchemaDisclosed(call: ResolvedMcpGatewayCall)');
expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain('mcpGateway.isSchemaDisclosed(resolvedGatewayCall)');
expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain('Inspect this tool before execution');
+ expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain('const gatewayCall = resolvedGatewayCall && mcpGateway.isSchemaDisclosed(resolvedGatewayCall)');
expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain('permissionToolName = gatewayCall?.qualifiedName');
expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain('permissionInput = gatewayCall?.args');
expect(CINDY_BRIDGE_EXTENSION_SOURCE).toContain(
@@ -2316,6 +2322,9 @@ it('routes Bot shortcuts through the scoped helper entry without exposing them t
{ compilerOptions: { module: ts.ModuleKind.None, target: ts.ScriptTarget.ES2022 } },
).outputText;
const context: Record<string, any> = {
+ // 沙箱没有模块系统:bridge 顶部的 node:crypto import 在切片后丢失,
+ // 指纹计算用的 createHash 必须由宿主注入。
+ createHash,
recordInput: (value: unknown) => value && typeof value === 'object' ? value : {},
mcpContentToPi: (content: unknown) => content,
};
@@ -2461,6 +2470,9 @@ it('lets cindy_mcp_call_tool omit args and forwards an empty object for no-param
{ compilerOptions: { module: ts.ModuleKind.None, target: ts.ScriptTarget.ES2022 } },
).outputText;
const context: Record<string, any> = {
+ // 沙箱没有模块系统:bridge 顶部的 node:crypto import 在切片后丢失,
+ // 指纹计算用的 createHash 必须由宿主注入(PR #6002 的 schemaFingerprint 走 sha256)。
+ createHash,
recordInput: (value: unknown) => value && typeof value === 'object' ? value : {},
mcpContentToPi: (content: unknown) => content,
};
@@ -2517,6 +2529,9 @@ it('tells the model the call_tool envelope instead of forwarding a flattened env
{ compilerOptions: { module: ts.ModuleKind.None, target: ts.ScriptTarget.ES2022 } },
).outputText;
const context: Record<string, any> = {
+ // 沙箱没有模块系统:bridge 顶部的 node:crypto import 在切片后丢失,
+ // 指纹计算用的 createHash 必须由宿主注入。
+ createHash,
recordInput: (value: unknown) => value && typeof value === 'object' ? value : {},
mcpContentToPi: (content: unknown) => content,
};
@@ -2556,6 +2571,9 @@ it('does not apply the Cindy envelope rule to a third-party tool also named call
{ compilerOptions: { module: ts.ModuleKind.None, target: ts.ScriptTarget.ES2022 } },
).outputText;
const context: Record<string, any> = {
+ // 沙箱没有模块系统:bridge 顶部的 node:crypto import 在切片后丢失,
+ // 指纹计算用的 createHash 必须由宿主注入。
+ createHash,
recordInput: (value: unknown) => value && typeof value === 'object' ? value : {},
mcpContentToPi: (content: unknown) => content,
};
@@ -2614,6 +2632,9 @@ it('leaves a direct tool alone when its required name is not the Cindy envelope'
{ compilerOptions: { module: ts.ModuleKind.None, target: ts.ScriptTarget.ES2022 } },
).outputText;
const context: Record<string, any> = {
+ // 沙箱没有模块系统:bridge 顶部的 node:crypto import 在切片后丢失,
+ // 指纹计算用的 createHash 必须由宿主注入。
+ createHash,
recordInput: (value: unknown) => value && typeof value === 'object' ? value : {},
mcpContentToPi: (content: unknown) => content,
};
diff --git a/packages/maker-core/src/agents/pi/__tests__/mcpDisclosureFingerprint.test.ts b/packages/maker-core/src/agents/pi/__tests__/mcpDisclosureFingerprint.test.ts
new file mode 100644
index 0000000000..590c7dc406
--- /dev/null
+++ b/packages/maker-core/src/agents/pi/__tests__/mcpDisclosureFingerprint.test.ts
@@ -0,0 +1,356 @@
+import { createHash } from 'node:crypto';
+import { runInNewContext } from 'node:vm';
+import ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+import { CINDY_BRIDGE_EXTENSION_SOURCE } from '../cindy-bridge-source.js';
+
+// 把 CindyMcpGateway 从 bridge 源码里切出来,在 VM 中用桩件驱动。断言都走真实入口
+// (register 后的 cindy_mcp_call_tool / cindy_mcp_list_tools),不直接调内部方法:披露门、
+// MCP 请求次数、落盘与重载都在同一条路径上被验证。
+//
+// 本 PR 只治「披露记录整片失效」:判定按 schema 指纹、按会话落盘。门本身保持上游的
+// 严格 fail closed —— 未披露的调用被拦下、不触达 MCP、不记账;模型显式 list_tools 后
+// 才算披露,随后放行。
+const source = CINDY_BRIDGE_EXTENSION_SOURCE;
+// 从工具名常量切到 CindyMcpGateway 类结束:register() 用到的常量与 helper 都在这段里,
+// 因此 register 后的 cindy_mcp_call_tool 走的是与生产同一条代码路径。
+const sliceStart = source.indexOf("const CINDY_MCP_LIST_TOOLS = 'cindy_mcp_list_tools'");
+const classStart = source.indexOf('class CindyMcpGateway {');
+const classEnd = source.indexOf('\n}\n', classStart) + 3;
+if (sliceStart < 0 || classStart < sliceStart || classEnd <= classStart) {
+ throw new Error('CindyMcpGateway slice not found in bridge source');
+}
+const GATEWAY_SOURCE = source.slice(sliceStart, classEnd);
+
+type DisclosedFile = { version: number; entries: Record<string, string> };
+type ToolDescriptor = { name: string; description?: string; inputSchema?: unknown };
+
+const TOOL: ToolDescriptor = {
+ name: 'send_to_worker',
+ description: '向指定 worker 投递消息',
+ inputSchema: { type: 'object', properties: { message: { type: 'string' } } },
+};
+const TOOL_CHANGED: ToolDescriptor = { ...TOOL, description: '向指定 worker 投递消息(v2)' };
+
+function fingerprint(tool: ToolDescriptor): string {
+ const description = typeof tool.description === 'string' && tool.description.length > 0
+ ? tool.description
+ : 'MCP tool ' + tool.name + ' from cindy_orca';
+ const inputSchema = tool.inputSchema && typeof tool.inputSchema === 'object'
+ ? tool.inputSchema
+ : { type: 'object', properties: {}, additionalProperties: true };
+ return createHash('sha256').update(JSON.stringify([tool.name, description, inputSchema])).digest('hex');
+}
+
+function loadGateway(options: {
+ stored?: DisclosedFile | null;
+ writeFails?: boolean;
+ /** 磁盘上已有内容(用于多实例合并场景),优先于 stored。 */
+ onDisk?: DisclosedFile | null;
+ /** 预先存在的锁文件持锁 pid;777 = 活进程,999 = 已退出进程。 */
+ lockOwner?: number;
+ /** process.kill(pid, 0) 抛出的错误码,默认 ESRCH。 */
+ killErrorCode?: string;
+ /** 模拟回收残留锁时被另一个实例抢先(rename 失败)。 */
+ reclaimLostRace?: boolean;
+} = {}) {
+ const writes: DisclosedFile[] = [];
+ const renames: string[] = [];
+ const warnings: string[] = [];
+ const requests: unknown[] = [];
+ const disk: { value: DisclosedFile | null } = { value: options.onDisk ?? options.stored ?? null };
+ const alivePids = new Set<number>([4242, 777]);
+ // 锁文件独立于披露文件,由外部(另一实例或崩溃残留)直接写入。
+ // 锁文件独立于披露文件,由外部(另一实例或崩溃残留)直接写入;null = 不存在。
+ const lockFile: { value: string | null } = { value: null };
+ if (options.lockOwner !== undefined) lockFile.value = String(options.lockOwner);
+ const externalWrite = (value: DisclosedFile) => { disk.value = value; };
+ const reclaimed: string[] = [];
+
+ const code = ts.transpileModule(
+ `${GATEWAY_SOURCE}\n(globalThis as any).CindyMcpGateway = CindyMcpGateway;`,
+ { compilerOptions: { target: ts.ScriptTarget.ES2022 } },
+ ).outputText;
+
+ const sandbox: Record<string, unknown> = {
+ console: { warn: (line: string) => warnings.push(line) },
+ process: {
+ pid: 4242,
+ env: {
+ CINDY_PI_PERMISSION_FILE: '/runtime/perm-s1.json',
+ CINDY_PI_SESSION_ID: 's1',
+ },
+ kill: (pid: number, signal: number) => {
+ if (alivePids.has(pid)) {
+ if (signal !== 0) alivePids.delete(pid);
+ return;
+ }
+ throw Object.assign(new Error('kill failed'), { code: options.killErrorCode ?? 'ESRCH' });
+ },
+ },
+ path: {
+ join: (...parts: string[]) => parts.join('/'),
+ dirname: (file: string) => file.slice(0, file.lastIndexOf('/')),
+ },
+ readFileSync: (file: string) => {
+ if (file.endsWith('.lock')) {
+ if (lockFile.value === null) throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+ return lockFile.value;
+ }
+ if (disk.value === null) throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+ return JSON.stringify(disk.value);
+ },
+ writeFileSync: (file: string, body: string) => {
+ if (options.writeFails) throw Object.assign(new Error('denied'), { code: 'EACCES' });
+ if (file.endsWith('.lock')) {
+ lockFile.value = body; // 记录持锁 pid
+ return;
+ }
+ disk.value = JSON.parse(body) as DisclosedFile;
+ writes.push(disk.value);
+ },
+ renameSync: (from: string, to: string) => {
+ if (options.reclaimLostRace && from.endsWith('.lock')) {
+ // 模拟另一个实例先把残留锁回收并重建了新锁:本实例的 rename 失败。
+ throw Object.assign(new Error('lock gone'), { code: 'ENOENT' });
+ }
+ if (from.endsWith('.lock')) lockFile.value = null;
+ renames.push(`${from} -> ${to}`);
+ },
+ rmSync: (file: string) => {
+ if (file.endsWith('.lock') && !file.includes('.stale-')) lockFile.value = null;
+ reclaimed.push(file);
+ },
+ openSync: (file: string, flags: string) => {
+ if (flags === 'wx' && lockFile.value !== null) {
+ throw Object.assign(new Error('locked'), { code: 'EEXIST' });
+ }
+ if (flags === 'wx') lockFile.value = '';
+ return 7;
+ },
+ closeSync: () => undefined,
+ createHash,
+ fetch: async (_url: string, init: { body: string } & Record<string, unknown>) => {
+ requests.push(JSON.parse(init.body));
+ return new Response(
+ JSON.stringify({ jsonrpc: '2.0', id: 1, result: { content: [{ type: 'text', text: 'delivered' }] } }),
+ { status: 200, headers: { 'content-type': 'application/json' } },
+ );
+ },
+ Response: globalThis.Response,
+ URL,
+ Headers,
+ AbortController,
+ TextDecoder,
+ setTimeout,
+ clearTimeout,
+ };
+ runInNewContext(code, sandbox);
+
+ const Gateway = sandbox.CindyMcpGateway as new () => {
+ add(server: string, client: unknown, tools: ToolDescriptor[]): void;
+ register(pi: unknown, options?: unknown): void;
+ resolveCall(input: unknown): unknown;
+ };
+ const gateway = new Gateway();
+
+ // executeResolvedCall 走 tool.client.request;用最小 client 桩替代 HTTP 层,
+ // 每次真实调用都会在 requests 里留下一条,正好用来断言“恰好执行一次”。
+ const httpClient = {
+ request: async (_method: string, params: { name: string; arguments: unknown }) => {
+ requests.push(params);
+ return { content: [{ type: 'text', text: 'delivered' }] };
+ },
+ };
+ gateway.add('cindy_orca', httpClient, [TOOL]);
+
+ const registered: { name: string; execute: (id: string, params: unknown) => Promise<unknown> }[] = [];
+ gateway.register({ registerTool: (tool: { name: string; execute: unknown }) => registered.push(tool as never) });
+ const callTool = registered.find((t) => t.name === 'cindy_mcp_call_tool');
+ const listTools = registered.find((t) => t.name === 'cindy_mcp_list_tools');
+ if (!callTool || !listTools) throw new Error('gateway tools not registered');
+
+ return {
+ gateway,
+ httpClient,
+ externalWrite,
+ reclaimed,
+ writes,
+ renames,
+ warnings,
+ requests,
+ disk,
+ callRaw: (args: Record<string, unknown> = { message: 'hi' }) =>
+ callTool.execute('call-1', { server: 'cindy_orca', tool: 'send_to_worker', args }),
+ // 默认模拟真实模型的两步:第一次被路标拦下 → 显式 list_tools 查完 schema → 重发。
+ // 只有验证拦截语义的用例用 callRaw;其他错误(如 zod 拒参)原样抛出,不在此处吞掉。
+ call: async (args: Record<string, unknown> = { message: 'hi' }) => {
+ const input = { server: 'cindy_orca', tool: 'send_to_worker', args };
+ try {
+ return await callTool.execute('call-1', input);
+ } catch (error) {
+ const message = error instanceof Error ? error.message : String(error);
+ if (!message.includes('Inspect this tool before execution')) throw error;
+ await listTools.execute('list-1', { server: 'cindy_orca', tool: 'send_to_worker' });
+ return callTool.execute('call-2', input);
+ }
+ },
+ list: () => listTools.execute('list-1', { server: 'cindy_orca', tool: 'send_to_worker' }),
+ };
+}
+
+describe('MCP gateway schema disclosure', () => {
+ it('blocks the first uninspected call without touching MCP, and discloses only after list_tools', async () => {
+ const { gateway, callRaw, list, requests, warnings, writes, disk } = loadGateway();
+ const resolved = gateway.resolveCall({ server: 'cindy_orca', tool: 'send_to_worker' }) as { tool: unknown };
+ // 事前未披露
+ expect((gateway as unknown as { isSchemaDisclosed(c: unknown): boolean })
+ .isSchemaDisclosed(resolved)).toBe(false);
+
+ // 第一次:被拦下,一个 MCP 请求都不该发出去;回执必须指名要查的 server/tool
+ const first = await callRaw().then(() => null, (error: Error) => error);
+ expect(first?.message).toContain('Inspect this tool before execution');
+ expect(first?.message).toContain('"server":"cindy_orca"');
+ expect(first?.message).toContain('"tool":"send_to_worker"');
+ expect(requests).toHaveLength(0);
+ // 门保持 fail closed:被拦的那次不记账、不落盘
+ expect(writes).toHaveLength(0);
+ expect(disk.value).toBeNull();
+
+ // 显式查完 schema 才算披露:此时记账并落盘
+ await list();
+ expect(disk.value?.entries['cindy_orca\u0000send_to_worker']).toBe(fingerprint(TOOL));
+ expect(writes).toHaveLength(1);
+
+ // 之后重发:放行并执行成功
+ const result = await callRaw();
+ expect(requests).toHaveLength(1);
+ expect(result).toMatchObject({ content: [{ type: 'text', text: 'delivered' }] });
+ expect(writes).toHaveLength(1);
+ });
+
+ it('reuses a persisted disclosure after a reload when the schema is unchanged', async () => {
+ const stored: DisclosedFile = {
+ version: 1,
+ entries: { 'cindy_orca\u0000send_to_worker': fingerprint(TOOL) },
+ };
+ const { gateway, call, requests, warnings, writes } = loadGateway({ stored });
+
+ expect((gateway as unknown as { isSchemaDisclosed(c: unknown): boolean })
+ .isSchemaDisclosed(gateway.resolveCall({ server: 'cindy_orca', tool: 'send_to_worker' }))).toBe(true);
+ await call();
+
+ expect(requests).toHaveLength(1);
+ expect(warnings).toHaveLength(0);
+ expect(writes).toHaveLength(0);
+ });
+
+ it('re-arms the gate when the tool schema actually changes', async () => {
+ const stored: DisclosedFile = {
+ version: 1,
+ entries: { 'cindy_orca\u0000send_to_worker': fingerprint(TOOL) },
+ };
+ const { gateway, httpClient, callRaw, list, requests, warnings, disk } = loadGateway({ stored });
+
+ // 同一会话内工具描述变化(MCP 重连后拿到新 schema)→ 指纹失配 → 门重新武装
+ gateway.add('cindy_orca', httpClient, [TOOL_CHANGED]);
+ const changed = gateway.resolveCall({ server: 'cindy_orca', tool: 'send_to_worker' }) as { tool: unknown };
+ expect((gateway as unknown as { isSchemaDisclosed(c: unknown): boolean })
+ .isSchemaDisclosed(changed)).toBe(false);
+
+ const first = await callRaw().then(() => null, (error: Error) => error);
+ expect(first?.message).toContain('"tool":"send_to_worker"');
+ expect(requests).toHaveLength(0);
+
+ // 重新查一次新 schema 才重新披露
+ await list();
+ expect(disk.value?.entries['cindy_orca\u0000send_to_worker']).toBe(fingerprint(TOOL_CHANGED));
+ await callRaw();
+ expect(requests).toHaveLength(1);
+ });
+
+ it('merges a record another instance wrote after startup instead of overwriting it', async () => {
+ // 关键:另一实例的写入发生在本实例**构造之后**,本实例内存里没有这条记录,
+ // 因此只有落盘时的读-合并才能保住它(删掉合并循环这条测试就会红)。
+ const { call, disk, renames, externalWrite } = loadGateway();
+ const otherKey = 'cindy_other\u0000other_tool';
+ const otherFingerprint = fingerprint({ name: 'other_tool', description: '别的工具' });
+ externalWrite({ version: 1, entries: { [otherKey]: otherFingerprint } });
+
+ await call();
+
+ expect(disk.value?.entries[otherKey]).toBe(otherFingerprint);
+ expect(disk.value?.entries['cindy_orca\u0000send_to_worker']).toBe(fingerprint(TOOL));
+ // 原子替换:先写 tmp 再 rename
+ expect(renames).toHaveLength(1);
+ expect(renames[0]).toContain('.tmp');
+ });
+
+ it('recovers a lock left behind by a crashed instance and persists', async () => {
+ // 持锁 pid 999 已退出 → 锁必须被回收,本进程仍能落盘。
+ const { call, disk } = loadGateway({ lockOwner: 999 });
+ await call();
+ expect(disk.value?.entries['cindy_orca\u0000send_to_worker']).toBe(fingerprint(TOOL));
+ });
+
+ it('skips persisting while another live instance holds the lock, without breaking the gate', async () => {
+ const { gateway, call, requests, disk } = loadGateway({ lockOwner: 777 });
+ await call();
+ expect(requests).toHaveLength(1);
+ expect(disk.value).toBeNull();
+ // 本进程内存里的披露已生效
+ expect((gateway as unknown as { isSchemaDisclosed(c: unknown): boolean })
+ .isSchemaDisclosed(gateway.resolveCall({ server: 'cindy_orca', tool: 'send_to_worker' }))).toBe(true);
+ });
+
+ it('keeps a stale lock when the liveness probe fails for a reason other than ESRCH', async () => {
+ // EINVAL 等非 ESRCH 错误不能证明进程已退出 → 不回收,跳过落盘但不挡工具执行。
+ const { gateway, call, requests, disk } = loadGateway({ lockOwner: 999, killErrorCode: 'EINVAL' });
+ await call();
+ expect(requests).toHaveLength(1);
+ expect(disk.value).toBeNull();
+ expect((gateway as unknown as { isSchemaDisclosed(c: unknown): boolean })
+ .isSchemaDisclosed(gateway.resolveCall({ server: 'cindy_orca', tool: 'send_to_worker' }))).toBe(true);
+ });
+
+ it('skips persisting when another instance reclaimed the stale lock first', async () => {
+ // 回收必须与重新加锁互斥:rename 失败说明锁已被别人收走/重建,本实例直接放弃,
+ // 不能继续 rmSync(那会删掉对方刚建的锁,两边都进写入路径互相覆盖记录)。
+ const { call, requests, disk, reclaimed } = loadGateway({ lockOwner: 999, reclaimLostRace: true });
+ await call();
+ expect(requests).toHaveLength(1);
+ expect(disk.value).toBeNull();
+ expect(reclaimed.some((file) => file.endsWith('.lock') && !file.includes('.stale-'))).toBe(false);
+ });
+
+ it('treats a missing or corrupt disclosure file as undisclosed and still executes', async () => {
+ for (const stored of [
+ null,
+ { version: 1, entries: { 'cindy_orca\u0000send_to_worker': 'not-a-hash' } },
+ ] as (DisclosedFile | null)[]) {
+ const { gateway, call, requests } = loadGateway({ stored });
+ expect((gateway as unknown as { isSchemaDisclosed(c: unknown): boolean })
+ .isSchemaDisclosed(gateway.resolveCall({ server: 'cindy_orca', tool: 'send_to_worker' }))).toBe(false);
+ await call();
+ expect(requests).toHaveLength(1);
+ }
+ });
+
+ it('keeps the in-memory gate working when the disclosure file cannot be written', async () => {
+ const { gateway, call, requests, writes } = loadGateway({ writeFails: true });
+ await call();
+ expect(requests).toHaveLength(1);
+ expect(writes).toHaveLength(0);
+ expect((gateway as unknown as { isSchemaDisclosed(c: unknown): boolean })
+ .isSchemaDisclosed(gateway.resolveCall({ server: 'cindy_orca', tool: 'send_to_worker' }))).toBe(true);
+ });
+
+ it('records disclosure through cindy_mcp_list_tools too', async () => {
+ const { gateway, list, requests, disk } = loadGateway();
+ await list();
+ expect(requests).toHaveLength(0);
+ expect(disk.value?.entries['cindy_orca\u0000send_to_worker']).toBe(fingerprint(TOOL));
+ expect((gateway as unknown as { isSchemaDisclosed(c: unknown): boolean })
+ .isSchemaDisclosed(gateway.resolveCall({ server: 'cindy_orca', tool: 'send_to_worker' }))).toBe(true);
+ });
+});
\ No newline at end of file
diff --git a/packages/maker-core/src/agents/pi/__tests__/pi-mcp-bridge.integration.test.ts b/packages/maker-core/src/agents/pi/__tests__/pi-mcp-bridge.integration.test.ts
index 7b3268ebe2..357c43f21d 100644
--- a/packages/maker-core/src/agents/pi/__tests__/pi-mcp-bridge.integration.test.ts
+++ b/packages/maker-core/src/agents/pi/__tests__/pi-mcp-bridge.integration.test.ts
@@ -927,6 +927,9 @@ describe.skipIf(!piAvailable)('PiAgent × cindy-bridge (real pi + MCP bridge + p
| 'local' | 'orca' | 'local-multi' | 'bot-memory' | 'remote' | 'remote-sse' | 'remote-paginated' = 'local',
prompt = 'call the echo tool',
localHostOnly: boolean | 'native' = false,
+ // 披露记录按 sessionId 落盘,所以要真正走到「首次未披露」必须给独立会话;
+ // 否则同文件前序用例已落盘的披露会让首次调用直接执行,掩盖门的行为。
+ sessionId = `mcp-itest-${permissionMode}`,
): Promise<{
events: AgentEvent[];
permissionAsked: boolean;
@@ -941,7 +944,7 @@ describe.skipIf(!piAvailable)('PiAgent × cindy-bridge (real pi + MCP bridge + p
let permissionAsked = false;
try {
handle = await agent.startSession({
- sessionId: `mcp-itest-${permissionMode}`,
+ sessionId,
workingDir: cwd,
model: 'pi-test-model',
permissionMode,
@@ -1476,6 +1479,9 @@ describe.skipIf(!piAvailable)('PiAgent × cindy-bridge (real pi + MCP bridge + p
},
'local',
'call without schema inspection',
+ // 披露记录按会话落盘:给独立会话,才走得到「首次未披露」。
+ false,
+ 'mcp-itest-uninspected-first-call',
);
expect(permissionAsked).toBe(true);
diff --git a/packages/maker-core/src/agents/pi/__tests__/pi-mcp-client.test.ts b/packages/maker-core/src/agents/pi/__tests__/pi-mcp-client.test.ts
index 600759015a..ae5117e69f 100644
--- a/packages/maker-core/src/agents/pi/__tests__/pi-mcp-client.test.ts
+++ b/packages/maker-core/src/agents/pi/__tests__/pi-mcp-client.test.ts
@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
import { runInNewContext } from 'node:vm';
import ts from 'typescript';
import { afterEach, describe, expect, it, vi } from 'vitest';
@@ -14,7 +15,9 @@ function gatewayWithFetch(fetchImpl: typeof fetch) {
).outputText;
const context: Record<string, any> = {
fetch: fetchImpl, URL, Headers, AbortController, TextDecoder, process: { env: {} },
- setTimeout, clearTimeout,
+ // 沙箱没有模块系统:bridge 顶部的 node:crypto import 在切片后丢失,
+ // 指纹计算用的 createHash 必须由宿主注入。
+ setTimeout, clearTimeout, createHash,
};
runInNewContext(compiled, context);
const client = new context.Client({ name: 'cindy', url: 'http://127.0.0.1/mcp' }, 'fake-token');
diff --git a/packages/maker-core/src/agents/pi/cindy-bridge-source.ts b/packages/maker-core/src/agents/pi/cindy-bridge-source.ts
index 17d205b059..815bab27b2 100644
--- a/packages/maker-core/src/agents/pi/cindy-bridge-source.ts
+++ b/packages/maker-core/src/agents/pi/cindy-bridge-source.ts
@@ -65,7 +65,11 @@ export const CINDY_PI_BASH_MAX_TIMEOUT_SECONDS = 1800;
export const CINDY_BRIDGE_EXTENSION_SOURCE = String.raw`/**
* cindy-bridge (generated by Cindy — do not edit; overwritten on session start)
*/
-import { globSync, lstatSync, opendirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import {
+ closeSync, globSync, lstatSync, openSync, opendirSync, readFileSync, realpathSync,
+ renameSync, rmSync, statSync, writeFileSync,
+} from 'node:fs';
+import { createHash } from 'node:crypto';
import { stat } from 'node:fs/promises';
import { spawn } from 'node:child_process';
import { createInterface } from 'node:readline';
@@ -2866,6 +2870,64 @@ function mcpGatewayKey(serverName: string, toolName: string): string {
return serverName + '\u0000' + toolName;
}
+/**
+ * 取披露文件写入锁(独占创建,跨进程可见),拿不到时返回 undefined 让调用方跳过落盘。
+ *
+ * 锁文件里记持锁进程 pid:持锁进程异常退出后锁会残留,若不回收,这个会话就永远写不进
+ * 披露记录(下次启动又重新自愈一遍、反复输出审计日志)。因此遇到已存在的锁时,只有
+ * 确认持锁进程已不存在才回收重建;进程还活着、pid 读不出来或与自己相同就不猜,宁可
+ * 跳过这一次落盘——本进程内存里的披露仍然有效。
+ */
+function acquireDisclosureLock(lockPath: string): boolean {
+ for (let attempt = 0; attempt < 2; attempt += 1) {
+ try {
+ // fd 只参与 wx 独占创建这一步;锁语义是文件存在性 + pid 内容,写完即可释放。
+ const fd = openSync(lockPath, 'wx', 0o600);
+ try { writeFileSync(lockPath, String(process.pid)); } catch { /* pid 写不进去时只当普通锁 */ }
+ try { closeSync(fd); } catch { /* 关闭失败不影响已持有的锁 */ }
+ return true;
+ } catch {
+ if (attempt === 1) return false;
+ const owner = readLockOwner(lockPath);
+ if (owner === undefined || owner === process.pid || isProcessAlive(owner)) return false;
+ // 回收:把残留锁**原子地挪走**,只有 rename 成功的那个实例才有权回收。否则两个
+ // 实例会先各自读到旧 owner,然后都执行 rmSync——A 删掉旧锁并重新加锁后,B 仍然
+ // 会把 A 的新锁删掉,两边同时进入写入路径,后一次替换覆盖前一次刚存的披露记录。
+ const stale = lockPath + '.stale-' + process.pid;
+ try { rmSync(stale, { force: true }); } catch { /* 上次没清掉的回收槽 */ }
+ try {
+ renameSync(lockPath, stale);
+ } catch {
+ return false; // 已被另一个实例回收或重建:不争,跳过本次落盘。
+ }
+ try { rmSync(stale, { force: true }); } catch { /* 残留回收槽不影响正确性 */ }
+ }
+ }
+ return false;
+}
+
+function readLockOwner(lockPath: string): number | undefined {
+ try {
+ const pid = Number.parseInt(readFileSync(lockPath, 'utf8').trim(), 10);
+ return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+ } catch {
+ return undefined;
+ }
+}
+
+function isProcessAlive(pid: number): boolean {
+ try {
+ process.kill(pid, 0);
+ return true;
+ } catch (error) {
+ // 只有明确的 ESRCH(进程确实不存在)才允许回收锁。EPERM = 进程存在但不属于当前
+ // 用户;EINVAL / 平台不支持 signal 0 等其他错误一律保守当作“可能还活着”,宁可
+ // 这一次不落盘,也不误删另一个实例正在使用的锁。
+ return (error as { code?: string }).code !== 'ESRCH';
+ }
+}
+
+
function recordInput(value: unknown): Record<string, unknown> {
return value && typeof value === 'object' && !Array.isArray(value)
? value as Record<string, unknown>
@@ -2885,10 +2947,82 @@ function schemaHint(schema: Record<string, unknown>): string {
class CindyMcpGateway {
private readonly tools = new Map<string, ConnectedMcpTool>();
private readonly unavailableServers = new Map<string, string>();
- private readonly disclosedSchemas = new Set<string>();
+ /** 已披露工具:键为 server + NUL + tool,值为该工具当前 schema 的指纹。 */
+ private readonly disclosedSchemas = new Map<string, string>();
private botMemoryFacadeEnabled = false;
private botHelperFacadeEnabled = false;
+ constructor() {
+ this.loadDisclosures();
+ }
+
+ /** 宿主下发的 runtime 目录锚点(权限文件同级);缺失时只在内存里记账。 */
+ private disclosureFile(): string | null {
+ const env = typeof process === 'undefined' ? undefined : process.env;
+ const permissionFile = env?.CINDY_PI_PERMISSION_FILE;
+ const sessionId = env?.CINDY_PI_SESSION_ID;
+ if (!permissionFile || !sessionId) return null;
+ return path.join(path.dirname(permissionFile), 'mcp-disclosure-' + sessionId + '.json');
+ }
+
+ private schemaFingerprint(tool: { name: string; description: string; inputSchema: unknown }): string {
+ return createHash('sha256')
+ .update(JSON.stringify([tool.name, tool.description, tool.inputSchema]))
+ .digest('hex');
+ }
+
+ private loadDisclosures(): void {
+ const file = this.disclosureFile();
+ if (!file) return;
+ try {
+ const parsed = JSON.parse(readFileSync(file, 'utf8')) as {
+ version?: unknown; entries?: unknown;
+ };
+ if (parsed?.version !== 1 || !parsed.entries || typeof parsed.entries !== 'object') return;
+ for (const [key, fingerprint] of Object.entries(parsed.entries as Record<string, unknown>)) {
+ if (typeof fingerprint === 'string' && /^[a-f0-9]{64}$/.test(fingerprint)) {
+ this.disclosedSchemas.set(key, fingerprint);
+ }
+ }
+ } catch {
+ // 缺失/损坏 = 未披露(fail-closed),下一次调用走自愈路径。
+ }
+ }
+
+ private persistDisclosures(): void {
+ const file = this.disclosureFile();
+ if (!file) return;
+ const temp = file + '.' + process.pid + '.tmp';
+ try {
+ const lockPath = file + '.lock';
+ if (!acquireDisclosureLock(lockPath)) return;
+ try {
+ const merged = new Map<string, string>(this.disclosedSchemas);
+ try {
+ const existing = JSON.parse(readFileSync(file, 'utf8')) as {
+ version?: unknown; entries?: unknown;
+ };
+ if (existing?.version === 1 && existing.entries && typeof existing.entries === 'object') {
+ for (const [key, fingerprint] of Object.entries(existing.entries as Record<string, unknown>)) {
+ if (typeof fingerprint === 'string' && /^[a-f0-9]{64}$/.test(fingerprint)) {
+ if (!merged.has(key)) merged.set(key, fingerprint);
+ }
+ }
+ }
+ } catch {
+ // 磁盘记录缺失/损坏:按只有本进程记录处理。
+ }
+ writeFileSync(temp, JSON.stringify({ version: 1, entries: Object.fromEntries(merged) }), { mode: 0o600 });
+ renameSync(temp, file);
+ } finally {
+ try { rmSync(lockPath, { force: true }); } catch { /* 残留锁由下次写入回收 */ }
+ }
+ } catch {
+ // 落盘失败只影响下次启动的体验,不影响本次门与自愈。
+ try { rmSync(temp, { force: true }); } catch { /* 忽略 */ }
+ }
+ }
+
add(serverName: string, client: McpHttpClient, tools: any[]): void {
for (const rawTool of tools) {
if (!rawTool || typeof rawTool !== 'object' || typeof rawTool.name !== 'string' || !rawTool.name) {
@@ -3035,7 +3169,21 @@ class CindyMcpGateway {
}
isSchemaDisclosed(call: ResolvedMcpGatewayCall): boolean {
- return this.disclosedSchemas.has(mcpGatewayKey(call.tool.serverName, call.tool.name));
+ const key = mcpGatewayKey(call.tool.serverName, call.tool.name);
+ return this.disclosedSchemas.get(key) === this.schemaFingerprint(call.tool);
+ }
+
+ /**
+ * 按当前 schema 记一次披露并落盘。披露判定按 schema 指纹而非 Pi 版本:Pi 升级不会
+ * 作废未变 schema 的披露;schema 真变动时指纹失配,门重新武装。
+ */
+ markSchemaDisclosed(call: ResolvedMcpGatewayCall): boolean {
+ const key = mcpGatewayKey(call.tool.serverName, call.tool.name);
+ const fingerprint = this.schemaFingerprint(call.tool);
+ if (this.disclosedSchemas.get(key) === fingerprint) return false;
+ this.disclosedSchemas.set(key, fingerprint);
+ this.persistDisclosures();
+ return true;
}
/**
@@ -3123,7 +3271,7 @@ class CindyMcpGateway {
availableTools: tools.map((tool) => tool.name),
};
} else {
- this.disclosedSchemas.add(mcpGatewayKey(serverName, toolName));
+ this.markSchemaDisclosed({ tool: selected, args: {} } as ResolvedMcpGatewayCall);
payload = {
ok: true,
tools: [{