zsjz-ai/ai-electron/scripts/codex-ipc-probe.html

<!doctype html>
<html lang="zh">
  <head>
    <meta charset="utf-8" />
    <title>Codex IPC 探针</title>
    <style>
      body { font: 12px/1.6 Consolas, monospace; margin: 16px; }
      .ok { color: #1a7f37; }
      .bad { color: #c00; }
    </style>
  </head>
  <body>
    <pre id="out">Codex IPC probe running…</pre>
    <script>
      /**
       * 真实 Electron IPC 链路探针：在应用窗口内逐条调用 controller/codexCtl/*，
       * 覆盖结构化克隆（含 Uint8Array 入参）、错误包装、以及真实 codex 子进程往返。
       *
       * 用法（env 开关，不污染常规 dev 启动）：
       *   ZSJZ_CODEX_PROBE=file:///<repo>/ai-electron/scripts/codex-ipc-probe.html \
       *   ZSJZ_CODEX_PROBE_OUT=./scripts/codex-ipc-probe.json npx electron . --env=local
       */
      const { ipcRenderer } = require('electron');
      const fs = require('node:fs');
      const os = require('node:os');
      const path = require('node:path');

      const outFile = process.env.ZSJZ_CODEX_PROBE_OUT || path.join(os.tmpdir(), 'codex-ipc-probe.json');
      const results = [];
      const pre = document.getElementById('out');

      const call = (method, params) => ipcRenderer.invoke(`controller/codexCtl/${method}`, params);
      /** 既有的 osCtl controller（窗口控制 / 打开本机文件等） */
      const osCall = (method, params) => ipcRenderer.invoke(`controller/osCtl/${method}`, params);

      function log(name, ok, detail) {
        results.push({ name, ok, detail });
        pre.innerHTML += `\n<span class="${ok ? 'ok' : 'bad'}">${ok ? 'PASS' : 'FAIL'} ${name}</span> ${JSON.stringify(detail).slice(0, 300)}`;
      }

      function isRpc(value) {
        return Boolean(value) && typeof value === 'object' && typeof value.success === 'boolean';
      }

      async function check(name, run, assert) {
        try {
          const rpc = await run();
          if (!isRpc(rpc)) {
            log(name, false, { reason: '返回不是 {success,data,message} 结构', rpc });
            return null;
          }
          const problem = assert ? assert(rpc) : rpc.success === false ? rpc.message : null;
          log(name, !problem, problem || (rpc.success ? rpc.data : { message: rpc.message }));
          return rpc;
        } catch (error) {
          log(name, false, { reason: 'invoke 直接 reject（说明主进程抛到了 Electron 层）', error: String(error) });
          return null;
        }
      }

      /** 断言「应当失败」：失败信息要回来，且不能被 Electron 包成 handler 错误 */
      function expectFailure(pattern) {
        return (rpc) => {
          if (rpc.success) return '本该失败却成功了';
          if (!pattern.test(rpc.message)) return `错误信息不匹配 ${pattern}: ${rpc.message}`;
          return null;
        };
      }

      function expectData(verify) {
        return (rpc) => {
          if (!rpc.success) return rpc.message;
          return verify(rpc.data) ? null : `数据不符合预期: ${JSON.stringify(rpc.data).slice(0, 200)}`;
        };
      }

      async function main() {
        pre.textContent = '';
        const tmpSkill = fs.mkdtempSync(path.join(os.tmpdir(), 'zsjz-probe-skill-'));
        fs.writeFileSync(
          path.join(tmpSkill, 'SKILL.md'),
          '---\nname: ipc-probe-skill\ndescription: 探针安装的技能\n---\n\n# probe\n',
          'utf8',
        );

        await check('ping', () => call('ping'), expectData((d) => d.available === true && /codex-cli/.test(d.version || '')));
        await check('status', () => call('status'), expectData((d) => typeof d.running === 'boolean' && Boolean(d.codexHome)));
        await check('start', () => call('start'), expectData((d) => d.running === true));
        await check('listModels', () => call('listModels'), (rpc) => (rpc.success && Array.isArray(rpc.data) ? null : rpc.message));

        await check(
          'mcpSave 含中文/空格参数',
          () => call('mcpSave', { id: 'probe-stdio', transport: 'stdio', command: 'node', args: ['-e', '过程 输出'], enabled: true }),
          expectData((list) => list.some((item) => item.id === 'probe-stdio' && item.args[1] === '过程 输出')),
        );
        await check('mcpList', () => call('mcpList'), expectData((list) => list.some((item) => item.id === 'probe-stdio')));
        await check('mcpSave 非法 id', () => call('mcpSave', { id: '有 空格', transport: 'stdio', command: 'x', enabled: true }), expectFailure(/MCP ID/));
        await check('mcpSave 明文 http 远程', () => call('mcpSave', { id: 'a', transport: 'http', url: 'http://10.0.0.8/mcp', enabled: true }), expectFailure(/HTTPS/));
        await check('mcpRemove 缺 id', () => call('mcpRemove', {}), expectFailure(/不能为空/));
        await check('mcpRemove', () => call('mcpRemove', { id: 'probe-stdio' }), expectData((list) => !list.some((item) => item.id === 'probe-stdio')));

        await check('skillInstallFolder', () => call('skillInstallFolder', { srcPath: tmpSkill, overwrite: true }), expectData((list) => list.some((s) => s.name === 'ipc-probe-skill' && s.managed)));
        await check('skillSetEnabled false', () => call('skillSetEnabled', { name: 'ipc-probe-skill', enabled: false }), expectData((d) => d.effectiveEnabled === false));
        await check('skillRead', () => call('skillRead', { name: 'ipc-probe-skill' }), expectData((d) => d.content.includes('ipc-probe-skill')));
        await check('skillInstallZip 非 zip 字节', () => call('skillInstallZip', { data: new Uint8Array([1, 2, 3, 4]) }), expectFailure(/无法解析 zip/));
        await check('skillRemove 内置', () => call('skillList', { forceReload: true }).then((rpc) => (rpc.success && rpc.data.find((s) => !s.managed) ? call('skillRemove', { path: rpc.data.find((s) => !s.managed).path }) : rpc)), expectFailure(/内置或暂存目录/));
        await check('skillRemove', () => call('skillRemove', { name: 'ipc-probe-skill' }), expectData((list) => !list.some((s) => s.name === 'ipc-probe-skill')));
        await check('删除后 config.toml 无残留条目', async () => {
          const st = await call('status');
          const file = st.success ? path.join(st.data.codexHome, 'config.toml') : null;
          if (!file || !fs.existsSync(file)) return { success: true, data: { note: '无 config.toml' } };
          const text = fs.readFileSync(file, 'utf8');
          return text.includes('ipc-probe-skill')
            ? { success: false, message: 'config.toml 仍留有该 skill 的条目（重装会继承禁用）' }
            : { success: true, data: { cleaned: true } };
        });

        await check('probeProvider 不可达端点', () => call('probeProvider', { baseUrl: 'http://127.0.0.1:9/v1' }), expectData((d) => d.protocol === 'unreachable' && d.responsesStatus === null && String(d.detail || '').includes('http://127.0.0.1:9/v1/responses')));

        // 用本地假端点跑一次真实 apply / clear（不触碰任何真实模型密钥）
        const http = require('node:http');
        const fake = http.createServer((req, res) => {
          req.resume();
          res.writeHead(req.url && req.url.endsWith('/responses') ? 401 : 200, { 'content-type': 'application/json' });
          res.end('{}');
        });
        await new Promise((resolve) => fake.listen(0, '127.0.0.1', resolve));
        const fakeUrl = `http://127.0.0.1:${fake.address().port}/v1`;

        await check(
          'applyProvider 真实往返',
          () => call('applyProvider', { modelId: 'probe-live', baseUrl: fakeUrl, apiKey: 'sk-probe-local', providerType: 'OPENAI', modelRecordId: 'probe-1' }),
          expectData((d) => d.applied.model === 'probe-live' && d.applied.providerId === 'zsjz' && d.status.running === true && d.status.defaultModel === 'probe-live'),
        );
        await check('密钥不落盘（config.toml / provider.json）', async () => {
          const st = await call('status');
          if (!st.success) return st;
          const codexHome = st.data.codexHome;
          const dataDir = path.dirname(codexHome);
          const targets = [
            path.join(codexHome, 'config.toml'),
            path.join(dataDir, 'codex-data', 'provider.json'),
          ];
          for (const file of targets) {
            if (!fs.existsSync(file)) continue;
            if (fs.readFileSync(file, 'utf8').includes('sk-probe-local')) {
              return { success: false, message: `${file} 里出现了密钥` };
            }
          }
          return { success: true, data: { checked: targets.filter((f) => fs.existsSync(f)) } };
        });
        await check(
          'applyProvider 端点不可达时报错（回归）',
          () => call('applyProvider', { modelId: 'qwen', baseUrl: 'http://127.0.0.1:9/v1' }),
          expectFailure(/不可达|没有 \/chat\/completions/),
        );
        await check('clearProvider', () => call('clearProvider'), expectData((d) => d.providerId === null && d.applied === null));
        fake.close();

        await check('applyProvider 缺 modelId', () => call('applyProvider', { modelId: ' ' }), expectFailure(/modelId/));
        await check('turnInterrupt 缺参', () => call('turnInterrupt', {}), expectFailure(/不能为空/));
        await check('approvalResolve 非法 decision', () => call('approvalResolve', { token: 'x', decision: 'whatever' }), expectFailure(/decision/));
        await check('eventsRead 非法 threadId', () => call('eventsRead', { threadId: '../etc' }), expectFailure(/不能为空|threadId|非法/));
        await check('logsTail', () => call('logsTail', { limit: 5 }), expectData((d) => Array.isArray(d)));
        // 「打开记录关联文件」用的 IPC：只验参数校验分支（成功分支会真的弹起本机应用）
        await check('osCtl.openPath 空路径被拒', () => osCall('openPath', {}), expectFailure(/不能为空/));
        await check('osCtl.openPath 相对路径被拒', () => osCall('openPath', { path: 'relative/a.xlsx' }), expectFailure(/绝对路径/));
        await check(
          'osCtl.openPath 不存在的文件被拒',
          () => osCall('openPath', { path: 'E:/no-such-dir/no-such-file.xlsx' }),
          expectFailure(/文件不存在/),
        );
        await check('stop', () => call('stop'), expectData((d) => d.state === 'stopped'));

        // 本机地图目录：存在客户端 local-settings.json，不经服务端（设置抽屉的「地图」用它）
        const MAP_DIR_SAMPLE = 'E:/workspace/zsjz-ai/ai-electron/scripts';
        const MAP_STYLE_SAMPLE = 'E:/workspace/zsjz-ai/ai-electron/frontend/public/resource/map/behavior-spacetime-style.json';
        // 先记下运行前的配置，末尾恢复，保证探针不改动使用者机器上的设置
        const mapOriginal = ((await osCall('getMapLocalPath')) || {}).data?.path || '';
        await check('osCtl.getMapLocalPath', () => osCall('getMapLocalPath'), expectData((d) => typeof d.path === 'string'));
        await check(
          'osCtl.setMapLocalPath 相对路径被拒',
          () => osCall('setMapLocalPath', { path: 'relative/maps' }),
          expectFailure(/绝对路径/),
        );
        await check(
          'osCtl.setMapLocalPath 不存在的目录被拒',
          () => osCall('setMapLocalPath', { path: 'E:/no-such-dir/maps' }),
          expectFailure(/目录不存在/),
        );
        await check(
          'osCtl.setMapLocalPath 文件被拒',
          () => osCall('setMapLocalPath', { path: MAP_STYLE_SAMPLE }),
          expectFailure(/请选择目录/),
        );
        await check(
          'osCtl.setMapLocalPath 保存真实目录',
          () => osCall('setMapLocalPath', { path: MAP_DIR_SAMPLE }),
          expectData((d) => d.path === MAP_DIR_SAMPLE),
        );
        await check(
          'osCtl.getMapLocalPath 回读一致',
          () => osCall('getMapLocalPath'),
          expectData((d) => d.path === MAP_DIR_SAMPLE),
        );
        await check(
          'osCtl.setMapLocalPath 清空（空值）',
          async () => {
            await osCall('setMapLocalPath', { path: '' });
            const after = ((await osCall('getMapLocalPath')) || {}).data || {};
            return { success: true, data: { path: after.path } };
          },
          expectData((d) => d.path === ''),
        );
        await check(
          'osCtl.setMapLocalPath 恢复运行前配置',
          async () => {
            if (mapOriginal) await osCall('setMapLocalPath', { path: mapOriginal });
            const after = ((await osCall('getMapLocalPath')) || {}).data || {};
            return { success: true, data: { path: after.path, expected: mapOriginal } };
          },
          expectData((d) => d.path === d.expected),
        );

        // 离线地图的本机读取（恢复改造前方式）：瓦片按偏移分块读、样式读文本
        const MAP_FILE_SAMPLE = 'E:/workspace/zsjz-ai/ai-electron/frontend/public/resource/map/behavior-spacetime-style.json';
        await check(
          'osCtl.readBinaryFileRange 读前 16 字节',
          () => osCall('readBinaryFileRange', { filePath: MAP_FILE_SAMPLE, offset: 0, length: 16 }),
          expectData((d) => d.size === 16 && Buffer.from(d.data, 'base64').toString('utf8').trimStart().startsWith('{')),
        );
        await check(
          'osCtl.readBinaryFileRange 中段偏移',
          () => osCall('readBinaryFileRange', { filePath: MAP_FILE_SAMPLE, offset: 100, length: 32 }),
          expectData((d) => d.size === 32 && d.fileSize > 100),
        );
        await check(
          'osCtl.readBinaryFileRange 超长自动收敛到文件末尾',
          () => osCall('readBinaryFileRange', { filePath: MAP_FILE_SAMPLE, offset: 0, length: 99999999 }),
          expectData((d) => d.size === d.fileSize),
        );
        await check(
          'osCtl.readBinaryFileRange 偏移越界返回空',
          () => osCall('readBinaryFileRange', { filePath: MAP_FILE_SAMPLE, offset: 99999999, length: 16 }),
          expectData((d) => d.size === 0 && d.data === ''),
        );
        await check(
          'osCtl.readBinaryFileRange 相对路径被拒',
          () => osCall('readBinaryFileRange', { filePath: 'relative/a.pmtiles', length: 16 }),
          expectFailure(/绝对路径/),
        );
        await check(
          'osCtl.readBinaryFileRange 缺 length 被拒',
          () => osCall('readBinaryFileRange', { filePath: MAP_FILE_SAMPLE }),
          expectFailure(/长度不合法/),
        );
        await check(
          'osCtl.readBinaryFileRange 不存在的文件被拒',
          () => osCall('readBinaryFileRange', { filePath: 'E:/no-such-dir/a.pmtiles', length: 16 }),
          expectFailure(/文件不存在/),
        );
        await check(
          'osCtl.readTextFile 能读到样式文本',
          () => osCall('readTextFile', { filePath: MAP_FILE_SAMPLE, encoding: 'utf8' }),
          expectData((d) => String(d.text || '').includes('version')),
        );
        await check(
          'osCtl.readTextFile 目录被拒',
          () => osCall('readTextFile', { filePath: 'E:/workspace/zsjz-ai' }),
          expectFailure(/不是文件/),
        );

        fs.writeFileSync(outFile, JSON.stringify({ at: new Date().toISOString(), results }, null, 2), 'utf8');
        const failed = results.filter((item) => !item.ok);
        pre.innerHTML += `\n\n${failed.length === 0 ? 'ALL PASS' : 'FAILED ' + failed.length} → ${outFile}`;
        // 让最后的写入落盘再退出
        setTimeout(() => process.exit(failed.length === 0 ? 0 : 1), 300);
      }

      main().catch((error) => {
        fs.writeFileSync(outFile, JSON.stringify({ error: String(error), results }, null, 2), 'utf8');
        setTimeout(() => process.exit(1), 100);
      });
    </script>
  </body>
</html>