@logicseek/hello-cc 1.0.1 → 1.0.2

package/scripts/web-handoff-installed-acceptance.mjs

@@ -0,0 +1,98 @@
+// Installed Codex protocol and scoped MCP discovery. No model turn, account
+// configuration, or existing task is touched; every file belongs to this run.
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { DatabaseSync } from 'node:sqlite';
+import { fileURLToPath } from 'node:url';
+import { initSchema } from '../lib/db/schema.mjs';
+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 { createCodexSessions } from '../lib/web/codex-sessions.mjs';
+import { createCodexAppServer } from '../lib/web/codex-app-server.mjs';
+import { createScopedMcpConfig } from '../lib/mcp/scope.mjs';
+import { setTimeout as delay } from 'node:timers/promises';
+
+const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-installed-mcp-'));
+const root = path.join(directory, 'project'), codexHome = path.join(directory, 'codex-home');
+fs.mkdirSync(root); fs.mkdirSync(codexHome);
+const ctx = { root, dbPath: path.join(root, 'mesh.db') };
+const connect = () => new DatabaseSync(ctx.dbPath);
+const db = connect(); initSchema(db); db.close();
+const now = () => Math.floor(Date.now() / 1000);
+const events = createEventHelpers({ now }), peers = createPeerHelpers({ now, ...events });
+const bindings = createPeerBindingStore({ now, ...events });
+const sessions = new Map();
+let child;
+const manager = createCodexSessions({ sessions, sessionKey: (context, id) => context.root + '\0' + id,
+  nextProjectSessionId: () => 'installed-mcp-qa', connectWebProject: connect,
+  ...peers, ...bindings, ...events, now, observePeerEvidence: () => ({ state: 'dead' }),
+  broadcast() {}, closeSessionClients() {},
+  mcpConfigFactory: options => createScopedMcpConfig({ ...options,
+    cliPath: fileURLToPath(new URL('../bin/hcc.mjs', import.meta.url)) }),
+  adapterFactory: options => createCodexAppServer({ ...options,
+    env: { ...options.env, CODEX_HOME: codexHome, HCC_SHIM_NO_ATTACH: '1' },
+    spawnProcess: (...args) => { child = spawn(...args); return child; }, requestTimeoutMs: 10000 }) });
+
+let requestSequence = 0;
+function rpc(method, params) {
+  const requestId = 'qa-protocol-' + ++requestSequence;
+  return new Promise((resolve, reject) => {
+    let buffer = '';
+    const cleanup = () => { clearTimeout(timer); child.stdout.off('data', onData); child.off('exit', onExit); };
+    const onExit = () => { cleanup(); reject(new Error('Installed App Server exited before MCP discovery')); };
+    const onData = data => {
+      buffer += data;
+      let newline;
+      while ((newline = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1);
+        let frame; try { frame = JSON.parse(line); } catch { continue; }
+        if (frame.id === requestId) { cleanup(); resolve(frame); }
+      }
+    };
+    const timer = setTimeout(() => { cleanup(); reject(new Error('Scoped MCP discovery timed out')); }, 15000);
+    child.stdout.on('data', onData); child.once('exit', onExit);
+    child.stdin.write(JSON.stringify({ id: requestId, method, params }) + '\n');
+  });
+}
+
+try {
+  const session = await manager.startCodexSession({ kind: 'codex', projectCtx: ctx });
+  let server;
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const frame = await rpc('mcpServerStatus/list', { threadId: session.binding.provider_session_id,
+      serverName: 'hello_cc_scoped', limit: 20 });
+    assert.equal(frame.error, undefined, frame.error?.message);
+    server = (frame.result?.data || []).find(entry => entry.name === 'hello_cc_scoped');
+    if (Object.keys(server?.tools || {}).length) break;
+    await delay(250);
+  }
+  const evidence = { isolatedHome: true, inferenceCalled: false, initialize: 'passed', threadStart: 'passed',
+    userAgent: session.adapter.snapshot().metadata?.userAgent || null,
+    mcpConfigured: Boolean(session.mcpCapability), serverDiscovered: Boolean(server),
+    toolCount: Object.keys(server?.tools || {}).length, serverFields: Object.keys(server || {}),
+    startupStatus: server?.startupStatus || server?.status || null, authStatus: server?.authStatus || null,
+    serverError: server?.error || server?.startupError || null,
+    mcpNotifications: session.adapter.snapshot().events.filter(event => /mcp/i.test(event.method)).map(event => ({ method: event.method,
+      status: event.params.status || null,
+      error: String(event.params.error || '').split(session.mcpCapability.config.env.HCC_MCP_BOOTSTRAP_TOKEN).join('[redacted]') })) };
+  assert.equal(evidence.serverDiscovered, true, 'Installed Codex did not discover its thread-scoped MCP server');
+  assert.equal(evidence.toolCount, 10, 'Installed Codex did not discover all scoped tools');
+  const result = await rpc('mcpServer/tool/call', { threadId: session.binding.provider_session_id,
+    server: 'hello_cc_scoped', tool: 'hcc_state', arguments: {} });
+  assert.equal(result.error, undefined, result.error?.message);
+  assert.equal(result.result.isError, false, 'Installed Codex could not execute a scoped coordination read');
+  assert.equal(result.result.structuredContent.ok, true);
+  assert.equal(result.result.structuredContent.peer, session.peerId);
+  evidence.mcpBusinessRead = 'passed';
+  console.log(JSON.stringify(evidence));
+  const history = await manager.listCodexThreads(ctx, { limit: 5 });
+  assert.ok(Array.isArray(history.threads));
+  console.log('INSTALLED_PROTOCOL_MCP_OK');
+} finally {
+  for (const session of sessions.values()) { await session.adapter?.close(); session.mcpCapability?.dispose(); }
+  fs.rmSync(directory, { recursive: true, force: true });
+}

package/scripts/web-native-interaction-acceptance.mjs

@@ -0,0 +1,204 @@
+// Opt-in, real model + browser acceptance for original native workers.
+// Uses isolated project/provider homes/socket; no query or request injection.
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import net from 'node:net';
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { DatabaseSync } from 'node:sqlite';
+import { setTimeout as delay } from 'node:timers/promises';
+import { initSchema } from '../lib/db/schema.mjs';
+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 { createNativeAdapter } from '../lib/integrations/native/index.mjs';
+import { startNativeService } from '../lib/runtime/native/service.mjs';
+import { nativeRequest } from '../lib/runtime/native/client.mjs';
+
+const args = process.argv.slice(2);
+const option = (name, fallback) => args.includes(name) ? args[args.indexOf(name) + 1] : fallback;
+if (!args.includes('--run-live')) {
+  console.log('Usage: node scripts/web-native-interaction-acceptance.mjs --run-live [--provider codex|claude|all] [--codex-bin PATH] [--claude-package DIR] [--output FILE]');
+  console.log('Set HCC_ACCEPTANCE_PLAYWRIGHT and optionally HCC_ACCEPTANCE_CHROME. Claude uses default SDK resolution; --claude-package links an installed package into the isolated worker project.');
+  process.exit(0);
+}
+const providers = option('--provider', 'codex') === 'all' ? ['codex', 'claude'] : [option('--provider', 'codex')];
+assert.ok(providers.every(value => ['codex', 'claude'].includes(value)), 'unknown provider');
+const repo = fileURLToPath(new URL('..', import.meta.url));
+const directory = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-live-web-interactions-')));
+fs.chmodSync(directory, 0o700);
+const root = path.join(directory, 'project'), bin = path.join(directory, 'bin');
+const codexHome = path.join(directory, 'codex-home'), claudeHome = path.join(directory, 'claude-home');
+const outside = path.join(directory, 'requested-write');
+for (const folder of [root, bin, codexHome, claudeHome, outside, path.join(root, '.hello-cc')]) fs.mkdirSync(folder, { recursive: true, mode: 0o700 });
+const digest = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const originalHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+const protectedFiles = ['config.toml', 'auth.json'].map(name => path.join(originalHome, name)).filter(file => fs.existsSync(file));
+const protectedHashes = protectedFiles.map(file => [file, digest(file)]);
+const sourceHashes = () => Object.fromEntries(['lib/integrations/codex-interactions.mjs', 'lib/integrations/native/codex.mjs', 'lib/integrations/native/claude.mjs', 'lib/integrations/native/interactions.mjs', 'lib/runtime/native/service.mjs', 'lib/web/native-sessions.mjs', 'lib/web/ui-native.mjs', 'lib/web/ui-interactions.mjs', 'scripts/web-native-interaction-acceptance.mjs'].map(name => [name, digest(path.join(repo, name))]));
+const evidence = { startedAt: new Date().toISOString(), directory, sourceFiles: sourceHashes(), providers: {}, checks: [], screenshots: [], pageErrors: [], consoleErrors: [], completed: false,
+  browser: 'Browser plugin not available; isolated installed Chrome and Playwright', modelInferenceCalled: false };
+const output = path.resolve(option('--output', path.join(directory, 'evidence.json')));
+const tmux = process.env.HCC_ACCEPTANCE_TMUX || '/opt/homebrew/bin/tmux';
+const socket = 'hcc-interactions-' + randomUUID();
+const quote = value => "'" + value.replaceAll("'", "'\\''") + "'";
+fs.writeFileSync(path.join(bin, 'tmux'), '#!/bin/sh\nexec ' + quote(tmux) + ' -L ' + quote(socket) + ' "$@"\n', { mode: 0o700 });
+const env = { ...process.env, PATH: bin + ':' + path.dirname(process.execPath) + ':' + process.env.PATH, CODEX_HOME: codexHome,
+  HCC_SHIM_ENSURED: '1', HCC_SHIM_NO_ATTACH: '1', HCC_NO_AUTO_INSTALL_TMUX: '1', HCC_WEB_TOKEN: randomUUID() };
+for (const key of Object.keys(env)) if (key.startsWith('HCC_') && !['HCC_WEB_TOKEN', 'HCC_NO_AUTO_INSTALL_TMUX', 'HCC_SHIM_ENSURED', 'HCC_SHIM_NO_ATTACH'].includes(key)) delete env[key];
+const ctx = { root, dbPath: path.join(root, '.hello-cc', 'mesh.db') };
+const connect = () => { const db = new DatabaseSync(ctx.dbPath); initSchema(db); return db; };
+const events = createEventHelpers(), bindings = createPeerBindingStore(events), peers = createPeerHelpers({ ...events, now: () => Math.floor(Date.now() / 1000) });
+const deps = { ...events, ...bindings, ...peers, ...createMessageStore(events), connect, detectBranch: () => '', liveProcessIdentity: pid => inspectProcessIdentity(pid).identity };
+const api = (method, route, body) => nativeRequest(ctx, method, route, body, { timeoutMs: 30000 });
+function hcc(...params) {
+  const result = spawnSync(process.execPath, [path.join(repo, 'bin/hcc.mjs'), '--root', root, ...params], { cwd: root, env, encoding: 'utf8', timeout: 30000 });
+  if (result.status !== 0) throw new Error('Isolated HCC CLI failed: ' + params[0]);
+}
+function check(name, details = {}) { evidence.checks.push({ name, passed: true, ...details }); console.log('PASS ' + name); }
+async function until(predicate, label, timeout = 180000) {
+  const deadline = Date.now() + timeout; let notice = Date.now() + 20000;
+  while (Date.now() < deadline) {
+    const result = await predicate(); if (result) return result;
+    if (Date.now() >= notice) { console.log('WAIT ' + label); notice += 20000; }
+    await delay(150);
+  }
+  throw new Error('Timed out: ' + label);
+}
+let service, browser, runtimeStarted = false;
+try {
+  assert.ok(fs.existsSync(tmux), 'tmux must be installed');
+  assert.ok(process.env.HCC_ACCEPTANCE_PLAYWRIGHT, 'Set HCC_ACCEPTANCE_PLAYWRIGHT');
+  if (providers.includes('codex')) {
+    const source = fs.readFileSync(path.join(originalHome, 'config.toml'), 'utf8'); let section = '';
+    const config = source.split('\n').filter(line => {
+      const header = line.match(/^\s*\[\[?([^\]]+)\]\]?/); if (header) section = header[1].split('.')[0].replaceAll('"', '').replaceAll("'", '');
+      return section ? section === 'model_providers' : /^\s*(?:model(?:_provider|_reasoning_effort|_reasoning_summary|_verbosity|_catalog_json)?|cli_auth_credentials_store)\s*=/.test(line);
+    }).join('\n');
+    fs.writeFileSync(path.join(codexHome, 'config.toml'), config + '\n', { mode: 0o600 });
+    if (fs.existsSync(path.join(originalHome, 'auth.json'))) { fs.copyFileSync(path.join(originalHome, 'auth.json'), path.join(codexHome, 'auth.json')); fs.chmodSync(path.join(codexHome, 'auth.json'), 0o600); }
+    evidence.providers.codex = { version: spawnSync(option('--codex-bin', '/opt/homebrew/bin/codex'), ['--version'], { env, encoding: 'utf8', timeout: 5000 }).stdout.trim(), featureConfiguration: 'HCC per-thread interactive tool switches; no acceptance-only switches' };
+  }
+  if (providers.includes('claude') && option('--claude-package')) {
+    const installed = fs.realpathSync(option('--claude-package'));
+    const pkg = JSON.parse(fs.readFileSync(path.join(installed, 'package.json'), 'utf8'));
+    assert.equal(pkg.name, '@anthropic-ai/claude-agent-sdk');
+    const scoped = path.join(root, 'node_modules/@anthropic-ai'); fs.mkdirSync(scoped, { recursive: true });
+    fs.symlinkSync(installed, path.join(scoped, 'claude-agent-sdk'), 'dir');
+    evidence.providers.claude = { sdkVersion: pkg.version, dependencyResolution: 'default loader: optional SDK installed in isolated worker project; no query injection' };
+  }
+  hcc('up', '--no-discover', '--no-guidance');
+  service = await startNativeService(ctx, deps, { adapterFactory: (provider, options) => createNativeAdapter(provider, { ...options,
+    env: { ...options.env, ...(provider === 'codex' ? { CODEX_HOME: codexHome } : { CLAUDE_CONFIG_DIR: claudeHome }) } }) });
+  for (const provider of providers) await api('POST', '/workers', { peer: 'live-' + provider, provider, ...(provider === 'codex' ? { binary: option('--codex-bin', '/opt/homebrew/bin/codex') } : {}) });
+  const port = await new Promise(resolve => { const listener = net.createServer(); listener.listen(0, '127.0.0.1', () => { const port = listener.address().port; listener.close(() => resolve(port)); }); });
+  hcc('web', '--local', '--port', String(port), '--no-discover', '--no-guidance'); runtimeStarted = true;
+  const { chromium } = await import(process.env.HCC_ACCEPTANCE_PLAYWRIGHT);
+  browser = await chromium.launch({ headless: true, ...(process.env.HCC_ACCEPTANCE_CHROME ? { executablePath: process.env.HCC_ACCEPTANCE_CHROME } : {}) });
+  const page = await browser.newPage({ viewport: { width: 1440, height: 1000 } });
+  page.on('dialog', dialog => dialog.accept());
+  page.on('pageerror', error => evidence.pageErrors.push(error.message));
+  page.on('console', message => { if (message.type() === 'error') evidence.consoleErrors.push(message.text()); });
+  await page.goto('http://127.0.0.1:' + port + '/?token=' + env.HCC_WEB_TOKEN);
+  async function state(peer) { return api('GET', '/workers/' + peer + '/state'); }
+  async function finish(peer, submission) {
+    return until(async () => {
+      const value = await state(peer), delivery = value.deliveries.find(row => row.submission_id === submission);
+      if (['failed', 'uncertain'].includes(delivery?.state)) throw new Error(peer + ' delivery ended as ' + delivery.state);
+      if (delivery?.state === 'completed') { evidence.modelInferenceCalled = true; return value; }
+      return false;
+    }, peer + ' real model completion');
+  }
+  async function selectPeer(peer) {
+    await page.waitForFunction(() => Boolean(window.hccHandoff?.session), null, { timeout: 15000 });
+    if (await page.evaluate(() => window.hccHandoff.active) !== peer) await page.locator('#sessions [data-id="' + peer + '"] .session-select').click();
+    await page.waitForFunction(peer => window.hccHandoff?.session?.id === peer, peer, { timeout: 15000 });
+    await page.waitForFunction(() => Boolean(window.hccHandoff.actionToken), null, { timeout: 15000 });
+    if (!await page.evaluate(() => window.hccHandoff.canControl)) await page.locator('#claimControlBtn').click();
+    await page.waitForFunction(() => window.hccHandoff.canControl, null, { timeout: 15000 });
+  }
+  async function submit(peer, prompt) {
+    const before = new Set((await state(peer)).deliveries.map(row => row.submission_id));
+    await page.locator('#nativeDraft').fill(prompt); await page.locator('#nativeSend').click();
+    return until(async () => (await state(peer)).deliveries.find(row => row.submission_id.startsWith('s_') && !before.has(row.submission_id)), peer + ' browser submission', 15000);
+  }
+  async function pending(peer, kind) {
+    return until(async () => { const value = await state(peer); const request = value.snapshot.pendingApprovals?.find(request => request.kind === kind); if (request) evidence.modelInferenceCalled = true; return request; }, peer + ' ' + kind);
+  }
+  async function shot(name) { const target = path.join(directory, name + '.png'); await page.screenshot({ path: target }); evidence.screenshots.push(target); }
+  for (const provider of providers) {
+    const peer = 'live-' + provider, result = evidence.providers[provider] ||= {}, allowed = path.join(outside, provider + '-allowed.txt');
+    const denied = path.join(directory, provider + '-denied', 'must-not-exist.txt');
+    fs.mkdirSync(path.dirname(denied), { mode: 0o700 });
+    await selectPeer(peer);
+    if (provider === 'codex') {
+      const delivery = await submit(peer, 'Use request_user_input now to ask me which marker to write: Cobalt or Amber, with those exact option labels. Wait for my choice. Then call request_permissions to request write access only to ' + allowed + '. Wait for approval. After approval write the chosen marker to that exact file and end with INTERACTION_ACCEPTED_OK. Use only bounded file operations. Do not bypass permission checks or use command escalation.');
+      const question = await pending(peer, 'userInput');
+      result.question = { method: question.method, requestId: question.requestId, sessionId: question.sessionId, turnId: question.turnId };
+      await page.locator('#nativeApprovals [data-question="0"]').waitFor({ timeout: 15000 });
+      const choices = await page.locator('#nativeApprovals [data-question="0"] option').allTextContents();
+      const cobalt = choices.findIndex(value => value.includes('Cobalt')); assert.ok(cobalt > 0);
+      await page.locator('#nativeApprovals [data-question="0"]').selectOption(String(cobalt - 1)); await shot('codex-real-question');
+      await page.locator('#nativeApprovals button[data-decision="accept"]').click();
+      const permission = await pending(peer, 'permissions');
+      assert.equal(permission.sessionId, question.sessionId); assert.equal(permission.turnId, question.turnId);
+      const requested = JSON.stringify(permission.params.permissions); assert.ok(requested.includes(allowed));
+      result.permission = { method: permission.method, requestId: permission.requestId, sessionId: permission.sessionId, turnId: permission.turnId, requested: permission.params.permissions };
+      await page.locator('#nativeApprovals [data-scope]').waitFor({ timeout: 15000 });
+      const permissionFields = page.locator('#nativeApprovals input[data-permission]');
+      assert.equal(await permissionFields.count(), 1, 'request must contain only the single bounded filesystem permission');
+      await permissionFields.check(); await page.locator('#nativeApprovals [data-scope]').selectOption('turn'); await shot('codex-real-permission');
+      await page.locator('#nativeApprovals button[data-decision="accept"]').click(); await finish(peer, delivery.submission_id);
+      assert.equal(fs.readFileSync(allowed, 'utf8').trim(), 'Cobalt');
+      result.sessionId = question.sessionId; check('Codex model question and exact turn-scoped permission answered through Web on the original turn');
+      const declined = await submit(peer, 'Call request_permissions for write access only to ' + denied + '. If approval is declined, do not try to write and end normally with INTERACTION_DECLINED_OK. Do not use escalation or any other paths.');
+      const request = await pending(peer, 'permissions'); assert.equal(request.sessionId, result.sessionId);
+      await page.locator('#nativeApprovals button[data-decision="decline"]').waitFor({ timeout: 15000 }); await page.locator('#nativeApprovals button[data-decision="decline"]').click();
+      await finish(peer, declined.submission_id); assert.equal(fs.existsSync(denied), false);
+      check('Codex model respects a declined real filesystem permission');
+    } else {
+      const delivery = await submit(peer, 'Use the Write tool to write exactly CLAUDE_APPROVED_OK to ' + allowed + '. Await the user permission decision. Do not use Bash or any workaround. End normally after the tool result.');
+      const request = await pending(peer, 'approval'); assert.equal(request.method, 'claude/canUseTool'); assert.equal(request.params.tool, 'Write');
+      assert.equal(request.params.input.file_path, allowed); result.permission = { method: request.method, tool: request.params.tool, requestId: request.requestId, turnId: request.turnId };
+      await page.locator('#nativeApprovals button[data-decision="accept"]').waitFor({ timeout: 15000 }); await shot('claude-real-permission');
+      await page.locator('#nativeApprovals button[data-decision="accept"]').click(); await finish(peer, delivery.submission_id);
+      assert.equal(fs.readFileSync(allowed, 'utf8').trim(), 'CLAUDE_APPROVED_OK');
+      result.sessionId = (await state(peer)).snapshot.sessionId; check('Default-loaded Claude SDK real Write approval returns to the original model turn');
+      const declined = await submit(peer, 'Use the Write tool to write CLAUDE_DENIED to ' + denied + '. If permission is declined, do not retry or use any workaround and finish normally.');
+      const refusal = await pending(peer, 'approval'); assert.equal(refusal.params.tool, 'Write'); assert.equal(refusal.params.input.file_path, denied);
+      await page.locator('#nativeApprovals button[data-decision="decline"]').waitFor({ timeout: 15000 }); await page.locator('#nativeApprovals button[data-decision="decline"]').click();
+      await finish(peer, declined.submission_id); assert.equal(fs.existsSync(denied), false); check('Claude model respects a declined real Write operation');
+    }
+    await page.locator('#releaseControlBtn').click(); await page.waitForFunction(() => !window.hccHandoff.canControl);
+    const followup = await api('POST', '/send', { peer, from: 'acceptance-local', submissionId: randomUUID(), body: 'No tool calls. Return INTERACTION_LOCAL_RETURN_OK.' });
+    const after = await finish(peer, followup.submission_id); assert.equal(after.snapshot.sessionId, result.sessionId);
+    result.completed = true; check(provider + ' local return retains original provider session');
+  }
+  assert.deepEqual(evidence.pageErrors, []); assert.deepEqual(evidence.consoleErrors, []);
+  assert.deepEqual(sourceHashes(), evidence.sourceFiles); check('zero browser errors; current implementation unchanged during real acceptance');
+  evidence.completed = true;
+} catch (error) {
+  evidence.error = error.message; process.exitCode = 1; console.error('REAL_INTERACTION_ACCEPTANCE_FAILED: ' + error.message);
+  if (browser) for (const context of browser.contexts()) for (const page of context.pages()) {
+    try { evidence.failureView = await page.evaluate(() => ({ active: window.hccHandoff?.active, canControl: window.hccHandoff?.canControl, sessions: window.hccHandoff?.sessions?.map(value => ({ id: value.id, type: value.type, status: value.status })), notice: document.getElementById('nativeNotice')?.textContent, handoff: document.getElementById('handoffController')?.textContent }));
+      const file = path.join(directory, 'failure.png'); await page.screenshot({ path: file }); evidence.screenshots.push(file);
+    } catch {}
+  }
+} finally {
+  await browser?.close();
+  if (runtimeStarted) { try { hcc('down'); } catch {} }
+  try { await service?.shutdown(); evidence.runtimeClosed = true; } catch (error) { evidence.cleanupError = error.message; process.exitCode = 1; evidence.completed = false; }
+  try { hcc('down'); } catch {}
+  spawnSync(tmux, ['-L', socket, 'kill-server'], { stdio: 'ignore' });
+  evidence.protectedConfigUnchanged = protectedHashes.every(([file, before]) => fs.existsSync(file) && digest(file) === before);
+  if (!evidence.protectedConfigUnchanged) { process.exitCode = 1; evidence.completed = false; }
+  for (const folder of [root, bin, codexHome, claudeHome, outside]) fs.rmSync(folder, { recursive: true, force: true });
+  evidence.temporaryProviderHomesRemoved = !fs.existsSync(codexHome) && !fs.existsSync(claudeHome);
+  evidence.finishedAt = new Date().toISOString(); fs.mkdirSync(path.dirname(output), { recursive: true }); fs.writeFileSync(output, JSON.stringify(evidence, null, 2) + '\n', { mode: 0o600 });
+  console.log(JSON.stringify({ evidence: output, completed: evidence.completed, protectedConfigUnchanged: evidence.protectedConfigUnchanged }));
+}

package/scripts/web-native-model-acceptance.mjs

@@ -0,0 +1,138 @@
+// Opt-in installed-model acceptance. Uses a disposable Codex home, project,
+// tmux socket and browser profile; preserves the original account configuration.
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import net from 'node:net';
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { DatabaseSync } from 'node:sqlite';
+import { setTimeout as delay } from 'node:timers/promises';
+import { initSchema } from '../lib/db/schema.mjs';
+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 { createCodexAdapter } from '../lib/integrations/native/codex.mjs';
+import { JsonRpcProcess } from '../lib/integrations/native/jsonrpc.mjs';
+import { startNativeService } from '../lib/runtime/native/service.mjs';
+import { nativeRequest } from '../lib/runtime/native/client.mjs';
+
+const repo = fileURLToPath(new URL('..', import.meta.url)), cli = path.join(repo, 'bin/hcc.mjs');
+const originalHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+const protectedFiles = ['config.toml', 'auth.json'].map(name => path.join(originalHome, name)).filter(file => fs.existsSync(file));
+const hash = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const protectedHashes = protectedFiles.map(file => [file, hash(file)]);
+const source = fs.readFileSync(path.join(originalHome, 'config.toml'), 'utf8');
+const provider = JSON.parse(source.match(/^model_provider\s*=\s*(".*")\s*$/m)?.[1] || '"openai"');
+const model = JSON.parse(source.match(/^model\s*=\s*(".*")\s*$/m)?.[1] || 'null');
+const directory = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'hcc-live-handoff-')));
+const root = path.join(directory, 'project'), home = path.join(directory, 'codex-home'), bin = path.join(directory, 'bin');
+for (const folder of [root, home, bin, path.join(root, '.hello-cc')]) fs.mkdirSync(folder, { recursive: true, mode: 0o700 });
+const sections = source.split(/(?=^\[)/m), headings = ['model_providers.' + provider, 'model_providers."' + provider + '"'];
+const config = ['model', 'model_provider', 'model_reasoning_effort'].map(key => source.match(new RegExp('^' + key + '\\s*=.*$', 'm'))?.[0]).filter(Boolean);
+for (const section of sections.slice(1)) {
+  const heading = /^\[([^\]]+)\]/.exec(section)?.[1];
+  if (headings.some(prefix => heading === prefix || heading?.startsWith(prefix + '.'))) config.push(section);
+}
+fs.writeFileSync(path.join(home, 'config.toml'), config.join('\n') + '\n', { mode: 0o600 });
+if (fs.existsSync(path.join(originalHome, 'auth.json'))) fs.writeFileSync(path.join(home, 'auth.json'), fs.readFileSync(path.join(originalHome, 'auth.json')), { mode: 0o600 });
+const socket = 'hcc-live-' + randomUUID(), tmux = process.env.HCC_ACCEPTANCE_TMUX || '/opt/homebrew/bin/tmux';
+assert.ok(fs.existsSync(tmux), 'Set HCC_ACCEPTANCE_TMUX to the installed tmux executable');
+fs.writeFileSync(path.join(bin, 'tmux'), '#!/bin/sh\nexec ' + JSON.stringify(tmux) + ' -L ' + JSON.stringify(socket) + ' "$@"\n', { mode: 0o700 });
+const env = { ...process.env, PATH: bin + ':' + path.dirname(process.execPath) + ':' + process.env.PATH,
+  CODEX_HOME: home, HCC_SHIM_ENSURED: '1', HCC_SHIM_NO_ATTACH: '1', HCC_NO_AUTO_INSTALL_TMUX: '1', HCC_WEB_TOKEN: randomUUID() };
+for (const key of Object.keys(env)) if (key.startsWith('HCC_') && !['HCC_WEB_TOKEN','HCC_NO_AUTO_INSTALL_TMUX','HCC_SHIM_ENSURED','HCC_SHIM_NO_ATTACH'].includes(key)) delete env[key];
+function hcc(...args) {
+  const result = spawnSync(process.execPath, [cli, '--root', root, ...args], { cwd: root, env, encoding: 'utf8', timeout: 30000 });
+  if (result.status !== 0) throw new Error('Isolated HCC CLI failed: ' + args[0]);
+  return result.stdout;
+}
+const ctx = { root, dbPath: path.join(root, '.hello-cc', 'mesh.db') };
+const connect = () => { const db = new DatabaseSync(ctx.dbPath); db.exec('PRAGMA busy_timeout=5000'); return db; };
+const db = connect(); initSchema(db); db.close();
+fs.writeFileSync(path.join(root, 'input.json'), JSON.stringify({ value: 41 }));
+const events = createEventHelpers(), bindings = createPeerBindingStore(events), peers = createPeerHelpers({ ...events, now: () => Math.floor(Date.now() / 1000) });
+const deps = { ...events, ...bindings, ...peers, ...createMessageStore(events), connect, detectBranch: () => '',
+  liveProcessIdentity: pid => inspectProcessIdentity(pid).identity };
+const evidence = { model, directory, stages: [], pageErrors: [], consoleErrors: [], screenshots: [], modelInferenceCalled: true,
+  browser: 'Browser plugin not available; isolated Chrome and Playwright', completed: false };
+let service, runtimeStarted = false, browser, child;
+const api = (method, route, body) => nativeRequest(ctx, method, route, body);
+async function complete(submissionId) {
+  const deadline = Date.now() + 180000;
+  while (Date.now() < deadline) {
+    const state = await api('GET', '/workers/live-worker/state');
+    const delivery = state.deliveries.find(row => row.submission_id === submissionId);
+    if (delivery?.state === 'completed') return state;
+    if (['failed', 'uncertain'].includes(delivery?.state)) throw new Error('Model delivery ended in ' + delivery.state);
+    if (state.snapshot.pendingApprovals?.length) throw new Error('Model requested an unexpected interactive operation during bounded file acceptance');
+    await delay(250);
+  }
+  throw new Error('Model continuous-task acceptance timed out');
+}
+function output() { return JSON.parse(fs.readFileSync(path.join(root, 'handoff.json'), 'utf8')); }
+try {
+  hcc('up', '--no-discover', '--no-guidance');
+  service = await startNativeService(ctx, deps, { adapterFactory: (provider, options) => {
+    assert.equal(provider, 'codex');
+    return createCodexAdapter({ ...options, env: { ...options.env, ...env, HCC_PEER: options.env.HCC_PEER, HCC_ROOT: root, HCC_DB: ctx.dbPath, HCC_NATIVE_OWNER: options.executorId },
+      rpcFactory: config => { const rpc = new JsonRpcProcess(config); const start = rpc.start.bind(rpc); rpc.start = async () => { await start(); child = rpc.child; }; return rpc; } });
+  } });
+  const worker = await api('POST', '/workers', { peer: 'live-worker', provider: 'codex' });
+  const identity = { sessionId: worker.sessionId, pid: child.pid };
+  const local = await api('POST', '/send', { peer: 'live-worker', from: 'shell', submissionId: 'live_local_' + randomUUID(), body:
+    'Use the hello_cc_scoped hcc_state MCP tool once. Read input.json. Write handoff.json as JSON with value increased by one and phases ["local"]. Do only these bounded project-file operations. End with LOCAL_PHASE_OK.' });
+  await complete(local.submission_id); assert.deepEqual(output(), { value: 42, phases: ['local'] });
+  evidence.stages.push({ stage: 'local-model-turn', passed: true, ...identity }); console.log('LOCAL_MODEL_PHASE_OK');
+  const port = await new Promise(resolve => { const listener = net.createServer(); listener.listen(0, '127.0.0.1', () => { const port = listener.address().port; listener.close(() => resolve(port)); }); });
+  hcc('web', '--local', '--port', String(port), '--no-discover', '--no-guidance'); runtimeStarted = true;
+  const playwright = process.env.HCC_ACCEPTANCE_PLAYWRIGHT;
+  assert.ok(playwright, 'Set HCC_ACCEPTANCE_PLAYWRIGHT to an installed Playwright module');
+  const { chromium } = await import(playwright);
+  browser = await chromium.launch({ headless: true, ...(process.env.HCC_ACCEPTANCE_CHROME ? { executablePath: process.env.HCC_ACCEPTANCE_CHROME } : {}) });
+  const page = await browser.newPage({ viewport: { width: 1440, height: 1000 } });
+  page.on('pageerror', error => evidence.pageErrors.push(error.message));
+  page.on('console', message => { if (message.type() === 'error') evidence.consoleErrors.push(message.text()); });
+  await page.goto('http://127.0.0.1:' + port + '/?token=' + env.HCC_WEB_TOKEN);
+  await page.waitForFunction(() => window.hccHandoff?.session?.type === 'native' && window.hccHandoff.canControl);
+  assert.equal(await page.locator('#nativePanel').isVisible(), true);
+  await page.locator('#nativeDraft').fill('Continue the same original task. Call hello_cc_scoped hcc_state once. Read handoff.json. Increase value by one, append "web" to phases, and save handoff.json. Do only these project-file operations. End with WEB_PHASE_OK.');
+  await page.locator('#nativeSend').click();
+  await page.waitForFunction(() => window.hccHandoff?.session?.type === 'native' && document.getElementById('nativeReceipts').textContent.includes('s_'));
+  let webDelivery;
+  for (let i = 0; i < 60; i++) { const deliveries = await api('GET', '/deliveries?peer=live-worker'); webDelivery = deliveries.find(row => row.submission_id.startsWith('s_')); if (webDelivery) break; await delay(100); }
+  assert.ok(webDelivery); const afterWeb = await complete(webDelivery.submission_id);
+  assert.deepEqual(output(), { value: 43, phases: ['local','web'] }); assert.equal(afterWeb.snapshot.sessionId, identity.sessionId); assert.equal(child.pid, identity.pid);
+  const screenshot = path.join(directory, 'live-web-task.png'); await page.screenshot({ path: screenshot }); evidence.screenshots.push(screenshot);
+  evidence.stages.push({ stage: 'web-same-executor-model-turn', passed: true, ...identity }); console.log('WEB_SAME_EXECUTOR_PHASE_OK');
+  await page.locator('#releaseControlBtn').click(); await page.waitForFunction(() => !window.hccHandoff.canControl);
+  await browser.close(); browser = null;
+  hcc('down'); runtimeStarted = false;
+  const back = await api('POST', '/send', { peer: 'live-worker', from: 'shell', submissionId: 'live_return_' + randomUUID(), body:
+    'Continue the same task after Web released control. Call hello_cc_scoped hcc_state once. Increase handoff.json value by one, append "local-return" to phases and save. End with LOCAL_RETURN_PHASE_OK.' });
+  const final = await complete(back.submission_id); assert.deepEqual(output(), { value: 44, phases: ['local','web','local-return'] });
+  assert.equal(final.snapshot.sessionId, identity.sessionId); assert.equal(child.pid, identity.pid);
+  evidence.stages.push({ stage: 'local-return-after-web-shutdown', passed: true, ...identity }); evidence.output = output();
+  assert.equal(evidence.pageErrors.length, 0); assert.equal(evidence.consoleErrors.length, 0);
+  const mcpEvents = final.events.filter(event => event.payload?.type === 'item' && event.payload.item?.type === 'mcpToolCall');
+  evidence.mcpToolEvents = mcpEvents.length;
+  evidence.completed = true; console.log('LIVE_LOCAL_WEB_LOCAL_OK');
+} catch (error) {
+  evidence.error = error.message;
+  process.exitCode = 1; console.error('LIVE_HANDOFF_FAILED: ' + error.message);
+} finally {
+  await browser?.close();
+  if (runtimeStarted) { try { hcc('down'); } catch {} }
+  await service?.shutdown();
+  try { hcc('down'); } catch {}
+  spawnSync(tmux, ['-L', socket, 'kill-server'], { stdio: 'ignore' });
+  evidence.protectedConfigUnchanged = protectedHashes.every(([file, original]) => fs.existsSync(file) && hash(file) === original);
+  if (!evidence.protectedConfigUnchanged) { process.exitCode = 1; evidence.completed = false; }
+  fs.writeFileSync(path.join(directory, 'evidence.json'), JSON.stringify(evidence, null, 2));
+  for (const folder of [root, home, bin]) fs.rmSync(folder, { recursive: true, force: true });
+  console.log(JSON.stringify({ evidence: path.join(directory, 'evidence.json'), completed: evidence.completed, protectedConfigUnchanged: evidence.protectedConfigUnchanged }));
+}