@logicseek/hello-cc 1.0.5 → 1.1.0-rc.3

package/scripts/web-file-preview-checks.mjs

@@ -0,0 +1,302 @@
+// Reusable browser checks for normal, test-owned project artifacts.
+// Shares the acceptance runtime; never starts an Agent or calls a model.
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { deflateSync } from 'node:zlib';
+
+export const FILE_PREVIEW_CHECKS = Object.freeze([
+  'standalone', 'html', 'markdown', 'text', 'image', 'pdf', 'formats',
+  'bounded-text', 'mobile', 'late-file', 'close-pending', 'project-switch', 'readonly'
+]);
+
+const sha256 = content => createHash('sha256').update(content).digest('hex');
+function pngFixture() {
+  const crc = bytes => {
+    let value = -1;
+    for (const byte of bytes) {
+      value ^= byte;
+      for (let bit = 0; bit < 8; bit++) value = (value >>> 1) ^ ((value & 1) ? 0xedb88320 : 0);
+    }
+    return (value ^ -1) >>> 0;
+  };
+  const chunk = (name, data) => {
+    const type = Buffer.from(name), length = Buffer.alloc(4), checksum = Buffer.alloc(4);
+    length.writeUInt32BE(data.length); checksum.writeUInt32BE(crc(Buffer.concat([type, data])));
+    return Buffer.concat([length, type, data, checksum]);
+  };
+  const width = 640, height = 320, rows = Buffer.alloc((width * 3 + 1) * height);
+  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+    const offset = y * (width * 3 + 1) + 1 + x * 3;
+    let color = [244, 249, 247];
+    if (x > 55 && x < 590 && (y === 272 || y === 273)) color = [182, 204, 196];
+    for (let bar = 0; bar < 5; bar++) {
+      if (x > 75 + 100 * bar && x < 138 + 100 * bar && y > 215 - bar * 29 && y < 272) color = [19 + bar * 7, 125 + bar * 10, 107 + bar * 6];
+    }
+    for (let channel = 0; channel < 3; channel++) rows[offset + channel] = color[channel];
+  }
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(width, 0); header.writeUInt32BE(height, 4); header[8] = 8; header[9] = 2;
+  return Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), chunk('IHDR', header), chunk('IDAT', deflateSync(rows)), chunk('IEND', Buffer.alloc(0))]);
+}
+
+function pdfFixture() {
+  const stream = 'BT /F1 25 Tf 54 738 Td (Project report) Tj 0 -45 Td /F1 13 Tf (File preview acceptance fixture) Tj 0 -30 Td (All five sample milestones are complete.) Tj ET';
+  const objects = [
+    '<< /Type /Catalog /Pages 2 0 R >>', '<< /Type /Pages /Kids [3 0 R] /Count 1 >>',
+    '<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>',
+    '<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>',
+    '<< /Length ' + Buffer.byteLength(stream) + ' >>\nstream\n' + stream + '\nendstream'
+  ];
+  let text = '%PDF-1.4\n';
+  const offsets = [];
+  for (const [index, body] of objects.entries()) {
+    offsets.push(Buffer.byteLength(text)); text += (index + 1) + ' 0 obj\n' + body + '\nendobj\n';
+  }
+  const xref = Buffer.byteLength(text);
+  text += 'xref\n0 6\n0000000000 65535 f \n' + offsets.map(offset => String(offset).padStart(10, '0') + ' 00000 n \n').join('')
+    + 'trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n' + xref + '\n%%EOF\n';
+  return Buffer.from(text);
+}
+
+function fixtures(sandbox) {
+  const first = path.join(sandbox, 'preview project with spaces'), second = path.join(sandbox, 'second preview project');
+  const files = new Map([
+    [path.join(first, 'README.md'), '# Project handoff\n\nA **reviewable result** from the workspace.\n\n- Inspect the report\n- Review the chart\n- Read the source\n\n```js\nconst status = "complete";\n```\n'],
+    [path.join(first, 'src/main.mjs'), 'export const greeting = "Hello from the project";\nexport const example = "<sample>";\n'],
+    [path.join(first, 'artifacts/report.html'), '<!doctype html><html><head><title>Milestone report</title><style>body{font:16px system-ui;margin:0;padding:40px;background:#f5faf7;color:#174837}h1{font-size:32px}section{padding:22px;background:white;border:1px solid #cce2d5;border-radius:12px;margin-top:28px}strong{font-size:40px;color:#12876b}</style></head><body><h1>Milestone report</h1><p>Generated locally</p><section><strong>5 / 5</strong><h2>Milestones completed</h2><p>Inspect this saved artifact without starting an Agent.</p></section></body></html>'],
+    [path.join(first, 'artifacts/chart.png'), pngFixture()],
+    [path.join(first, 'artifacts/report.pdf'), pdfFixture()],
+    [path.join(first, 'artifacts/sample.svg'), '<svg xmlns="http://www.w3.org/2000/svg"><text x="20" y="20">Source only</text></svg>'],
+    [path.join(first, 'artifacts/data.bin'), Buffer.from([0, 1, 2, 255, 0, 4])],
+    [path.join(first, 'large.txt'), 'Large text fixture\n' + 'example line\n'.repeat(100000)],
+    [path.join(first, 'dist/index.html'), '<h1>Build output is browsable</h1>'],
+    [path.join(second, 'SECOND.md'), '# Second project\n\nThe selected project owns this preview.\n']
+  ]);
+  for (const [filename, content] of files) {
+    fs.mkdirSync(path.dirname(filename), { recursive: true, mode: 0o700 }); fs.writeFileSync(filename, content);
+  }
+  return { first, second, files };
+}
+
+function deferred() {
+  let resolve, reject;
+  const promise = new Promise((accept, decline) => { resolve = accept; reject = decline; });
+  return { promise, resolve, reject };
+}
+
+async function bounded(promise, label) {
+  let timer;
+  try {
+    return await Promise.race([promise, new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('Timed out: ' + label)), 15000); })]);
+  } finally { clearTimeout(timer); }
+}
+
+// Delay delivery of an actual response. File contents and server behavior are
+// unchanged; the only controlled variable is when the browser receives it.
+async function delayedPreview(page, project, filename, whileHeld) {
+  const arrived = deferred(), release = deferred(), settled = deferred(), completed = deferred();
+  let heldRequest, routeError;
+  const matches = url => url.pathname === '/api/files/preview' && url.searchParams.get('path') === filename && url.searchParams.get('root') === project;
+  const finished = request => { if (request === heldRequest) completed.resolve(); };
+  const handler = async route => {
+    heldRequest = route.request();
+    try {
+      const response = await route.fetch();
+      assert.equal(response.status(), 200, 'The delayed preview must be a real successful file read');
+      arrived.resolve(); await release.promise; await route.fulfill({ response });
+    } catch (error) { routeError = error; arrived.reject(error); }
+    finally { settled.resolve(); }
+  };
+  page.on('requestfinished', finished); page.on('requestfailed', finished);
+  await page.route(matches, handler);
+  try {
+    await page.evaluate(filename => window.hccFiles.open(filename), filename);
+    await bounded(arrived.promise, 'preview response fetched');
+    await whileHeld(); release.resolve();
+    await bounded(settled.promise, 'preview response released');
+    await bounded(completed.promise, 'preview request settled in browser');
+    if (routeError && heldRequest.failure()?.errorText !== 'net::ERR_ABORTED') throw routeError;
+    // Wait for the browser's next rendered state, not an arbitrary sleep.
+    await page.evaluate(() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve))));
+    return heldRequest.failure() ? 'cancelled-on-project-change' : 'delivered';
+  } finally {
+    release.resolve(); await page.unroute(matches, handler);
+    page.off('requestfinished', finished); page.off('requestfailed', finished);
+  }
+}
+
+export async function runFilePreviewChecks({ browser, base, token, sandbox, registerPage, adapters, check, shot, watch, browserInstrumentation, evidence }) {
+  const { first, second, files } = fixtures(sandbox);
+  const hashes = () => Object.fromEntries([...files.keys()].map(filename => [path.relative(sandbox, filename), sha256(fs.readFileSync(filename))]));
+  const before = hashes(), providers = [...adapters.keys()], sends = providers.map(provider => adapters.get(provider).sent || 0);
+  const receipt = evidence.filePreview = {
+    schemaVersion: 1, checks: [], viewports: [{ width: 1440, height: 1000 }, { width: 390, height: 844 }],
+    modelCalls: false, fileHashes: before, fileRequests: [], writeRequests: [],
+    pdfScope: 'Typed PDF Blob, iframe handoff and downloaded bytes; browser PDF viewer internals and OS rendering are not asserted'
+  };
+  const pass = (id, label) => { receipt.checks.push(id); check('file preview: ' + label); };
+  const previousProject = await registerPage.evaluate(() => window.hccHandoff.projectRoot);
+  for (const project of [first, second]) {
+    await registerPage.locator('#openProjectDialog').click();
+    await registerPage.locator('#projectPath').fill(project);
+    await registerPage.locator('#addProjectBtn').click();
+    await registerPage.waitForFunction(project => window.hccHandoff.projectRoot === project &&
+      document.getElementById('projectDialog').hidden, project);
+  }
+  await registerPage.locator('#projectSelect').selectOption(previousProject);
+  await registerPage.waitForFunction(project => window.hccHandoff.projectRoot === project &&
+    window.hccHandoff.actionToken && /(已连接|Connected)$/.test(document.getElementById('handoffConnection').textContent), previousProject);
+  const context = await browser.newContext({ viewport: receipt.viewports[0], acceptDownloads: true });
+  await context.addInitScript(browserInstrumentation);
+  // Observe the normal browser Blob handoff. Fetching a blob: URL is outside
+  // the preview flow and intentionally unavailable under the page's CSP.
+  await context.addInitScript(() => {
+    const create = URL.createObjectURL;
+    window.__hccPreviewBlobs = new Map();
+    URL.createObjectURL = function (blob) {
+      const url = create.call(this, blob);
+      window.__hccPreviewBlobs.set(url, { type: blob.type, size: blob.size });
+      return url;
+    };
+  });
+  const page = await context.newPage(); watch(page);
+  const open = async () => {
+    await page.locator('#filesBtn').click(); await page.locator('#filesDialog').waitFor({ state: 'visible' });
+    await page.locator('#filesEntries button').first().waitFor();
+  };
+  const select = async filename => {
+    const buttons = page.locator('#filesEntries button[data-file-path]');
+    const index = (await buttons.evaluateAll(elements => elements.map(element => element.dataset.filePath))).indexOf(filename);
+    assert.ok(index >= 0, 'Missing project entry: ' + filename); await buttons.nth(index).click();
+  };
+  const show = async filename => {
+    await page.evaluate(filename => window.hccFiles.open(filename), filename);
+    await page.waitForFunction(filename => document.getElementById('filesMeta').textContent.startsWith(filename + ' ·'), filename);
+  };
+  const fits = async () => {
+    const box = await page.locator('#filesPanel').boundingBox(), viewport = page.viewportSize();
+    assert.ok(box && box.x >= 0 && box.y >= 0 && box.x + box.width <= viewport.width + 1 && box.y + box.height <= viewport.height + 1, JSON.stringify(box));
+    assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1));
+  };
+  try {
+    await page.goto(base + '/?token=' + token);
+    await page.waitForFunction(() => window.hccFiles && window.hccHandoff?.actionToken &&
+      /(已连接|Connected)$/.test(document.getElementById('handoffConnection').textContent));
+    await page.locator('#projectSelect').selectOption(first);
+    await page.waitForFunction(project => window.hccHandoff?.projectRoot === project, first);
+    assert.equal(await page.title(), 'hello-cc'); assert.equal(new URL(page.url()).origin, base);
+    assert.ok((await page.locator('body').innerText()).includes('hello-cc'));
+    assert.equal(await page.locator('vite-error-overlay,nextjs-portal,#webpack-dev-server-client-overlay').count(), 0);
+    page.on('request', request => {
+      const url = new URL(request.url());
+      if (url.origin !== base || !url.pathname.startsWith('/api/')) return;
+      const item = { method: request.method(), path: url.pathname, project: url.searchParams.get('root') };
+      if (url.pathname.startsWith('/api/files/')) receipt.fileRequests.push(item);
+      if (!['GET', 'HEAD', 'OPTIONS'].includes(request.method())) receipt.writeRequests.push(item);
+    });
+    await open(); await fits();
+    const names = await page.locator('#filesEntries button').evaluateAll(buttons => buttons.map(button => button.dataset.filePath));
+    assert.ok(names.includes('README.md') && names.includes('dist'));
+    assert.equal(await page.evaluate(() => window.hccHandoff.sessions.length), 0);
+    pass('standalone', 'standalone project files open with no Agent session');
+
+    await select('artifacts'); await page.locator('[data-file-path="artifacts/report.html"]').waitFor();
+    await select('artifacts/report.html'); await page.frameLocator('#filesFrame').locator('h1').waitFor();
+    assert.equal(await page.frameLocator('#filesFrame').locator('h1').innerText(), 'Milestone report');
+    assert.equal(await page.locator('#filesFrame').getAttribute('sandbox'), '');
+    await shot(page, 'desktop-file-preview-html');
+    await page.locator('#filesSourceBtn').click();
+    assert.ok((await page.locator('#filesPreview pre').innerText()).includes('<h1>Milestone report</h1>'));
+    await page.locator('#filesSourceBtn').click(); await page.frameLocator('#filesFrame').locator('h1').waitFor();
+    pass('html', 'directory navigation and static HTML source/rendered switch work');
+
+    await page.locator('#filesUp').click(); await page.locator('[data-file-path="README.md"]').waitFor();
+    await select('README.md'); await page.locator('#filesPreview h1').waitFor();
+    assert.equal(await page.locator('#filesPreview h1').innerText(), 'Project handoff');
+    assert.equal(await page.locator('#filesPreview li').count(), 3);
+    assert.equal(await page.locator('#filesPreview pre code').innerText(), 'const status = "complete";');
+    pass('markdown', 'Markdown headings, lists and code blocks render');
+    await show('src/main.mjs');
+    assert.ok((await page.locator('#filesPreview pre').innerText()).includes('<sample>'));
+    assert.equal(await page.locator('#filesPreview sample').count(), 0);
+    pass('text', 'source files display literal text');
+
+    await show('artifacts/chart.png');
+    await page.waitForFunction(() => document.querySelector('#filesPreview img')?.naturalWidth === 640);
+    const size = await page.locator('#filesPreview img').evaluate(image => ({ width: image.naturalWidth, height: image.naturalHeight, renderedWidth: image.clientWidth, renderedHeight: image.clientHeight }));
+    assert.equal(size.height, 320); assert.ok(Math.abs(size.renderedWidth / size.renderedHeight - 2) < 0.02);
+    await shot(page, 'desktop-file-preview-image');
+    pass('image', 'PNG dimensions and displayed aspect ratio match the fixture');
+
+    await show('artifacts/report.pdf'); await page.locator('#filesDownload').waitFor({ state: 'visible' });
+    const pdfUrl = await page.locator('#filesFrame').getAttribute('src'); assert.match(pdfUrl, /^blob:/);
+    assert.equal(await page.locator('#filesDownload').getAttribute('href'), pdfUrl);
+    const blob = await page.evaluate(url => window.__hccPreviewBlobs.get(url), pdfUrl);
+    assert.equal(blob.type, 'application/pdf');
+    const expectedPdfHash = sha256(files.get(path.join(first, 'artifacts/report.pdf')));
+    assert.equal(blob.size, files.get(path.join(first, 'artifacts/report.pdf')).length);
+    const downloading = page.waitForEvent('download'); await page.locator('#filesDownload').click(); const download = await downloading;
+    assert.equal(download.suggestedFilename(), 'report.pdf');
+    const stream = await download.createReadStream(), chunks = [];
+    assert.ok(stream, 'Downloaded PDF must be readable'); for await (const chunk of stream) chunks.push(chunk);
+    assert.equal(sha256(Buffer.concat(chunks)), expectedPdfHash);
+    receipt.pdf = { mime: blob.type, bytes: blob.size, sha256: expectedPdfHash, filename: download.suggestedFilename() };
+    await shot(page, 'desktop-file-preview-pdf-handoff');
+    pass('pdf', 'typed PDF Blob and downloaded bytes match the saved file');
+
+    await show('artifacts/sample.svg'); assert.ok((await page.locator('#filesPreview pre').innerText()).includes('<svg'));
+    assert.equal(await page.locator('#filesPreview svg').count(), 0);
+    await show('artifacts/data.bin'); assert.ok((await page.locator('#filesPreview').innerText()).trim().length > 0);
+    assert.equal(await page.locator('#filesPreview iframe,#filesPreview img').count(), 0);
+    pass('formats', 'SVG remains source text and unsupported binary has an explicit state');
+    await show('large.txt'); assert.ok((await page.locator('#filesPreviewStatus').innerText()).trim().length > 0);
+    const large = await page.locator('#filesPreview pre').innerText();
+    assert.ok(Buffer.byteLength(large) <= 1024 * 1024 && large.length < String(files.get(path.join(first, 'large.txt'))).length);
+    pass('bounded-text', 'large text remains bounded with a visible truncation notice');
+
+    await page.locator('#filesClose').click(); await page.setViewportSize(receipt.viewports[1]);
+    await open(); await fits(); await shot(page, 'mobile-file-preview-list');
+    await select('README.md'); await page.locator('#filesPreview h1').waitFor(); await fits();
+    await shot(page, 'mobile-file-preview-markdown');
+    await page.locator('#filesBack').click(); assert.equal(await page.locator('#filesEntries').isVisible(), true);
+    await page.locator('#filesClose').click(); assert.equal(await page.locator('#filesDialog').isVisible(), false);
+    pass('mobile', '390px list, preview, back and close fit the viewport');
+
+    await page.setViewportSize(receipt.viewports[0]);
+    receipt.lateFile = await delayedPreview(page, first, 'src/main.mjs', () => show('README.md'));
+    assert.equal(await page.locator('#filesName').innerText(), 'README.md');
+    assert.equal(await page.locator('#filesPreview h1').innerText(), 'Project handoff');
+    pass('late-file', 'late previous-file response cannot replace the latest preview');
+    await delayedPreview(page, first, 'src/main.mjs', () => page.locator('#filesClose').click());
+    assert.equal(await page.locator('#filesDialog').isVisible(), false);
+    assert.equal(await page.locator('#filesPreview').innerText(), '');
+    await open(); assert.equal(await page.locator('#filesName').innerText(), '');
+    pass('close-pending', 'closing a pending preview leaves the next dialog clean');
+
+    receipt.lateProject = await delayedPreview(page, first, 'src/main.mjs', async () => {
+      // The project selector is outside the modal. Close through its visible
+      // control before switching, as a user would.
+      await page.locator('#filesClose').click();
+      await page.locator('#projectSelect').selectOption(second);
+      await page.waitForFunction(project => window.hccHandoff.projectRoot === project, second);
+      await open();
+      const entries = await page.locator('#filesEntries button').evaluateAll(buttons => buttons.map(button => button.dataset.filePath));
+      assert.ok(entries.includes('SECOND.md') && !entries.includes('README.md'));
+      await select('SECOND.md'); await page.locator('#filesPreview h1').waitFor();
+    });
+    assert.equal(await page.locator('#filesProject').innerText(), second);
+    assert.equal(await page.locator('#filesPreview h1').innerText(), 'Second project');
+    pass('project-switch', 'project switch scopes reads and fences the prior project response');
+    await page.locator('#filesClose').click();
+    assert.equal(await page.evaluate(() => window.hccHandoff.sessions.length), 0);
+    assert.deepEqual([...adapters.keys()], providers); assert.deepEqual(providers.map(provider => adapters.get(provider).sent || 0), sends);
+    assert.deepEqual(hashes(), before);
+    assert.deepEqual(receipt.writeRequests, [{ method: 'POST', path: '/api/projects/select', project: second }],
+      'Only the explicit project switch may write selection metadata; previews must not mutate files or workers');
+    assert.ok(receipt.fileRequests.length > 0 && receipt.fileRequests.every(request => request.method === 'GET' && [first, second].includes(request.project)));
+    pass('readonly', 'preview preserves fixture bytes and makes no file writes or Agent sends');
+    assert.deepEqual(receipt.checks, FILE_PREVIEW_CHECKS); receipt.success = true;
+  } finally { await context.close(); }
+}

package/scripts/web-mcp-form-acceptance.mjs

@@ -0,0 +1,134 @@
+// Browser acceptance with isolated simulated providers. No real model or provider authentication is used.
+import fs from 'node:fs';
+import path from 'node:path';
+import net from 'node:net';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { DatabaseSync } from 'node:sqlite';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+if (!process.argv.includes('--run-browser')) { console.log('Use --run-browser with HCC_ACCEPTANCE_PLAYWRIGHT and optional HCC_ACCEPTANCE_CHROME. Uses simulated providers and isolated projects; no model calls.'); process.exit(0); }
+const { chromium } = await import(process.env.HCC_ACCEPTANCE_PLAYWRIGHT || 'playwright');
+import { createEventHelpers } from '../lib/db/events.mjs';
+import { createPeerHelpers } from '../lib/core/peers/peer-helpers.mjs';
+import { createPeerBindingStore } from '../lib/db/stores/peers.mjs';
+import { createMessageStore } from '../lib/core/coordination/messages.mjs';
+import { inspectProcessIdentity } from '../lib/process/identity.mjs';
+import { startNativeService } from '../lib/runtime/native/service.mjs';
+import { nativeRequest } from '../lib/runtime/native/client.mjs';
+import { createNativeInteractions } from '../lib/integrations/native/interactions.mjs';
+import { codexInteractionResponse, codexInteractionKind, cancelCodexInteraction } from '../lib/integrations/codex-interactions.mjs';
+const node=process.execPath, repo=fileURLToPath(new URL('..',import.meta.url));
+const dir=fs.realpathSync(fs.mkdtempSync('/tmp/hcc-interactions-ui-')),root=path.join(dir,'project'),home=path.join(dir,'home'),bin=path.join(dir,'bin'),socket='hcc-interactions-'+Date.now();
+for(const folder of [root,home,bin])fs.mkdirSync(folder);
+const formParams={mode:'form',serverName:'form-fixture',message:'Provide project settings <script>bad()</script>',requestedSchema:{type:'object',properties:{name:{type:'string',title:'Project <name>',minLength:3,maxLength:20},count:{type:'integer',minimum:1,maximum:4},enabled:{type:'boolean'},region:{type:'string',oneOf:[{const:'eu',title:'Europe'},{const:'us',title:'USA'}]},features:{type:'array',minItems:1,maxItems:2,items:{anyOf:[{const:'logs',title:'Logs'},{const:'tests',title:'Tests'}]}},optional:{type:'string',default:'suggested'}},required:['name','count','enabled','region','features']}};
+const env={PATH:bin+':'+path.dirname(node)+':/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin',HOME:home,SHELL:'/bin/bash',LANG:'en_US.UTF-8',TMPDIR:dir,CODEX_HOME:path.join(home,'.codex'),HCC_NO_AUTO_INSTALL_TMUX:'1',HCC_WEB_TOKEN:'qa-interactive-isolated',HCC_TEST_MCP_RPC:path.join(dir,'mcp-rpc.jsonl')};
+const tmux=spawnSync('which',['tmux'],{encoding:'utf8'}).stdout.trim();if(!tmux||!fs.existsSync(tmux))throw Error('tmux is required for isolated Web runtime acceptance');
+fs.writeFileSync(path.join(bin,'tmux'),'#!/bin/sh\nexec '+JSON.stringify(tmux)+' -L '+socket+' "$@"\n',{mode:0o700});
+fs.writeFileSync(path.join(bin,'codex'),`#!${node}
+import readline from 'node:readline';
+import fs from 'node:fs';
+const send=x=>process.stdout.write(JSON.stringify(x)+'\\n'),reply=(m,r)=>send({id:m.id,result:r});
+let thread={id:'qa-thread',cwd:process.cwd(),status:{type:'idle'},turns:[]}, pending, turn;
+const req=(method,params)=>{pending=params.mode==='url'?'mcp-url':method;send({id:params.mode==='url'?'mcp-url':method==='mcpServer/elicitation/request'?0:method,method,params:{threadId:thread.id,turnId:turn.id,itemId:method,...params}})};
+readline.createInterface({input:process.stdin}).on('line',line=>{
+const m=JSON.parse(line),p=m.params||{};
+if(!m.method){fs.appendFileSync(process.env.HCC_TEST_MCP_RPC,JSON.stringify(m)+'\\n');send({method:'serverRequest/resolved',params:{threadId:thread.id,requestId:m.id}});if(pending==='item/permissions/requestApproval'){req('item/tool/requestUserInput',{questions:[{id:'choice',header:'Choice',question:'Which mode?',options:[{label:'Blue',description:'Blue mode'},{label:'Red',description:'Red mode'}]}]});}else if(pending==='item/tool/requestUserInput'){req('mcpServer/elicitation/request',${JSON.stringify(formParams)});}else if(pending==='mcpServer/elicitation/request'){req('mcpServer/elicitation/request',{mode:'url',serverName:'form-fixture',message:'External authentication',url:'javascript:alert(1)',elicitationId:'unsupported-url'});}else{turn.status='completed';send({method:'turn/completed',params:{threadId:thread.id,turn}});}return;}
+if(m.method==='initialized')return;
+if(m.method==='initialize')return reply(m,{userAgent:'ui-fake'});
+if(m.method==='thread/list')return reply(m,{data:[thread],nextCursor:null});
+if(['thread/start','thread/resume','thread/read'].includes(m.method))return reply(m,{thread});
+if(m.method==='turn/start'){turn={id:'qa-turn',status:'inProgress',items:[]};thread.turns.push(turn);thread.status={type:'active'};reply(m,{turn});req('item/permissions/requestApproval',{cwd:process.cwd(),reason:'Test bounded permission',permissions:{network:{enabled:true},fileSystem:{read:['/read-only'],write:['/project']}}});return;}
+reply(m,{});
+});
+`,{mode:0o700});
+function sourceHashes(){const result={};const walk=folder=>{for(const entry of fs.readdirSync(path.join(repo,folder),{withFileTypes:true})){const file=path.join(folder,entry.name);if(entry.isDirectory())walk(file);else if(entry.isFile())result[file]=createHash('sha256').update(fs.readFileSync(path.join(repo,file))).digest('hex');}};for(const folder of ['bin','lib','scripts','test'])walk(folder);for(const file of ['package.json','package-lock.json'])result[file]=createHash('sha256').update(fs.readFileSync(path.join(repo,file))).digest('hex');return result;}
+const evidence={dir,checks:[],screenshots:[],pageErrors:[],consoleErrors:[],browser:'Browser plugin not available; isolated installed Chrome + Playwright',providerMode:'simulated protocol requests; production HTTP, SQLite, worker and browser paths; no inference',node:process.version,sourceRoot:repo,sourceFiles:sourceHashes(),startedAt:new Date().toISOString()};
+const check=(name,extra={})=>{evidence.checks.push({name,...extra});console.log('PASS '+name);};
+function hcc(...args){const r=spawnSync(node,[path.join(repo,'bin/hcc.mjs'),'--root',root,...args],{cwd:root,env,encoding:'utf8',timeout:30000});if(r.status!==0)throw Error('Isolated CLI failed '+args[0]);return r.stdout;}
+const ctx={root,dbPath:path.join(root,'.hello-cc','mesh.db')},events=createEventHelpers(),binding=createPeerBindingStore(events),peer=createPeerHelpers({now:()=>Math.floor(Date.now()/1000),...events});
+const deps={...events,...binding,...peer,...createMessageStore(events),connect:()=>new DatabaseSync(ctx.dbPath),detectBranch:()=>'',liveProcessIdentity:pid=>inspectProcessIdentity(pid).identity};
+let browser,service,runtime=false,state,interactions,emit,adapter;
+const api=(method,route,body)=>nativeRequest(ctx,method,route,body);
+const port=await new Promise(resolve=>{const s=net.createServer();s.listen(0,'127.0.0.1',()=>{const p=s.address().port;s.close(()=>resolve(p));});}),base='http://127.0.0.1:'+port;
+const shot=async(page,name)=>{const file=path.join(dir,name+'.png');await page.screenshot({path:file});evidence.screenshots.push(file);};
+const wait=(page,fn)=>page.waitForFunction(fn,null,{timeout:12000});
+function ask(id,method,params){state.turnId='native-turn';state.status='running';return interactions.request({requestId:id,sessionId:state.sessionId,turnId:state.turnId,method,kind:codexInteractionKind(method),params,validate:codexInteractionResponse,cancelled:cancelCodexInteraction(method)});}
+try{
+hcc('up','--no-discover','--no-guidance');
+service=await startNativeService(ctx,deps,{pollMs:60000,adapterFactory:async(provider,options)=>{
+state={provider,status:'idle',sessionId:'native-qa-session',turnId:null,executorId:options.executorId,capabilities:{send:true,interrupt:true,close:true,approvals:true,userInput:true}};emit=options.onEvent;
+interactions=createNativeInteractions({executorId:options.executorId,isActive:(session,turn)=>session===state.sessionId&&turn===state.turnId&&state.status==='running',onChange:emit});
+adapter={capabilities:state.capabilities,snapshot:()=>({...state,pendingApprovals:interactions.snapshot()}),async open(){return this.snapshot();},respond:interactions.respond,async interrupt(){interactions.expire();state.turnId=null;state.status='idle';return{status:'interrupting'};},async close(){interactions.expire();state.status='closed';}};return adapter;
+}});
+await api('POST','/workers',{peer:'native-qa',provider:'codex'});
+hcc('web','--local','--port',String(port),'--no-discover','--no-guidance');runtime=true;
+browser=await chromium.launch({headless:true,executablePath:process.env.HCC_ACCEPTANCE_CHROME||'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'});
+const a=await browser.newContext({viewport:{width:1440,height:1000}}),b=await browser.newContext({viewport:{width:1280,height:900}});
+for(const c of [a,b])await c.addInitScript(()=>localStorage.setItem('hcc.lang','en'));
+const p1=await a.newPage(),p2=await b.newPage();
+for(const [p,label]of [[p1,'controller'],[p2,'observer']]){p.on('pageerror',e=>evidence.pageErrors.push({label,message:e.message}));p.on('console',m=>{if(['warning','error'].includes(m.type()))evidence.consoleErrors.push({label,text:m.text()});});p.on('dialog',d=>d.accept());}
+await p1.goto(base+'/?token='+env.HCC_WEB_TOKEN);await wait(p1,()=>window.hccHandoff?.canControl&&window.hccHandoff.session?.type==='native');
+assert.equal(await p1.title(),'hello-cc');assert.ok((await p1.locator('body').innerText()).length>200);check('page identity, nonblank, native view and no error overlay');
+const command=ask('command','item/commandExecution/requestApproval',{command:'echo <script>bad()</script>',cwd:root});
+await p1.locator('#nativeRead').click();await p1.locator('#nativeApprovals button[data-decision="accept"]').waitFor();
+await p2.goto(base+'/?token='+env.HCC_WEB_TOKEN);await wait(p2,()=>window.hccHandoff?.session?.type==='native'&&window.hccHandoff.actionToken);
+assert.equal(await p2.locator('#nativeApprovals button[data-decision="accept"]').isDisabled(),true);assert.equal(await p1.locator('#nativeApprovals script').count(),0);check('observer approvals disabled and request previews escape HTML');
+await p1.locator('#nativeApprovals button[data-decision="accept"]').click();assert.deepEqual(await command,{decision:'accept'});await wait(p1,()=>!document.querySelector('#nativeApprovals button'));check('manual command approval resolves the original request and removes its card');
+const permissions=ask('permissions','item/permissions/requestApproval',{permissions:{network:{enabled:true},fileSystem:{read:['/read-only'],write:['/write-only']}}});
+await p1.locator('#nativeRead').click();await p1.locator('#nativeApprovals [data-permission="read"]').check();
+await shot(p1,'native-permissions-desktop');
+await p1.locator('#nativeApprovals button[data-decision="accept"]').click();assert.deepEqual(await permissions,{permissions:{fileSystem:{read:['/read-only']}},scope:'turn'});check('permissions submit only selected read path with explicit turn duration');
+const questions=ask('questions','item/tool/requestUserInput',{questions:[{id:'color',header:'Color',question:'Choose color',isOther:true,options:[{label:'Blue',description:'Blue option'},{label:'Red',description:'Red option'}]},{id:'secret',header:'Secret',question:'Private input',isSecret:true}]});
+await p1.locator('#nativeRead').click();await p1.locator('#nativeApprovals button[data-decision="accept"]').click();await wait(p1,()=>document.getElementById('nativeNotice').textContent.includes('answer every question'));assert.equal(interactions.snapshot().length,1);check('unanswered questions remain pending');
+await p1.locator('#nativeApprovals [data-question="0"]').selectOption('other');await p1.locator('#nativeApprovals [data-answer="0"]').fill('Green');await p1.locator('#nativeApprovals [data-answer="1"]').fill('private-qa-answer');
+await p1.locator('#nativeRead').click();assert.equal(await p1.locator('#nativeApprovals [data-answer="0"]').inputValue(),'Green');assert.equal(await p1.locator('#nativeApprovals [data-answer="1"]').inputValue(),'private-qa-answer');check('question draft and secret input survive state refresh without local storage');
+await p1.locator('#nativeApprovals button[data-decision="accept"]').click();const answers=await questions;assert.deepEqual(JSON.parse(JSON.stringify(answers)),{answers:{color:{answers:['Green']},secret:{answers:['private-qa-answer']}}});
+assert.equal(await p1.evaluate(()=>JSON.stringify(localStorage).includes('private-qa-answer')),false);assert.equal(JSON.stringify(await api('GET','/workers/native-qa/state')).includes('private-qa-answer'),false);check('choice/freeform/secret response shape is correct and answers are absent from events/storage');
+const form=ask('mcp-form','mcpServer/elicitation/request',formParams);
+await p1.locator('#nativeRead').click();await p1.locator('#nativeApprovals [data-mcp-field="0"]').waitFor();
+assert.equal(await p1.locator('#nativeApprovals script').count(),0);assert.ok((await p1.locator('#nativeApprovals').innerText()).includes('Project <name>'));
+await p1.locator('#nativeApprovals [data-mcp-field="0"]').fill('private-ui-form');await p1.locator('#nativeApprovals [data-mcp-field="1"]').fill('0');
+await p1.locator('#nativeApprovals [data-mcp-field="2"]').selectOption('1');await p1.locator('#nativeApprovals [data-mcp-field="3"]').selectOption('0');await p1.locator('#nativeApprovals [data-mcp-field="4"][data-mcp-option="1"]').check();
+await p1.locator('#nativeApprovals button[data-decision="accept"]').click();await p1.waitForFunction(()=>document.getElementById('nativeNotice').textContent.includes('Invalid value'));assert.equal(interactions.snapshot().length,1);check('MCP invalid values stay pending and malicious schema labels remain text');
+await p1.locator('#nativeApprovals [data-mcp-field="1"]').fill('2');await p1.locator('#nativeRead').click();assert.equal(await p1.locator('#nativeApprovals [data-mcp-field="0"]').inputValue(),'private-ui-form');assert.equal(await p1.locator('#nativeApprovals [data-mcp-field="4"][data-mcp-option="1"]').isChecked(),true);check('MCP text and multiselect drafts survive state refresh in page memory');
+await p1.evaluate(()=>{document.querySelector('.native-scroll').scrollTop=0;});await shot(p1,'native-mcp-form-desktop');await p1.setViewportSize({width:390,height:844});assert.equal(await p1.evaluate(()=>document.documentElement.scrollWidth<=innerWidth+2),true);await p1.evaluate(()=>{document.querySelector('.native-scroll').scrollTop=0;});await shot(p1,'native-mcp-form-mobile');await p1.locator('#nativeApprovals button[data-decision="accept"]').scrollIntoViewIfNeeded();await shot(p1,'native-mcp-form-mobile-submit');check('MCP form controls fit desktop and mobile viewports');
+await p1.locator('#nativeApprovals button[data-decision="accept"]').click();assert.deepEqual(await form,{action:'accept',content:{name:'private-ui-form',count:2,enabled:false,region:'eu',features:['tests']}});
+assert.equal(await p1.evaluate(()=>JSON.stringify(localStorage).includes('private-ui-form')),false);assert.equal(JSON.stringify(await api('GET','/workers/native-qa/state')).includes('private-ui-form'),false);check('MCP typed response reaches the original native request, optional defaults are omitted and answers are not retained');await p1.setViewportSize({width:1440,height:1000});
+const unsupported=ask('unsupported-url','mcpServer/elicitation/request',{mode:'url',serverName:'form-fixture',message:'Authenticate',url:'https://auth.example.invalid'});await p1.locator('#nativeRead').click();assert.equal(await p1.locator('#nativeApprovals button[data-decision="accept"]').isDisabled(),true);await p1.locator('#nativeApprovals button[data-decision="cancel"]').click();assert.deepEqual(await unsupported,{action:'cancel'});check('MCP URL request missing its elicitation identity has blocked acceptance and usable cancellation');
+const malformed=ask('unsupported-schema','mcpServer/elicitation/request',{...formParams,requestedSchema:{type:'object',properties:{nested:{type:'object'}}}});await p1.locator('#nativeRead').click();assert.equal(await p1.locator('#nativeApprovals button[data-decision="accept"]').isDisabled(),true);await p1.locator('#nativeApprovals button[data-decision="decline"]').click();assert.deepEqual(await malformed,{action:'decline'});check('unsupported MCP schema remains explicitly rejectable');
+// A valid URL flow uses the same controls, with an isolated intercepted destination.
+await a.route('https://auth.example.invalid/device*',route=>route.fulfill({status:200,contentType:'text/html',body:'<title>Synthetic authorization</title><h1>Complete the external flow</h1>'}));
+const urlFlow=ask('url-flow','mcpServer/elicitation/request',{mode:'url',serverName:'form-fixture',message:'Synthetic external authorization',elicitationId:'private-ui-flow',url:'https://auth.example.invalid/device?code=private-ui-url-code'});
+await p1.locator('#nativeRead').click();await p2.locator('#nativeRead').click();
+assert.equal(await p1.locator('#nativeApprovals button[data-decision="accept"]').isEnabled(),true);
+assert.equal(await p2.locator('#nativeApprovals button[data-decision="accept"]').isDisabled(),true);
+assert.equal((await p1.locator('#nativeApprovals').innerText()).includes('private-ui-url-code'),false);
+await p1.evaluate(()=>{window.hccTestOpen=window.open;window.open=()=>null;});
+await p1.locator('#nativeApprovals button[data-decision="accept"]').click();
+await wait(p1,()=>document.getElementById('nativeNotice').textContent.includes('pop-ups'));
+assert.equal(interactions.snapshot().length,1);
+await p1.evaluate(()=>{window.open=window.hccTestOpen;delete window.hccTestOpen;});
+await shot(p1,'native-mcp-url-desktop');
+const popupWait=a.waitForEvent('page');await p1.locator('#nativeApprovals button[data-decision="accept"]').click();const popup=await popupWait;
+await popup.waitForURL('https://auth.example.invalid/device?code=private-ui-url-code');
+assert.deepEqual(await urlFlow,{action:'accept'});assert.equal(await popup.evaluate(()=>window.opener),null);await popup.close();
+const urlState=await api('GET','/workers/native-qa/state');
+assert.equal(JSON.stringify(urlState).includes('private-ui-url-code'),false);assert.equal(JSON.stringify(urlState).includes('private-ui-flow'),false);
+assert.equal(await p1.evaluate(()=>JSON.stringify(localStorage).includes('private-ui-url-code')),false);
+check('valid URL opens only for the controller after exact acceptance; popup blocking preserves the request and links are not retained');
+const takeover=ask('takeover','mcpServer/elicitation/request',{mode:'form',requestedSchema:{type:'object',properties:{enabled:{type:'boolean'}},required:['enabled']}});await p1.locator('#nativeRead').click();await p2.locator('#nativeRead').click();await p2.locator('#claimControlBtn').click();await wait(p2,()=>window.hccHandoff.canControl);await wait(p1,()=>!window.hccHandoff.canControl);
+assert.equal(await p1.locator('#nativeApprovals button[data-decision="accept"]').isDisabled(),true);await p2.locator('#nativeApprovals [data-mcp-field="0"]').selectOption('0');await p2.locator('#nativeApprovals button[data-decision="accept"]').click();assert.deepEqual(await takeover,{action:'accept',content:{enabled:true}});check('lease takeover fences the old browser and enables the new controller');
+const mobile=ask('mobile','item/permissions/requestApproval',{permissions:{network:{enabled:true},fileSystem:{read:['/long/path/with-a-readable-file-name'],write:['/work']}}});
+await p2.setViewportSize({width:390,height:844});await p2.locator('#nativeRead').click();await p2.locator('#nativeApprovals [data-permission="read"]').waitFor();
+assert.equal(await p2.evaluate(()=>document.documentElement.scrollWidth<=innerWidth+2),true);await p2.evaluate(()=>{const el=document.querySelector('.header-controls');el.scrollLeft=el.scrollWidth;});assert.equal(await p2.evaluate(()=>document.getElementById('logoutBtn').getBoundingClientRect().right<=innerWidth),true);await shot(p2,'native-permissions-mobile');await p2.locator('#nativeApprovals button[data-decision="decline"]').click();assert.deepEqual(await mobile,{permissions:{},scope:'turn'});check('mobile permission controls wrap without page overflow and can decline');
+await p1.locator('#openHistoryDialog').click();await p1.locator('#historyThreads [data-thread="qa-thread"]').waitFor();await p1.locator('#historyThreads [data-thread="qa-thread"]').click();await p1.locator('#historyConfirmed').check();await p1.locator('#historyResume').click();await wait(p1,()=>window.hccHandoff.canControl&&window.hccHandoff.session?.type==='app-server');
+await p1.locator('#codexDraft').fill('test interactive permissions');await p1.locator('#codexSend').click();await p1.locator('#codexApprovals [data-permission="network"]').waitFor();await p1.locator('#codexApprovals [data-permission="network"]').check();await shot(p1,'codex-permissions-desktop');await p1.locator('#codexApprovals button[data-decision="accept"]').click();
+await p1.locator('#codexApprovals [data-question="0"]').waitFor();await p1.locator('#codexApprovals [data-question="0"]').selectOption('0');await shot(p1,'codex-question-desktop');await p1.locator('#codexApprovals button[data-decision="accept"]').click();check('Web-owned App Server permissions and userInput use the same form and actual RPC replies');
+await p1.locator('#codexApprovals [data-mcp-field="0"]').waitFor();await p1.locator('#codexApprovals [data-mcp-field="0"]').fill('web-owned-form');await p1.locator('#codexApprovals [data-mcp-field="1"]').fill('3');await p1.locator('#codexApprovals [data-mcp-field="2"]').selectOption('1');await p1.locator('#codexApprovals [data-mcp-field="3"]').selectOption('1');await p1.locator('#codexApprovals [data-mcp-field="4"][data-mcp-option="0"]').check();await shot(p1,'web-owned-mcp-form-desktop');await p1.locator('#codexApprovals button[data-decision="accept"]').click();
+await p1.waitForFunction(()=>document.querySelector('#codexApprovals button[data-decision="cancel"]')&&document.querySelector('#codexApprovals button[data-decision="accept"]')?.disabled);await p1.locator('#codexApprovals button[data-decision="cancel"]').click();await wait(p1,()=>!document.querySelector('#codexApprovals button'));
+const replies=fs.readFileSync(env.HCC_TEST_MCP_RPC,'utf8').trim().split('\n').map(JSON.parse);assert.deepEqual(replies.find(reply=>reply.id===0).result,{action:'accept',content:{name:'web-owned-form',count:3,enabled:false,region:'us',features:['logs']}});assert.deepEqual(replies.find(reply=>reply.id==='mcp-url').result,{action:'cancel'});check('Web-owned MCP forms return typed content to exact RPC id zero and URL mode stays cancellable');
+assert.equal(await p1.evaluate(()=>JSON.stringify(localStorage).includes('web-owned-form')),false);check('Web-owned MCP response is absent from browser storage');
+assert.deepEqual(evidence.pageErrors,[]);assert.deepEqual(evidence.consoleErrors,[]);check('zero page errors or console warnings/errors');evidence.success=true;
+}catch(error){evidence.success=false;evidence.error=error.message;console.error(error);if(browser)for(const context of browser.contexts())for(const page of context.pages())try{await shot(page,'failure-'+browser.contexts().indexOf(context));}catch{}}
+finally{evidence.finishedAt=new Date().toISOString();const after=sourceHashes();evidence.sourceChangesDuringValidation=[...new Set([...Object.keys(evidence.sourceFiles),...Object.keys(after)])].filter(file=>after[file]!==evidence.sourceFiles[file]);if(evidence.sourceChangesDuringValidation.length){evidence.success=false;evidence.error='Source changed during browser validation';}await browser?.close();if(runtime)try{hcc('down');}catch(e){evidence.cleanupError=e.message;}await service?.shutdown();spawnSync(path.join(bin,'tmux'),['kill-server'],{env,stdio:'ignore'});fs.writeFileSync(path.join(dir,'evidence.json'),JSON.stringify(evidence,null,2));fs.writeFileSync('/tmp/hcc-mcp-form-ui-latest.json',JSON.stringify(evidence,null,2));for(const folder of [root,home,bin])fs.rmSync(folder,{recursive:true,force:true});console.log('EVIDENCE '+dir);if(!evidence.success)process.exitCode=1;}