@harness-mix/cli 0.1.4 → 0.1.6

package/scripts/integrations-test.cjs

@@ -0,0 +1,123 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { Integrations } = require('../src/main/host/integrations');
+const { buildAdapters } = require('../src/main/adapters');
+const { NativeProtocol } = require('../src/main/native/protocol');
+const { acpServers, namedServers } = require('../src/main/adapters/managed-mcp');
+
+async function main() {
+  const root = path.resolve('output/integrations-test', `${Date.now()}`);
+  const project = path.join(root, 'project'), home = path.join(root, 'home');
+  await fs.mkdir(project, { recursive: true }); await fs.mkdir(home);
+  const adapters = new Map(buildAdapters(() => {}).map(a => [a.manifest.id, a]));
+  const runtime = { adapters, status: {}, sessions: new Map(), store: { directory: path.join(root, 'data') }, resolveHarnessId: id => id };
+  const manager = runtime.integrations = new Integrations(runtime, { home, environment: {} });
+  const global = { harnessId: 'claude', scope: 'global' }, local = { harnessId: 'claude', scope: 'project', cwd: project };
+  const server = { name: 'probe', command: process.execPath, args: ['probe.cjs'], enabled: true };
+  await Promise.all([manager.save({ ...global, server }), manager.save({ ...local, server: { ...server, enabled: false } })]);
+  assert.equal((await manager.forSession({ cwd: project }, adapters.get('claude'))).servers.length, 0, 'project disabled entry masks global');
+  let snapshot = await manager.list(local);
+  assert.equal(snapshot.servers.length, 2); assert.equal(snapshot.servers.filter(s => s.effective).length, 1);
+  await manager.remove({ ...local, id: snapshot.servers.find(s => s.scope === 'project').id });
+  const selected = await manager.forSession({ cwd: project }, adapters.get('claude'));
+  assert.equal(selected.servers[0].name, 'hm-user-probe');
+  runtime.sessions.set('s', { adapter: adapters.get('claude'), nativeSessionId: 'native-test', integrationCwd: await fs.realpath(project), integrationServers: selected.records,
+    query: { mcpServerStatus: async () => [{ name: 'hm-user-probe', status: 'connected', config: { token: 'DO_NOT_PROJECT' }, tools: [{ name: 'echo' }] }] } });
+  snapshot = await manager.list(local);
+  assert.equal(snapshot.servers[0].appliedSessions, 1); assert.equal(snapshot.native[0].status, 'connected'); assert.ok(!JSON.stringify(snapshot).includes('DO_NOT_PROJECT'));
+  await manager.save({ ...global, server: { ...server, args: ['changed.cjs'] } });
+  assert.equal((await manager.list(global)).servers[0].appliedSessions, 0, 'changed config not claimed as applied');
+  const reload = new Integrations(runtime, { home }); assert.equal((await reload.list(global)).servers.length, 1);
+  const stdioExtended = { name: 'stdio-ext', command: process.execPath, args: ['probe.cjs'], env: { NODE_ENV: 'test' }, env_vars: ['PATH'], cwd: project, enabled: true };
+  await manager.save({ ...local, server: stdioExtended });
+  const stdioLoaded = (await manager.list(local)).servers.find(s => s.name === 'stdio-ext');
+  assert.equal(stdioLoaded.transportType, 'stdio');
+  assert.deepEqual(stdioLoaded.env, { NODE_ENV: 'test' });
+  assert.deepEqual(stdioLoaded.env_vars, ['PATH']);
+  assert.equal(stdioLoaded.cwd, project);
+
+  const http = { name: 'http-probe', transportType: 'streamable_http', url: 'https://mcp.example.com/mcp', bearer_token_env_var: 'MCP_TOKEN', http_headers: { 'X-Custom': 'val' }, env_http_headers: { 'X-Auth': 'TOKEN_VAR' }, enabled: true };
+  await manager.save({ ...global, server: http });
+  const httpLoaded = (await manager.list(global)).servers.find(s => s.name === 'http-probe');
+  assert.equal(httpLoaded.transportType, 'streamable_http');
+  assert.equal(httpLoaded.url, 'https://mcp.example.com/mcp');
+  assert.equal(httpLoaded.bearer_token_env_var, 'MCP_TOKEN');
+  assert.deepEqual(httpLoaded.http_headers, { 'X-Custom': 'val' });
+  assert.deepEqual(httpLoaded.env_http_headers, { 'X-Auth': 'TOKEN_VAR' });
+
+  await assert.rejects(manager.save({ ...global, server: { ...server, invalidProp: 'never' } }));
+  await assert.rejects(manager.save({ ...global, server: { ...server, args: ['--token', 'never'] } }));
+  await assert.rejects(manager.save({ ...global, server: { name: 'bad-url', url: 'invalid-url', enabled: true } }));
+  await assert.rejects(manager.save({ ...global, server: { name: 'bad-bearer', url: 'https://example.com', bearer_token_env_var: '123-bad', enabled: true } }));
+  await assert.rejects(manager.save({ ...global, harnessId: 'pi', server }), /no supported/);
+  await assert.rejects(manager.remove({ ...local, id: snapshot.servers[0].id }), /scope/);
+  await assert.rejects(manager.list({ ...local, cwd: 'relative' }));
+  const source = path.join(root, 'source'); await fs.mkdir(path.join(source, 'scripts'), { recursive: true });
+  await fs.writeFile(path.join(source, 'SKILL.md'), '---\nname: sample\ndescription: Sample skill\n---\n# Sample\n');
+  await fs.writeFile(path.join(source, 'scripts', 'sample.txt'), 'unchanged');
+  await manager.skillChange({ ...local, name: 'sample', source, action: 'install' });
+  const nativeFile = path.join(project, '.claude/skills/sample/SKILL.md'); assert.match(await fs.readFile(nativeFile, 'utf8'), /Sample/);
+  await assert.rejects(manager.skillChange({ ...local, name: 'sample', source, action: 'install' }), /already exists/);
+  await manager.skillChange({ ...local, name: 'sample', action: 'disable' });
+  await assert.rejects(fs.access(nativeFile)); assert.equal((await manager.list(local)).skills[0].enabled, false);
+  await manager.skillChange({ ...local, name: 'sample', action: 'enable' });
+  assert.equal(await fs.readFile(path.join(project, '.claude/skills/sample/scripts/sample.txt'), 'utf8'), 'unchanged');
+  const droppedMarkdown = Buffer.from('---\nname: dropped\ndescription: Dropped skill\n---\n# Dropped\n').toString('base64');
+  await manager.skillChange({ ...local, name: 'dropped', files: [{ path: 'SKILL.md', contentBase64: droppedMarkdown }], action: 'install' });
+  assert.match(await fs.readFile(path.join(project, '.claude/skills/dropped/SKILL.md'), 'utf8'), /Dropped skill/);
+  await assert.rejects(manager.skillChange({ ...local, name: 'escape', files: [{ path: '../SKILL.md', contentBase64: droppedMarkdown }], action: 'install' }), /invalid path/);
+  await assert.rejects(manager.skillChange({ ...local, name: 'bad-data', files: [{ path: 'SKILL.md', contentBase64: '***' }], action: 'install' }), /invalid file data/);
+  await assert.rejects(manager.skillChange({ ...local, name: '../escape', source, action: 'install' }));
+  await assert.rejects(manager.skillChange({ ...local, name: 'sample', root, action: 'disable' }));
+  const link = path.join(project, '.claude/skills/linked');
+  await fs.symlink(source, link, process.platform === 'win32' ? 'junction' : 'dir');
+  assert.equal((await manager.list(local)).skills.find(s => s.name === 'linked').writable, false);
+  await assert.rejects(manager.skillChange({ ...local, name: 'linked', action: 'disable' }), /read-only/);
+  const collab = { command: 'native-node', args: ['bridge'], env: { LOCAL_BRIDGE: 'capability' } };
+  const acp = acpServers(selected.servers, collab);
+  assert.equal(acp.length, 2); assert.equal(acp[1].name, 'harness-mix'); assert.deepEqual(acp[0].env, []);
+  assert.ok(namedServers(selected.servers, collab)['hm-user-probe']);
+  const catalog = await manager.catalog(); assert.equal(catalog.harnesses.length, 16);
+  for (const a of adapters.values()) {
+    const entry = catalog.harnesses.find(h => h.id === a.manifest.id);
+    assert.equal(entry.mcp, a.manifest.integrations?.mcp === true);
+    assert.equal(entry.skills, true, `${a.manifest.id} must declare verified native skill roots`);
+    const roots = await manager.ensureSkillRoots({ cwd: project }, a);
+    assert.ok(roots.length > 0, `${a.manifest.id} must resolve at least one native skill root`);
+    for (const skillRoot of roots) assert.equal((await fs.stat(skillRoot)).isDirectory(), true);
+  }
+  assert.deepEqual(manager.roots(adapters.get('antigravity'), { scope: 'global', cwd: null }), [path.join(home, '.gemini/config/skills')]);
+  assert.deepEqual(manager.roots(adapters.get('dsh'), { scope: 'project', cwd: project }), [path.join(project, '.dsh/skills'), path.join(project, '.agents/skills')]);
+  assert.deepEqual(manager.roots(adapters.get('zcode'), { scope: 'global', cwd: null }), [path.join(home, '.zcode/skills'), path.join(home, '.agents/skills')]);
+  assert.deepEqual(manager.roots(adapters.get('zcode'), { scope: 'project', cwd: project }), [path.join(project, '.zcode/skills'), path.join(project, '.agents/skills')]);
+  // Trae IDE (.trae) and TraeCode CLI (.traecli) share one managed root set.
+  assert.deepEqual(manager.roots(adapters.get('trae'), { scope: 'project', cwd: project }), [path.join(project, '.trae/skills'), path.join(project, '.traecli/skills'), path.join(project, '.agents/skills')]);
+  // Hermes documents no project-scope skills directory, so only its global root is managed.
+  assert.deepEqual(manager.roots(adapters.get('hermes'), { scope: 'project', cwd: project }), []);
+  assert.deepEqual(manager.roots(adapters.get('hermes'), { scope: 'global', cwd: null }), [path.join(home, '.hermes/skills')]);
+  // Environment overrides relocate global roots; the deprecated-but-loaded $CODEX_HOME/skills stays discoverable.
+  const codexHome = path.join(root, 'codex-home'), hermesHome = path.join(root, 'hermes-home');
+  const overridden = new Integrations(runtime, { home, environment: { CODEX_HOME: codexHome, HERMES_HOME: hermesHome } });
+  assert.deepEqual(overridden.roots(adapters.get('codex'), { scope: 'global', cwd: null }), [path.join(home, '.agents/skills'), path.join(codexHome, 'skills')]);
+  assert.deepEqual(overridden.roots(adapters.get('hermes'), { scope: 'global', cwd: null }), [path.join(hermesHome, 'skills')]);
+  // A root that cannot be created is reported and skipped, never fatal to opening a session.
+  const blockedHome = path.join(root, 'blocked-home');
+  await fs.mkdir(path.join(blockedHome, '.codex'), { recursive: true });
+  await fs.writeFile(path.join(blockedHome, '.codex', 'skills'), 'not a directory');
+  const blocked = new Integrations(runtime, { home: blockedHome, environment: {} });
+  const reported = [];
+  const ensured = await blocked.ensureSkillRoots({ cwd: project }, adapters.get('codex'), { onError: message => reported.push(message) });
+  assert.ok(!ensured.some(value => value.endsWith(path.join('.codex', 'skills'))), 'uncreatable root is skipped');
+  assert.equal(ensured.length, 2, 'the remaining global and project roots are still created');
+  assert.equal(reported.length, 1, 'the skipped root is reported');
+  assert.equal((await fs.stat(ensured[0])).isDirectory(), true);
+  // An unusable project scope degrades to global roots instead of failing the launch.
+  const globalOnly = await blocked.ensureSkillRoots({ cwd: 'relative-not-absolute' }, adapters.get('codex'), {});
+  assert.equal(globalOnly.length, 1);
+  // Exercise the real protocol dispatcher without starting native processes.
+  assert.equal((await NativeProtocol.prototype.request.call({ runtime }, 'codexhost/integrations/catalog', {})).harnesses.length, 16);
+  assert.equal((await NativeProtocol.prototype.request.call({ runtime }, 'codexhost/integrations/list', local)).skills.length, 3);
+  console.log('integrations: scope precedence, persistence, native status projection, no credential fields, unsupported capabilities, skill install/disable/restore, links, and protocol PASS');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/integrations-ui-smoke.cjs

@@ -0,0 +1,124 @@
+const { app, BrowserWindow, ipcMain } = require('electron');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const esbuild = require('esbuild');
+const { Integrations } = require('../src/main/host/integrations');
+const { buildAdapters } = require('../src/main/adapters');
+const { NativeProtocol } = require('../src/main/native/protocol');
+app.disableHardwareAcceleration();
+
+app.whenReady().then(async () => {
+  const out = path.resolve('output/integrations-ui', `${Date.now()}`), project = path.join(out, 'project');
+  await fs.mkdir(project, { recursive: true });
+  const adapters = new Map(buildAdapters(() => {}).map(a => [a.manifest.id, a]));
+  const runtime = { adapters, sessions: new Map(), status: { claude: { available: true } }, store: { directory: path.join(out, 'data') }, resolveHarnessId: id => id };
+  runtime.integrations = new Integrations(runtime, { home: path.join(out, 'home') });
+  const preload = path.join(out, 'preload.cjs');
+  await fs.writeFile(preload, `const {contextBridge,ipcRenderer}=require('electron');contextBridge.exposeInMainWorld('integrationTest',{request:(method,params)=>ipcRenderer.invoke('integrations-test',method,params)});`);
+  ipcMain.handle('integrations-test', (_event, method, params) => {
+    assert.ok(method.startsWith('codexhost/integrations/'));
+    return NativeProtocol.prototype.request.call({ runtime }, method, params);
+  });
+  const build = await esbuild.build({ stdin: { contents: `export {createMcpSettingsPage,createSkillsSettingsPage} from './src/native-ui/renderer-extension/src/settings/integrations-page.ts'; export {mountRendererSettingsShell} from './src/native-ui/renderer-extension/src/settings/shell.ts'; export {createRendererSettingsPageRegistry} from './src/native-ui/renderer-extension/src/settings/core.ts'; export {rendererSettingsMessages} from './src/native-ui/renderer-extension/src/settings/localization.ts'; export {createRendererIntegrationsClient} from './src/native-ui/renderer-extension/src/renderer-integrations-client.ts';`, resolveDir: process.cwd() }, bundle: true, platform: 'browser', format: 'iife', globalName: 'IntegrationUI', write: false, alias: { '@codexhost/shared-contracts': path.resolve('src/native-ui/shared-contracts/src/index.ts') }, loader: { '.svg': 'dataurl', '.png': 'dataurl', '.css': 'text' } });
+  const consoleProblems = [];
+  const win = new BrowserWindow({ show: false, width: 1100, height: 900, webPreferences: { preload, contextIsolation: true, sandbox: true, offscreen: true } });
+  win.webContents.on('console-message', (_event, details) => { if (details.level === 'error' || details.level === 'warning') consoleProblems.push(details.message); });
+  try {
+    await win.loadURL('data:text/html,<html><head><title>Harness Mix Integrations QA</title><meta http-equiv="Content-Security-Policy" content="default-src %27none%27; script-src %27none%27; style-src %27unsafe-inline%27; img-src data:"></head><body style="background:%23191919;color:white;font-family:Arial"></body></html>');
+    await win.webContents.executeJavaScript(build.outputFiles[0].text);
+    const result = await win.webContents.executeJavaScript(`(async()=>{
+      const messages=IntegrationUI.rendererSettingsMessages('zh-CN');
+      const client=IntegrationUI.createRendererIntegrationsClient((m,p)=>window.integrationTest.request(m,p));
+      const registry=IntegrationUI.createRendererSettingsPageRegistry([IntegrationUI.createMcpSettingsPage(messages,()=>client),IntegrationUI.createSkillsSettingsPage(messages,()=>client)]);
+      const shell=IntegrationUI.mountRendererSettingsShell(registry,document,messages); shell.openSettings(undefined,'mcp');
+      const root=shell.root.shadowRoot;
+      const wait=async predicate=>{for(let i=0;i<100;i++){if(predicate())return;await new Promise(r=>setTimeout(r,30));}throw Error('UI timed out');};
+      await wait(()=>root.querySelector('select')?.options.length===17 && !root.querySelector('select').disabled);
+      const [harness,scope]=root.querySelectorAll('select');harness.value='claude';harness.dispatchEvent(new Event('change'));
+      await wait(()=>root.querySelector('.settings-integrations-toolbar')&&!harness.disabled);
+      scope.value='project';scope.dispatchEvent(new Event('change'));
+      const cwd=root.querySelector('.settings-integrations-controls input');cwd.value=${JSON.stringify(project)};cwd.dispatchEvent(new Event('change'));
+      await wait(()=>root.querySelector('.settings-integrations-toolbar')&&!harness.disabled);
+      Array.from(root.querySelectorAll('button')).find(b=>b.textContent.includes('添加 MCP')).click();
+      const form=root.querySelector('form'); const fields=form.querySelectorAll('input');fields[0].value='ui-probe';fields[1].value='node';fields[2].value='probe.cjs';form.requestSubmit();
+      await wait(()=>root.textContent.includes('ui-probe')&&!harness.disabled&&!!root.querySelector('.settings-integrations-row'));
+      const mcpRow=()=>Array.from(root.querySelectorAll('.settings-integrations-row')).find(r=>r.querySelector('strong')?.textContent==='ui-probe');
+      mcpRow().querySelectorAll('button')[1].click();await wait(()=>mcpRow()?.textContent.includes('已停用')&&!harness.disabled);
+      mcpRow().querySelectorAll('button')[1].click();await wait(()=>mcpRow()?.textContent.includes('已配置')&&!harness.disabled);
+      harness.value = '__all__'; harness.dispatchEvent(new Event('change'));
+      await wait(()=>root.querySelector('.settings-mcp-overview-grid')&&!harness.disabled);
+      const mcpOverviewCard=Array.from(root.querySelectorAll('.settings-mcp-harness-card')).find(c=>c.querySelector('strong')?.textContent?.includes('Claude'));
+      if (!mcpOverviewCard || !mcpOverviewCard.textContent.includes('ui-probe')) throw Error('MCP overview missing ui-probe on Claude');
+      shell.openSettings(undefined,'skills');
+      await wait(()=>root.querySelector('.settings-skill-dropzone')&&!root.querySelector('select').disabled);
+      const [skillHarness,skillScope]=root.querySelectorAll('select');skillHarness.value='claude';skillHarness.dispatchEvent(new Event('change'));
+      await wait(()=>!skillHarness.disabled);skillScope.value='project';skillScope.dispatchEvent(new Event('change'));
+      const skillCwd=root.querySelector('.settings-integrations-controls input');skillCwd.value=${JSON.stringify(project)};skillCwd.dispatchEvent(new Event('change'));
+      await wait(()=>root.querySelector('.settings-skill-dropzone')&&!skillHarness.disabled);
+      const transfer=new DataTransfer();transfer.items.add(new File(['---\\nname: ui-skill\\ndescription: UI fixture\\n---\\n# Test\\n'],'ui-skill.md',{type:'text/markdown'}));
+      root.querySelector('.settings-skill-dropzone').dispatchEvent(new DragEvent('drop',{dataTransfer:transfer,bubbles:true,cancelable:true}));
+      const skillRow=()=>Array.from(root.querySelectorAll('.settings-integrations-row')).find(r=>r.querySelector('strong')?.textContent==='ui-skill');
+      await wait(()=>skillRow()&&!skillHarness.disabled);skillRow().querySelector('button').click();await wait(()=>skillRow()?.textContent.includes('已停用')&&!skillHarness.disabled);
+      skillRow().querySelector('button').click();await wait(()=>skillRow()?.textContent.includes('已安装')&&!skillHarness.disabled);
+      skillHarness.value = '__all__'; skillHarness.dispatchEvent(new Event('change'));
+      await wait(()=>root.querySelector('.settings-skills-overview-grid')&&!skillHarness.disabled);
+      return {mcpSaved:true,mcpToggled:true,mcpOverviewRendered:true,skillDropped:true,skillRestored:true,overviewRendered:true,separatePages:registry.pages.map(p=>p.id),scope:skillScope.value,text:root.textContent.slice(-2000)};
+    })()`);
+    assert.equal(await win.webContents.executeJavaScript('document.title'), 'Harness Mix Integrations QA');
+    assert.ok(result.mcpSaved && result.mcpOverviewRendered && result.skillDropped && result.skillRestored && result.overviewRendered); assert.deepEqual(result.separatePages, ['mcp', 'skills']); assert.deepEqual(consoleProblems, []);
+    const list = await runtime.integrations.list({ harnessId: 'claude', scope: 'project', cwd: project });
+    assert.equal(list.servers[0].enabled, true); assert.equal(list.skills[0].enabled, true);
+    const overviewImage = (await win.webContents.capturePage()).toPNG();
+    await fs.writeFile(path.join(out, 'overview.png'), overviewImage);
+    await fs.writeFile(path.join(out, 'settings.png'), overviewImage);
+    await fs.writeFile(path.join(out, 'skills.png'), overviewImage);
+    await win.webContents.executeJavaScript(`(async()=>{
+      const root=document.querySelector('[data-codexhost-settings-shell]').shadowRoot;
+      root.querySelector('button[data-page-id="mcp"]').click();
+      const wait=async predicate=>{for(let i=0;i<100;i++){if(predicate())return;await new Promise(r=>setTimeout(r,30));}throw Error('MCP screenshot timed out');};
+      await wait(()=>root.querySelector('select')?.options.length===17&&!root.querySelector('select').disabled);
+      const [harness,scope]=root.querySelectorAll('select');
+      scope.value='project';scope.dispatchEvent(new Event('change'));
+      const cwd=root.querySelector('.settings-integrations-controls input');cwd.value=${JSON.stringify(project)};cwd.dispatchEvent(new Event('change'));
+      harness.value='__all__';harness.dispatchEvent(new Event('change'));
+      await wait(()=>root.querySelector('.settings-mcp-overview-grid')&&root.textContent.includes('ui-probe')&&!harness.disabled);
+      const byServerBtn=Array.from(root.querySelectorAll('.settings-mcp-tabs button')).find(b=>b.textContent.includes('Server'));
+      byServerBtn?.click();
+      await wait(()=>root.querySelector('.settings-mcp-matrix-list')&&!harness.disabled);
+      const mcpMatrixCard=Array.from(root.querySelectorAll('.settings-mcp-matrix-card')).find(c=>c.querySelector('strong')?.textContent==='ui-probe');
+      if (!mcpMatrixCard) throw Error('MCP server matrix missing ui-probe card');
+    })()`);
+    await new Promise(r => setTimeout(r, 60));
+    await fs.writeFile(path.join(out, 'mcp-matrix.png'), (await win.webContents.capturePage()).toPNG());
+    await win.webContents.executeJavaScript(`(async()=>{
+      const root=document.querySelector('[data-codexhost-settings-shell]').shadowRoot;
+      const byHarnessBtn=Array.from(root.querySelectorAll('.settings-mcp-tabs button')).find(b=>b.textContent.includes('Harness'));
+      byHarnessBtn?.click();
+      const wait=async predicate=>{for(let i=0;i<100;i++){if(predicate())return;await new Promise(r=>setTimeout(r,30));}throw Error('MCP switch timed out');};
+      await wait(()=>root.querySelector('.settings-mcp-overview-grid')&&!root.querySelector('select').disabled);
+    })()`);
+    await new Promise(r => setTimeout(r, 60));
+    await fs.writeFile(path.join(out, 'mcp-overview.png'), (await win.webContents.capturePage()).toPNG());
+    await win.webContents.executeJavaScript(`(async()=>{
+      const root=document.querySelector('[data-codexhost-settings-shell]').shadowRoot;
+      const [harness,scope]=root.querySelectorAll('select');
+      harness.value='claude';harness.dispatchEvent(new Event('change'));
+      const wait=async predicate=>{for(let i=0;i<100;i++){if(predicate())return;await new Promise(r=>setTimeout(r,30));}throw Error('MCP reload timed out');};
+      await wait(()=>!harness.disabled);scope.value='project';scope.dispatchEvent(new Event('change'));
+      const cwd=root.querySelector('.settings-integrations-controls input');cwd.value=${JSON.stringify(project)};cwd.dispatchEvent(new Event('change'));
+      await wait(()=>root.textContent.includes('ui-probe')&&!harness.disabled);
+    })()`);
+    await fs.writeFile(path.join(out, 'mcp.png'), (await win.webContents.capturePage()).toPNG());
+    await win.webContents.executeJavaScript(`(async()=>{
+      const root=document.querySelector('[data-codexhost-settings-shell]').shadowRoot;
+      const mcpRow=Array.from(root.querySelectorAll('.settings-integrations-row')).find(r=>r.querySelector('strong')?.textContent?.includes('ui-probe'));
+      mcpRow.querySelector('button').click();
+      const wait=async predicate=>{for(let i=0;i<100;i++){if(predicate())return;await new Promise(r=>setTimeout(r,30));}throw Error('MCP editor timed out');};
+      await wait(()=>!root.querySelector('.settings-mcp-editor').hidden);
+    })()`);
+    await fs.writeFile(path.join(out, 'mcp-editor.png'), (await win.webContents.capturePage()).toPNG());
+    await fs.writeFile(path.join(out, 'report.json'), JSON.stringify(result, null, 2));
+    console.log(`Integrations rendered UI -> typed client -> NativeProtocol -> real files PASS: ${out}`);
+  } finally { win.destroy(); app.quit(); }
+}).catch(error => { console.error(error); app.exit(1); });

package/scripts/native-protocol-test.cjs

@@ -21,9 +21,23 @@ async function main() {
   runtime.adapters.set('pi', adapter); runtime.status.pi = { available: true };
   const events = [];
   const section = { id: 'test-pinned-section', name: 'Pinned', appearance: null };
-  const bridge = new NativeProtocol(runtime, event => events.push(event), async method => {
-    assert.equal(method, 'threadSection/list');
-    return { data: [section], nextCursor: null };
+  const officialRequests = [];
+  const bridge = new NativeProtocol(runtime, event => events.push(event), async (method, params) => {
+    officialRequests.push({ method, params });
+    if (method === 'threadSection/list') return { data: [section], nextCursor: null };
+    if (method === 'account/read') return { account: { type: 'chatgpt', email: 'native@example.com', planType: 'plus' }, requiresOpenaiAuth: true };
+    if (method === 'account/rateLimits/read') return {
+      rateLimits: {
+        primary: { usedPercent: 33, windowDurationMins: 300, resetsAt: 1_800_000_000 },
+        secondary: { usedPercent: 29, windowDurationMins: 10080, resetsAt: 1_800_604_800 },
+      },
+      rateLimitResetCredits: { availableCount: 0, credits: [] },
+    };
+    if (method === 'account/login/start') return { type: 'chatgptDeviceCode', loginId: 'native-login', verificationUrl: 'https://auth.example.com/device', userCode: 'ABCD-EFGH' };
+    if (method === 'account/login/cancel') return { status: 'canceled' };
+    if (method === 'account/logout') return {};
+    if (method === 'account/rateLimitResetCredit/consume') return { outcome: 'reset' };
+    throw new Error(`Unexpected official request: ${method}`);
   });
   try {
     const catalogModels = [{ id: 'shared', provider: 'a' }, { id: 'shared', provider: 'b' }, { id: 'unique', provider: 'a' }];
@@ -51,6 +65,48 @@ async function main() {
     const schemaPath = path.join(root, 'schemas.cjs');
     await esbuild.build({ entryPoints: ['src/native-ui/shared-contracts/src/index.ts'], outfile: schemaPath, bundle: true, platform: 'node', format: 'cjs', logLevel: 'silent' });
     const schemas = require(schemaPath);
+    const version = await bridge.request('harness-mix/runtime/version');
+    assert.equal(version.version, require('../package.json').version, 'About page reads the installed package version');
+    const accounts = await bridge.request('codexhost/account/list');
+    schemas.codexAccountListResultSchema.parse(accounts);
+    assert.equal(accounts.accounts[0].email, 'native@example.com', 'Official account/read is projected into Account management');
+    assert.equal(accounts.accounts[0].authenticated, true);
+    assert.equal(accounts.accounts[0].management, 'native');
+    const accountUsage = await bridge.request('codexhost/account/usage/inspect', { accountId: 'official-codex' });
+    schemas.codexAccountUsageResultSchema.parse(accountUsage);
+    assert.equal(accountUsage.usage.planFiveHourUsedPercent, 33);
+    assert.equal(accountUsage.usage.planSevenDayUsedPercent, 29);
+    assert.equal(accountUsage.accountCredits.periodType, 'five_hour');
+    assert.equal(accountUsage.accountCredits.productUsage[0].product, '7-day window');
+    const login = await bridge.request('codexhost/account/login/start', { accountId: 'official-codex' });
+    schemas.codexAccountLoginStartResultSchema.parse(login);
+    assert.equal(login.userCode, 'ABCD-EFGH');
+    assert.deepEqual(await bridge.request('codexhost/account/login/cancel', { accountId: 'official-codex', loginId: 'native-login' }), { cancelled: true });
+    const loggedOut = await bridge.request('codexhost/account/logout');
+    schemas.codexAccountMutationResultSchema.parse(loggedOut);
+    assert.equal(loggedOut.account.authenticated, false);
+    let openedCodexThread = null;
+    const codexAdapter = {
+      manifest: { id: 'codex', name: 'Codex', capabilities: { streaming: true, models: true, approvals: true, questions: true, resume: true } },
+      async describe() { return { models: [{ id: 'gpt-test', name: 'GPT Test', provider: 'openai' }], thinkingLevels: [], permissionModes: [] }; },
+      async open(input) { openedCodexThread = input.thread; return { nativeSessionId: 'isolated-native-session', model: input.thread.options.model }; },
+      async send() {}, async cancel() {}, async close() {},
+    };
+    runtime.adapters.set('codex', codexAdapter);
+    runtime.status.codex = { available: true };
+    bridge.codexAccounts.close();
+    bridge.codexAccounts = {
+      executionContext(accountId) {
+        assert.equal(accountId, 'account-work');
+        return { accountId, codexHome: path.join(root, 'isolated-codex-home') };
+      },
+      close() {},
+    };
+    const isolated = await bridge.request('thread/start', { cwd: root, model: 'gpt-test', __codexhostAccountId: 'account-work' });
+    assert.equal(decodeRoute(isolated.thread.model).harnessId, 'codex-harness', 'An isolated Codex Account becomes an owned Codex adapter Thread');
+    assert.equal(openedCodexThread.options.accountId, 'account-work');
+    assert.equal(openedCodexThread.options.codexHome, path.join(root, 'isolated-codex-home'));
+    assert.equal(openedCodexThread.options.model.id, 'gpt-test');
     const inspection = await bridge.inspect('pi');
     schemas.harnessInspectionSchema.parse(inspection);
     assert.equal(inspection.catalog.defaultThinkingOptionId, 'high', 'Declared default thinking level projects to the catalog');
@@ -142,7 +198,25 @@ async function main() {
     assert.ok(runtime.execution.isRunning(threadId) && runtime.threads.find(t => t.id === threadId).currentTurn.id === current, 'Stale steering never cancels the running Turn');
     emit({ kind: 'completed', finalAnswer: true });
     await wait(() => !runtime.execution.isRunning(threadId) && !runtime.threads.find(t => t.id === threadId).reviewPending && !runtime.sending.has(threadId));
-    assert.equal(await bridge.request('thread/start', { model: 'official-model' }), undefined, 'Official Codex requests pass through');
+    assert.equal(await bridge.request('thread/start', { model: 'official-model' }), undefined, 'Official Codex thread/start passes through');
+    for (const [method, params] of [
+      ['thread/read', { threadId: 'official-thread', includeTurns: true }],
+      ['thread/resume', { threadId: 'official-thread' }],
+      ['turn/start', { threadId: 'official-thread', input: [{ type: 'text', text: 'continue' }] }],
+      ['turn/interrupt', { threadId: 'official-thread', turnId: 'official-turn' }],
+      ['thread/fork', { threadId: 'official-thread', lastTurnId: 'official-turn' }],
+      ['thread/compact/start', { threadId: 'official-thread' }],
+    ]) {
+      assert.equal(await bridge.request(method, params), undefined, `Official Codex ${method} passes through`);
+    }
+    assert.deepEqual(await bridge.request('codexhost/thread/ownership/list', { threadIds: ['official-thread', threadId] }), {
+      threads: [
+        { threadId: 'official-thread', owner: 'codex' },
+        { threadId, owner: 'external', harnessId: 'pi' },
+      ],
+    }, 'Official and Harness-managed threads keep separate ownership');
+    const runtimeInspection = await bridge.request('harness-mix/runtime/inspect');
+    assert.deepEqual(runtimeInspection.codex, { mode: 'official-passthrough', managedRoute: 'codex-harness' });
     adapter.listCommands = async () => [{ id: 'compact', action: 'execute', label: 'Compact' }];
     let compactCalls = 0;
     adapter.executeCommand = async (_session, id, hooks) => {
@@ -252,7 +326,108 @@ async function main() {
     assert.equal(discardResult.discarded, true);
     assert.equal(discardResult.branch, 'codexhost/test-wt-branch');
     assert.equal(dummyTargetThread.workspace, undefined, 'Discard deletes thread.workspace');
-    console.log('PASS: native protocol, external steering, command execution and Usage projection');
+
+    // 消息排队（thread/queue/add, list, update, reorder, delete, start）能力验证
+    const qThread = await bridge.request('thread/start', { cwd: root, model: routeModel('pi') });
+    const qThreadId = qThread.thread.id;
+    assert.deepEqual(await bridge.request('thread/queue/list', { threadId: qThreadId }), { data: [], nextCursor: null });
+    const q1 = await bridge.request('thread/queue/add', {
+      threadId: qThreadId,
+      input: [{ type: 'text', text: '排队补充需求 1' }],
+      clientUserMessageId: 'client-msg-1',
+    });
+    assert.equal(typeof q1.queuedSubmission.id, 'string');
+    assert.equal(q1.queuedSubmission.clientUserMessageId, 'client-msg-1');
+    assert.equal(events.at(-1)?.method, 'thread/queue/changed');
+    assert.equal(events.at(-1)?.params?.threadId, qThreadId);
+
+    const q2 = await bridge.request('thread/queue/add', {
+      threadId: qThreadId,
+      input: [{ type: 'text', text: '排队补充需求 2' }],
+      clientUserMessageId: 'client-msg-2',
+    });
+    let qList = await bridge.request('thread/queue/list', { threadId: qThreadId });
+    assert.equal(qList.data.length, 2);
+    assert.equal(qList.data[0].id, q1.queuedSubmission.id);
+    assert.equal(qList.data[1].id, q2.queuedSubmission.id);
+
+    // 更新排队项
+    const updated = await bridge.request('thread/queue/update', {
+      threadId: qThreadId,
+      queuedSubmissionId: q1.queuedSubmission.id,
+      input: [{ type: 'text', text: '更新后的补充需求 1' }],
+    });
+    assert.equal(updated.queuedSubmission.input[0].text, '更新后的补充需求 1');
+
+    // 重排序
+    await bridge.request('thread/queue/reorder', {
+      threadId: qThreadId,
+      queuedSubmissionIds: [q2.queuedSubmission.id, q1.queuedSubmission.id],
+    });
+    qList = await bridge.request('thread/queue/list', { threadId: qThreadId });
+    assert.equal(qList.data[0].id, q2.queuedSubmission.id);
+    assert.equal(qList.data[1].id, q1.queuedSubmission.id);
+
+    // 删除排队项
+    const del = await bridge.request('thread/queue/delete', {
+      threadId: qThreadId,
+      queuedSubmissionId: q2.queuedSubmission.id,
+    });
+    assert.equal(del.deleted, true);
+    qList = await bridge.request('thread/queue/list', { threadId: qThreadId });
+    assert.equal(qList.data.length, 1);
+    assert.equal(qList.data[0].id, q1.queuedSubmission.id);
+
+    // 空闲状态启动排队消息
+    const startedQ = await bridge.request('thread/queue/start', {
+      threadId: qThreadId,
+      queuedSubmissionId: q1.queuedSubmission.id,
+    });
+    assert.equal(typeof startedQ.turn?.id, 'string');
+    assert.deepEqual(await bridge.request('thread/queue/list', { threadId: qThreadId }), { data: [], nextCursor: null });
+
+    // 运行中打断执行排队消息（中途补充并打断执行）
+    let releaseHold;
+    const holdGate = new Promise(resolve => { releaseHold = resolve; });
+    const holdAdapter = {
+      manifest: { id: 'hold-adapter', name: 'Hold', capabilities: { streaming: true, models: true, resume: true } },
+      async open() { return {}; },
+      async send(session, text, { emit }) {
+        if (text.includes('长任务')) {
+          await holdGate;
+        } else {
+          emit({ kind: 'completed', finalAnswer: true });
+        }
+      },
+      async cancel() { releaseHold(); },
+      async close() {},
+    };
+    runtime.adapters.set('hold-adapter', holdAdapter);
+    runtime.status['hold-adapter'] = { available: true };
+    const steerThread = await bridge.request('thread/start', { cwd: root, model: routeModel('hold-adapter') });
+    const steerThreadId = steerThread.thread.id;
+    // 启动初始任务，使其进入运行中状态
+    const initTurn = await bridge.request('turn/start', {
+      threadId: steerThreadId,
+      input: [{ type: 'text', text: '长任务运行中...' }],
+    });
+    assert.equal(runtime.execution.isRunning(steerThreadId), true);
+    // 运行时添加排队补充
+    const steerQueue = await bridge.request('thread/queue/add', {
+      threadId: steerThreadId,
+      input: [{ type: 'text', text: '中途打断补充并立即执行' }],
+    });
+    assert.equal(typeof steerQueue.queuedSubmission.id, 'string');
+    // 执行 thread/queue/start：打断当前任务并立即执行补充内容
+    const midTurnStart = await bridge.request('thread/queue/start', {
+      threadId: steerThreadId,
+      queuedSubmissionId: steerQueue.queuedSubmission.id,
+    });
+    assert.notEqual(midTurnStart.turn.id, initTurn.turn.id, '排队消息中途启动已成功打断并派生新 Turn');
+    releaseHold();
+    await wait(() => !runtime.execution.isRunning(steerThreadId));
+
+    console.log('PASS: native protocol, external steering, command execution, message queue and Usage projection');
   } finally { bridge.close(); await runtime.close(); }
 }
 main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-secret-test.cjs

@@ -20,8 +20,8 @@ const helper = [
   assert.equal(redactText('ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'), '[redacted]');
   assert.equal(redactText('skeleton key'), 'skeleton key'); // no false positive on prose
   assert.deepEqual(
-    redact({ token: 'x', name: 'ok', nested: { api_key: 'y', list: ['Bearer zzzzzzzzzzzz'] } }),
-    { token: '[redacted]', name: 'ok', nested: { api_key: '[redacted]', list: ['[redacted]'] } },
+    redact({ token: 'x', name: 'ok', userCode: 'ABCD-EFGH', loginId: 'login-1', verificationUrl: 'https://auth.example/device', nested: { api_key: 'y', list: ['Bearer zzzzzzzzzzzz'] } }),
+    { token: '[redacted]', name: 'ok', userCode: '[redacted]', loginId: '[redacted]', verificationUrl: '[redacted]', nested: { api_key: '[redacted]', list: ['[redacted]'] } },
   );
 
   if (!helper) {

package/scripts/native-shim-test.cjs

@@ -10,6 +10,7 @@ const { terminateTree } = require('../src/main/native/process-utils');
 async function main() {
   const work = fs.mkdtempSync(path.join(os.tmpdir(), 'hm shim spaces-'));
   const host = path.join(work, 'fixture host.cjs');
+  const stockProbe = path.join(work, 'stock probe.cjs');
   const env = { ...process.env, HARNESS_MIX_NODE_PATH: process.execPath,
     CODEXHOST_STOCK_CODEX_PATH: process.execPath, HARNESS_MIX_HOST_SCRIPT: host, CODEX_CLI_PATH: 'must-be-removed' };
   let child;
@@ -19,8 +20,23 @@ if (process.env.CODEX_CLI_PATH) process.exit(90);
 readline.createInterface({ input: process.stdin }).on('line', line => {
   process.stdout.write(JSON.stringify({ text: line, args: process.argv.slice(2) }) + '\\n');
 }).on('close', () => process.exit(0));`);
-    assert.equal(execFileSync(nativePaths().shim, ['--version'], { env, encoding: 'utf8', timeout: 10000 }).trim(), process.version);
-    child = spawn(nativePaths().shim, ['app-server', 'argument with spaces'], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+    fs.writeFileSync(stockProbe, `process.stdout.write(JSON.stringify(process.argv.slice(1))); process.exit(0);`);
+    const passthrough = args => execFileSync(nativePaths().shim, args, { env, encoding: 'utf8', timeout: 10000 }).trim();
+    assert.equal(passthrough(['--version']), process.version);
+    const probeEnv = { ...env, NODE_OPTIONS: [process.env.NODE_OPTIONS, `--require=${JSON.stringify(stockProbe)}`].filter(Boolean).join(' ') };
+    const probeStock = args => JSON.parse(execFileSync(nativePaths().shim, args, { env: probeEnv, encoding: 'utf8', timeout: 10000 }));
+    const assertStock = (args, message) => {
+      const observed = probeStock(args);
+      assert.equal(observed.length, args.length, message);
+      assert.equal(path.basename(observed[0]), args[0], message);
+      assert.deepEqual(observed.slice(1), args.slice(1), message);
+    };
+    assertStock(['app-server', 'proxy'], 'app-server proxy stays on the official CLI');
+    assertStock(['app-server', 'daemon'], 'app-server daemon stays on the official CLI');
+    assertStock(['app-server', '--future-option'], 'unknown app-server forms fail open to the official CLI');
+    assertStock(['exec', 'app-server'], 'an argument named app-server is not treated as the subcommand');
+    const serverArgs = ['-c', 'feature.label=argument with spaces', 'app-server', '--listen', 'stdio://', '--analytics-default-enabled'];
+    child = spawn(nativePaths().shim, serverArgs, { env, stdio: ['pipe', 'pipe', 'pipe'] });
     let stdout = '', stderr = '';
     child.stdout.on('data', chunk => { stdout += chunk; });
     child.stderr.on('data', chunk => { stderr += chunk; });
@@ -31,8 +47,8 @@ readline.createInterface({ input: process.stdin }).on('line', line => {
     });
     child.stdin.end('你好 Linux/macOS\n');
     assert.equal(await done, 0, stderr);
-    assert.deepEqual(JSON.parse(stdout), { text: '你好 Linux/macOS', args: ['app-server', 'argument with spaces'] });
-    console.log('PASS: compiled Shim routing, Unicode stdio, spaced arguments, environment and EOF');
+    assert.deepEqual(JSON.parse(stdout), { text: '你好 Linux/macOS', args: serverArgs });
+    console.log('PASS: precise app-server routing, official management passthrough, Unicode stdio, arguments, environment and EOF');
   } finally {
     if (child && child.exitCode === null) await terminateTree(child.pid);
     fs.rmSync(work, { recursive: true, force: true });

package/scripts/native-sidebar-test.cjs

@@ -21,6 +21,13 @@ assert.deepEqual(merged.data.map(t => t.id), ['official', 'external']);
 assert.equal(merged.nextCursor, 'next');
 assert.equal(mergeThreadPage(page, [thread], { cursor: 'next' }, t => t), page);
 
+const archivedThread = { id: 'archived-ext', archived: true, createdAt: 15 };
+const pageWithArchived = { data: [{ id: 'official', createdAt: 20 }, archivedThread], nextCursor: null };
+const mergedWithoutArchived = mergeThreadPage(pageWithArchived, [archivedThread], { archived: false }, t => t);
+assert.deepEqual(mergedWithoutArchived.data.map(t => t.id), ['official']);
+const mergedWithArchived = mergeThreadPage({ data: [{ id: 'official-archived', archived: true, createdAt: 20 }, archivedThread], nextCursor: null }, [archivedThread], { archived: true }, t => t);
+assert.deepEqual(mergedWithArchived.data.map(t => t.id), ['official-archived', 'archived-ext']);
+
 const root = fs.mkdtempSync(path.resolve('output/native-runtime-cache-test-'));
 const resources = path.join(root, 'resources');
 const cache = path.join(root, 'cache');