@logicseek/hello-cc 1.1.0-rc.1 → 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

@@ -43,7 +43,7 @@ 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:'Isolated installed Chrome + Playwright; browser-extension connectivity is not exercised',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 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});
@@ -51,12 +51,7 @@ const deps={...events,...binding,...peer,...createMessageStore(events),connect:(
 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');
-  // Viewport changes can leave an old compositor frame after layout settles.
-  await page.evaluate(()=>new Promise(resolve=>requestAnimationFrame(()=>requestAnimationFrame(resolve))));
-  await page.screenshot({path:file});evidence.screenshots.push(file);
-};
+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{
@@ -102,6 +97,26 @@ await p1.locator('#nativeApprovals button[data-decision="accept"]').click();asse
 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']}}});

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

@@ -64,7 +64,7 @@ const protectedHashes = protectedFiles.map(file => [file, fs.existsSync(file) ?
 const evidence = { startedAt: new Date().toISOString(), node: process.version, directory, sourceRoot: repo,
   sourceFiles: sourceHashes(), modelInferenceCalled: false, requestInjection: false,
   providerMode: 'installed Codex; real model calls a disposable stdio MCP server; production HCC runtime and browser',
-  browser: 'Isolated installed Chrome and Playwright; browser-extension connectivity is not exercised', checks: [], screenshots: [],
+  browser: 'Browser plugin not available; isolated installed Chrome and Playwright', checks: [], screenshots: [],
   pageErrors: [], consoleErrors: [], completed: false };
 const codexBin = option('--codex-bin', '/opt/homebrew/bin/codex');
 const tmux = process.env.HCC_ACCEPTANCE_TMUX || '/opt/homebrew/bin/tmux';

package/scripts/web-native-handoff-checks.mjs

@@ -0,0 +1,128 @@
+// Browser lifecycle checks against deterministic native adapters, with no model calls.
+import assert from 'node:assert/strict';
+
+export async function runNativeHandoffChecks({ browser, base, token, adaptersByPeer, api, service, select, check, shot, watch, browserInstrumentation, evidence, stopWeb }) {
+  const context = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
+  await context.addInitScript(browserInstrumentation);
+  const peer = 'qa-web-created', submitted = 'Fixture input submitted once before closing Web';
+  const draft = 'Unsent background Agent draft survives page close';
+  const requests = { launch: [], resume: [] };
+  const watchMutations = page => page.on('request', request => {
+    if (request.method() !== 'POST') return;
+    const pathname = new URL(request.url()).pathname;
+    if (pathname === '/api/sessions' && request.postDataJSON()?.id === peer) requests.launch.push(request.postDataJSON());
+    if (pathname === '/api/native/history/' + peer + '/resume') requests.resume.push(request.postDataJSON());
+  });
+  let page = await context.newPage(); watch(page); watchMutations(page);
+  try {
+    evidence.phase = 'Web background Agent creation and lifecycle';
+    await page.goto(base + '/?token=' + token);
+    await select(page, 'qa-codex');
+    await page.locator('#openStartDialog').click();
+    await page.locator('#startDialog').waitFor({ state: 'visible' });
+    await page.waitForFunction(() => !document.getElementById('agentStartBtn').disabled);
+    assert.equal(await page.locator('#kind').inputValue(), 'codex');
+    assert.equal(await page.locator('#transport').inputValue(), 'native');
+    await page.locator('#agentName').fill(peer);
+    await page.locator('#agentStartBtn').click();
+    await page.waitForFunction(peer => window.hccHandoff?.active === peer && window.hccHandoff.canControl &&
+      /(已连接|Connected)$/.test(document.getElementById('handoffConnection').textContent), peer);
+    const initial = await api('GET', '/workers/' + peer + '/state');
+    const serviceBefore = await api('GET', '/status');
+    const original = adaptersByPeer.get(peer);
+    assert.ok(original && initial.owner && initial.snapshot.sessionId);
+    assert.equal(requests.launch.length, 1);
+    assert.equal(requests.launch[0].transport, 'native');
+    assert.equal(original.opens.length, 1);
+    assert.equal(original.sent || 0, 0);
+    await shot(page, 'desktop-web-created-native');
+    check('visible New Agent form creates one independent native worker with the default background interface');
+
+    await page.locator('#nativeDraft').fill(submitted);
+    await page.locator('#nativeSend').click();
+    await page.waitForFunction(() => document.getElementById('nativeDraft').value === '');
+    // The fixture uses a long automatic poll interval; drain the durable queue now.
+    await service.poll();
+    const active = await api('GET', '/workers/' + peer + '/state');
+    assert.equal(original.sent, 1);
+    assert.ok(active.active_delivery && active.snapshot.turnId);
+    await page.locator('#nativeDraft').fill(draft);
+    await page.close();
+    original.emit({ type: 'message', itemId: 'background-live-output', text: 'BACKGROUND_EXECUTOR_CONTINUED_WITHOUT_WEB' });
+    const detached = await api('GET', '/workers/' + peer + '/state');
+    assert.equal(detached.owner, initial.owner);
+    assert.equal(detached.generation, initial.generation);
+    assert.equal(detached.snapshot.sessionId, initial.snapshot.sessionId);
+    assert.equal(detached.snapshot.turnId, active.snapshot.turnId);
+    page = await context.newPage(); watch(page); watchMutations(page);
+    await page.goto(base + '/?token=' + token);
+    await select(page, peer);
+    await page.waitForFunction(() => document.getElementById('nativeEvents').textContent.includes('BACKGROUND_EXECUTOR_CONTINUED_WITHOUT_WEB'));
+    assert.equal(await page.locator('#nativeDraft').inputValue(), draft);
+    assert.equal(original.sent, 1);
+    assert.equal(requests.launch.length, 1);
+    if (!await page.evaluate(() => window.hccHandoff.canControl)) await page.locator('#claimControlBtn').click();
+    await page.waitForFunction(() => window.hccHandoff.canControl);
+    await shot(page, 'desktop-web-reconnected-native');
+    check('closing and reopening Web preserves the new native owner, provider session, active turn and unsent draft without replay');
+
+    original.state.status = 'idle'; original.state.turnId = null;
+    original.emit({ type: 'completed', status: 'completed', turnId: active.snapshot.turnId });
+    await page.locator('#nativeRead').click();
+    await page.waitForFunction(() => document.getElementById('nativeInterrupt').disabled);
+    await page.locator('#nativeCloseConfirmed').check();
+    const closeReply = page.waitForResponse(response => response.request().method() === 'POST' &&
+      new URL(response.url()).pathname === '/api/sessions/' + peer + '/native/close');
+    await page.locator('#nativeClose').click();
+    assert.equal((await closeReply).status(), 200);
+    const closed = (await api('GET', '/status')).workers.find(worker => worker.peer === peer);
+    assert.equal(closed.status, 'closed'); assert.equal(closed.owned, false);
+    await page.locator('#openHistoryDialog').click();
+    await page.locator('#historyThreads [data-thread="' + peer + '"]').click();
+    await page.waitForFunction(() => document.getElementById('historySelected').textContent.includes('qa-web-created') &&
+      !document.getElementById('historyConfirmed').disabled);
+    assert.equal(await page.locator('#historyResume').isDisabled(), true);
+    await page.locator('#historyConfirmed').check();
+    // History confirmation submits restore directly; it does not require a second launch.
+    await page.locator('#historyResume').click();
+    await page.waitForFunction(peer => document.getElementById('startDialog').hidden &&
+      window.hccHandoff?.active === peer && window.hccHandoff.actionToken &&
+      /(已连接|Connected)$/.test(document.getElementById('handoffConnection').textContent), peer);
+    const resumed = await api('GET', '/workers/' + peer + '/state');
+    const replacement = adaptersByPeer.get(peer);
+    assert.notEqual(resumed.owner, initial.owner);
+    assert.equal(resumed.snapshot.sessionId, initial.snapshot.sessionId);
+    assert.equal(resumed.generation, initial.generation);
+    assert.notEqual(replacement, original);
+    assert.equal(replacement.opens.length, 1);
+    assert.equal(replacement.opens[0].sessionId, initial.snapshot.sessionId);
+    assert.equal(replacement.sent || 0, 0);
+    assert.equal(requests.launch.length, 1); assert.equal(requests.resume.length, 1);
+    assert.equal(await page.locator('#nativeNotice').innerText(), '');
+    assert.equal(await page.locator('#nativeCloseConfirmed').isChecked(), false);
+    assert.equal(await page.locator('#nativeDraft').inputValue(), draft);
+    await shot(page, 'desktop-native-history-resumed');
+    check('explicit retained-history confirmation resumes the same provider session in a new native owner without creating or replaying input');
+
+    // Close every Web view before stopping its HTTP service; native has a separate owner.
+    await Promise.all(browser.contexts().map(view => view.close()));
+    await stopWeb();
+    const serviceAfter = await api('GET', '/status');
+    const afterWebShutdown = await api('GET', '/workers/' + peer + '/state');
+    assert.equal(serviceAfter.pid, serviceBefore.pid);
+    assert.equal(serviceAfter.generation, serviceBefore.generation);
+    assert.equal(afterWebShutdown.owner, resumed.owner);
+    assert.equal(afterWebShutdown.snapshot.sessionId, resumed.snapshot.sessionId);
+    evidence.nativeHandoff = { providerMode: 'synthetic native adapter', nativeRuntimePid: serviceAfter.pid,
+      generation: initial.generation, originalOwner: initial.owner, resumedOwner: resumed.owner,
+      providerSessionId: resumed.snapshot.sessionId, launchRequests: requests.launch.length,
+      resumeRequests: requests.resume.length, originalInputs: original.sent, replayedInputs: replacement.sent || 0,
+      webShutdownPreservedNativeRuntime: true };
+    check('Web shutdown keeps the independently owned native runtime and resumed worker alive');
+  } catch (error) {
+    evidence.nativeHandoffFailure = { requests, message: error.message, current: page.isClosed() ? null : await page.evaluate(() => ({ active: window.hccHandoff?.active, project: window.hccHandoff?.projectRoot, canControl: window.hccHandoff?.canControl, startError: document.getElementById('startDialogError').textContent, startHidden: document.getElementById('startDialog').hidden })) };
+    evidence.nativeHandoffFailure.runtime = await api('GET', '/status');
+    if (!page.isClosed()) await shot(page, 'native-handoff-failure');
+    throw error;
+  } finally { await context.close(); }
+}