@p10i/create-nestbox 0.4.0 → 0.5.0

package/tests/host-runner.mjs

@@ -1,64 +1,111 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { createServer } from 'node:http';
 import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const fixture = await mkdtemp(join(tmpdir(), 'nestbox-host-runner-'));
-const tokenFixture = await mkdtemp(join(tmpdir(), 'nestbox-host-token-'));
 const testDirectory = dirname(fileURLToPath(import.meta.url));
 const runnerPath = resolve(testDirectory, '..', 'host-runner.mjs');
-const token = 'test-token-'.padEnd(64, 'x');
-const jobs = [];
-const results = new Map();
-const resultAttempts = new Map();
+const fakeBridge = join(fixture, 'fake-docker.mjs');
+const jobPath = join(fixture, 'bridge-job.json');
+const resultPath = join(fixture, 'bridge-result.json');
+const invocationPath = join(fixture, 'invocations.jsonl');
+const ackPath = join(fixture, 'acked-marker');
 let runner;
 let runnerStdout = '';
-let heartbeatConflicts = 1;
 
-function readBody(request) {
-  return new Promise((resolveBody, reject) => {
-    const chunks = [];
-    request.on('data', chunk => chunks.push(chunk));
-    request.on('end', () => { try { resolveBody(JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}')); } catch (error) { reject(error); } });
-    request.on('error', reject);
-  });
+const fakeSource = String.raw`
+import { appendFileSync, existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+appendFileSync(process.env.FAKE_INVOCATIONS, JSON.stringify({ args: process.argv.slice(2), cwd: process.cwd() }) + '\n');
+const messages = [];
+let waiter, ended = false, input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  input += chunk;
+  let newline;
+  while ((newline = input.indexOf('\n')) >= 0) {
+    const line = input.slice(0, newline); input = input.slice(newline + 1);
+    if (line) messages.push(JSON.parse(line));
+    if (waiter) { const resolve = waiter; waiter = null; resolve(); }
+  }
+});
+process.stdin.on('end', () => { ended = true; if (waiter) waiter(); });
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+async function receive() {
+  while (!messages.length && !ended) await new Promise(resolve => waiter = resolve);
+  if (!messages.length) return null;
+  return messages.shift();
 }
-
-const server = createServer(async (request, response) => {
-  if (request.headers.authorization !== `Bearer ${token}` || !request.headers['x-nestbox-runner-id']) {
-    response.writeHead(401).end('{"error":"unauthorized"}'); return;
+function send(value) { process.stdout.write(JSON.stringify({ protocolVersion: 1, ...value }) + '\n'); }
+const hello = await receive();
+if (hello?.type !== 'hello') process.exit(2);
+if (hello.retainedResult) {
+  if (hello.retainedResult.jobId === 'job-rejected') {
+    writeFileSync(process.env.FAKE_REJECTED, 'terminal');
+    send({ type: 'result.rejected', jobId: hello.retainedResult.jobId, error: 'conflicting host result replay' });
+  } else {
+    if (existsSync(process.env.FAKE_JOB)) unlinkSync(process.env.FAKE_JOB);
+    writeFileSync(process.env.FAKE_RESULT, JSON.stringify(hello.retainedResult));
+    send({ type: 'result.ack', jobId: hello.retainedResult.jobId, duplicate: true });
+    await sleep(25);
+    writeFileSync(process.env.FAKE_RECONCILED, hello.retainedResult.jobId);
+    writeFileSync(process.env.FAKE_ACKED + '.' + hello.retainedResult.jobId, hello.retainedResult.jobId);
   }
-  if (request.method === 'POST' && request.url === '/_nestbox/host/heartbeat') {
-    if (heartbeatConflicts > 0) { heartbeatConflicts -= 1; response.writeHead(409).end('{"error":"another host runner is active"}'); return; }
-    await readBody(request); response.writeHead(200, { 'content-type': 'application/json' }).end('{"ok":true}'); return;
+}
+send({ type: 'ready' });
+while (!ended) {
+  if (!existsSync(process.env.FAKE_JOB)) { send({ type: 'idle' }); await sleep(50); continue; }
+  const job = JSON.parse(readFileSync(process.env.FAKE_JOB, 'utf8'));
+  send({ type: 'job', job });
+  if (job.jobId === 'job-inflight' && !existsSync(process.env.FAKE_INFLIGHT)) {
+    writeFileSync(process.env.FAKE_INFLIGHT, 'disconnected');
+    process.exit(76);
   }
-  if (request.method === 'GET' && request.url.startsWith('/_nestbox/host/jobs/next')) {
-    const job = jobs.shift();
-    if (!job) { response.writeHead(204).end(); return; }
-    response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(job)); return;
+  const message = await receive();
+  if (!message) break;
+  if (message.type !== 'result' || message.result?.jobId !== job.jobId) process.exit(3);
+  if (job.jobId === 'job-retry' && !existsSync(process.env.FAKE_RETRY)) {
+    writeFileSync(process.env.FAKE_RETRY, 'attempted');
+    writeFileSync(process.env.FAKE_RESULT, JSON.stringify(message.result));
+    unlinkSync(process.env.FAKE_JOB);
+    process.exit(75);
   }
-  const match = request.url.match(/^\/_nestbox\/host\/jobs\/([^/]+)\/result$/);
-  if (request.method === 'POST' && match) {
-    const jobId = decodeURIComponent(match[1]);
-    const result = await readBody(request);
-    const attempt = (resultAttempts.get(jobId) || 0) + 1;
-    resultAttempts.set(jobId, attempt);
-    if (jobId === 'job-retry' && attempt === 1) { response.writeHead(503).end('{"error":"restarting"}'); return; }
-    results.set(jobId, result);
-    response.writeHead(202, { 'content-type': 'application/json' }).end('{"accepted":true}'); return;
+  if (job.jobId === 'job-rejected' && !existsSync(process.env.FAKE_REJECT)) {
+    writeFileSync(process.env.FAKE_REJECT, 'accepted-without-ack');
+    unlinkSync(process.env.FAKE_JOB);
+    process.exit(77);
   }
-  response.writeHead(404).end();
-});
+  unlinkSync(process.env.FAKE_JOB);
+  writeFileSync(process.env.FAKE_RESULT, JSON.stringify(message.result));
+  send({ type: 'result.ack', jobId: job.jobId });
+  await sleep(25);
+  writeFileSync(process.env.FAKE_ACKED + '.' + job.jobId, job.jobId);
+}
+`;
 
-async function waitForResult(jobId, timeout = 10000) {
+async function waitFor(path, timeout = 10000) {
   const deadline = Date.now() + timeout;
   while (Date.now() < deadline) {
-    if (results.has(jobId)) return results.get(jobId);
+    if (existsSync(path)) return;
     await new Promise(resolveWait => setTimeout(resolveWait, 25));
   }
-  throw new Error(`Timed out waiting for result ${jobId}`);
+  throw new Error(`Timed out waiting for ${path}`);
+}
+
+async function submit(job) {
+  const jobAckPath = `${ackPath}.${job.jobId}`;
+  await rm(resultPath, { force: true });
+  await rm(jobAckPath, { force: true });
+  await writeFile(jobPath, JSON.stringify({ schemaVersion: 1, ...job }));
+  await waitFor(resultPath);
+  const result = JSON.parse(await readFile(resultPath, 'utf8'));
+  if (job.jobId !== 'job-retry') {
+    await waitFor(jobAckPath);
+    if (await readFile(jobAckPath, 'utf8') !== job.jobId) throw new Error(`Unexpected acknowledgement for ${job.jobId}.`);
+  }
+  return result;
 }
 
 async function waitForEvent(type, requestId, timeout = 10000) {
@@ -66,32 +113,41 @@ async function waitForEvent(type, requestId, timeout = 10000) {
   while (Date.now() < deadline) {
     for (const line of runnerStdout.split(/\r?\n/).filter(Boolean)) {
       const event = JSON.parse(line);
-      if (event.type === type && (!requestId || event.requestId === requestId)) return event;
+      if (event.type === type && (!requestId || event.requestId === requestId || event.jobId === requestId)) return event;
     }
     await new Promise(resolveWait => setTimeout(resolveWait, 25));
   }
   throw new Error(`Timed out waiting for event ${type}`);
 }
 
-function submit(job) { jobs.push({ schemaVersion: 1, ...job }); return waitForResult(job.jobId); }
-
 try {
+  await writeFile(fakeBridge, fakeSource);
   await writeFile(join(fixture, 'package.json'), JSON.stringify({
     private: true,
     scripts: {
       host: 'node host-runner.mjs',
       ok: `node -e "process.stdout.write('host-ok')"`,
       fail: `node -e "process.stderr.write('host-failed'); process.exit(7)"`,
+      delayed: `node -e "setTimeout(() => require('fs').appendFileSync('executions', 'x'), 300)"`,
     },
   }));
-  const tokenPath = join(tokenFixture, 'host-token');
-  await writeFile(tokenPath, `${token}\n`);
-  await new Promise((resolveListen, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolveListen); });
-  const port = server.address().port;
-  runner = spawn(process.execPath, [runnerPath, '--json'], {
-    env: { ...process.env, npm_execpath: '', NESTBOX_HOST_WORKSPACE: fixture, NESTBOX_CONTROL_HOST_URL: `http://127.0.0.1:${port}/_nestbox`, NESTBOX_HOST_TOKEN_FILE: tokenPath, NESTBOX_HOST_TOKEN: '' },
-    stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true,
-  });
+  const environment = {
+    ...process.env,
+    npm_execpath: '',
+    NESTBOX_HOST_WORKSPACE: fixture,
+    NESTBOX_HOST_DOCKER: process.execPath,
+    NESTBOX_HOST_DOCKER_ARGS: JSON.stringify([fakeBridge]),
+    FAKE_JOB: jobPath,
+    FAKE_RESULT: resultPath,
+    FAKE_RETRY: join(fixture, 'retry-marker'),
+    FAKE_RECONCILED: join(fixture, 'reconciled-marker'),
+    FAKE_REJECT: join(fixture, 'reject-marker'),
+    FAKE_REJECTED: join(fixture, 'rejected-marker'),
+    FAKE_ACKED: ackPath,
+    FAKE_INFLIGHT: join(fixture, 'inflight-marker'),
+    FAKE_INVOCATIONS: invocationPath,
+  };
+  runner = spawn(process.execPath, [runnerPath, '--json'], { env: environment, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
   let runnerStderr = '';
   runner.stdout.on('data', chunk => runnerStdout += chunk); runner.stderr.on('data', chunk => runnerStderr += chunk);
   await waitForEvent('runner.ready');
@@ -101,12 +157,27 @@ try {
   if (success.exitCode !== 0 || !success.stdout.includes('host-ok') || !success.hostPlatform) throw new Error('Successful host result was not preserved.');
   if (failure.exitCode !== 7 || !failure.stderr.includes('host-failed')) throw new Error('Failed host result was not preserved.');
   const retried = await submit({ jobId: 'job-retry', type: 'npm.run', script: 'ok', args: [] });
-  if (retried.exitCode !== 0 || resultAttempts.get('job-retry') !== 2) throw new Error('Host result was not retried after a transient control failure.');
+  if (retried.exitCode !== 0) throw new Error('Pending result was not replayed after bridge disconnect.');
+  await waitFor(environment.FAKE_RECONCILED);
+  if (await readFile(environment.FAKE_RECONCILED, 'utf8') !== 'job-retry') throw new Error('Ack-lost result was not reconciled before polling.');
+  const inFlight = await submit({ jobId: 'job-inflight', type: 'npm.run', script: 'delayed', args: [] });
+  const executions = await readFile(join(fixture, 'executions'), 'utf8');
+  if (inFlight.exitCode !== 0 || executions !== 'x') throw new Error(`In-flight host job was duplicated across bridge reconnect: exit=${inFlight.exitCode} executions=${executions}.`);
+
+  await writeFile(jobPath, JSON.stringify({ schemaVersion: 1, jobId: 'job-rejected', type: 'npm.run', script: 'ok', args: [] }));
+  try { await waitFor(environment.FAKE_REJECTED); }
+  catch (error) { throw new Error(`${error.message}; accepted=${existsSync(environment.FAKE_REJECT)} job=${existsSync(jobPath)} result=${existsSync(resultPath) ? await readFile(resultPath, 'utf8') : 'none'}\n${runnerStdout}\n${runnerStderr}`); }
+  const rejected = await waitForEvent('runner.error', 'job-rejected');
+  if (!rejected.error.includes('conflicting host result replay')) throw new Error('Terminal result rejection was not reported.');
+  const afterRejected = await submit({ jobId: 'job-after-rejected', type: 'npm.run', script: 'ok', args: [] });
+  if (afterRejected.exitCode !== 0) throw new Error('Terminal result rejection was retried instead of cleared.');
 
   const requestId = 'npm-script-request-test-add';
-  const requestedPromise = submit({ jobId: requestId, type: 'npm.scripts.request', requestId, operation: 'add', name: 'approved', command: `node -e "process.stdout.write('approved')"` });
+  await rm(resultPath, { force: true });
+  await writeFile(jobPath, JSON.stringify({ schemaVersion: 1, jobId: requestId, type: 'npm.scripts.request', requestId, operation: 'add', name: 'approved', command: `node -e "process.stdout.write('approved')"` }));
   const event = await waitForEvent('npm.scripts.confirmation_required', requestId);
-  const requested = await requestedPromise;
+  await waitFor(resultPath);
+  const requested = JSON.parse(await readFile(resultPath, 'utf8'));
   if (requested.status !== 'confirmation_required' || Object.hasOwn(requested, 'code')) throw new Error('Script request exposed its confirmation code.');
   const confirmed = await submit({ jobId: 'confirm-add', type: 'npm.scripts.confirm', requestId, code: event.code });
   const changed = JSON.parse(await readFile(join(fixture, 'package.json'), 'utf8'));
@@ -115,29 +186,30 @@ try {
   const protectedResult = await submit({ jobId: 'protected-host', type: 'npm.scripts.request', requestId: 'protected-host', operation: 'delete', name: 'host' });
   if (protectedResult.exitCode !== 1 || !protectedResult.stderr.includes('cannot be changed')) throw new Error('Core host script was not protected.');
 
+  const invocations = (await readFile(invocationPath, 'utf8')).trim().split(/\r?\n/).map(JSON.parse);
+  if (invocations.length < 2 || invocations.some(value => value.cwd !== dirname(runnerPath))) throw new Error('Docker CLI did not run from the installation directory.');
+  const expected = ['compose', 'exec', '-T', 'control', '/usr/local/bin/nestbox-host-bridge'];
+  if (!invocations.every(value => expected.every((part, index) => value.args[index] === part))) throw new Error('Docker Compose bridge arguments were incorrect.');
+
   const exit = new Promise((resolveExit, reject) => { runner.on('error', reject); runner.on('close', code => code === 0 || code === null ? resolveExit() : reject(new Error(`Runner exited ${code}: ${runnerStderr}`))); });
   runner.kill('SIGTERM'); await exit; runner = undefined;
 
-  const onceRunner = spawn(process.execPath, [runnerPath, '--once', '--json'], {
-    env: { ...process.env, npm_execpath: '', NESTBOX_HOST_WORKSPACE: fixture, NESTBOX_CONTROL_HOST_URL: `http://127.0.0.1:${port}/_nestbox`, NESTBOX_HOST_TOKEN_FILE: tokenPath, NESTBOX_HOST_TOKEN: '' },
-    stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true,
-  });
+  const onceRunner = spawn(process.execPath, [runnerPath, '--once', '--json'], { env: environment, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
   const onceExit = await Promise.race([
     new Promise(resolveExit => onceRunner.once('close', resolveExit)),
     new Promise((_, reject) => setTimeout(() => reject(new Error('--once runner did not exit after an empty poll.')), 5000)),
   ]);
   if (onceExit !== 0) throw new Error(`--once runner exited ${onceExit}.`);
 
-  const unsafeToken = join(fixture, 'unsafe-token');
-  await writeFile(unsafeToken, `${token}\n`);
-  const unsafe = spawnSync(process.execPath, [runnerPath, '--once'], {
-    env: { ...process.env, NESTBOX_HOST_WORKSPACE: fixture, NESTBOX_CONTROL_HOST_URL: `http://127.0.0.1:${port}/_nestbox`, NESTBOX_HOST_TOKEN_FILE: unsafeToken, NESTBOX_HOST_TOKEN: '' }, encoding: 'utf8', windowsHide: true,
+  const stale = spawnSync(process.execPath, [runnerPath, '--once'], {
+    env: { ...environment, NESTBOX_HOST_DOCKER_ARGS: JSON.stringify(['-e', `process.stderr.write('nestbox-host-bridge: not found\\n'); process.exit(127)`]) },
+    encoding: 'utf8',
+    windowsHide: true,
+    timeout: 5000,
   });
-  if (unsafe.status === 0 || !unsafe.stderr.includes('must be outside')) throw new Error('Runner accepted a token inside the workspace.');
-  console.log('Host runner HTTP tests passed.');
+  if (stale.status !== 1 || !stale.stderr.includes('docker compose build control')) throw new Error('Stale control image error was not actionable or terminal.');
+  console.log('Host runner stdio transport tests passed.');
 } finally {
   runner?.kill('SIGTERM');
-  await new Promise(resolveClose => server.close(resolveClose));
   await rm(fixture, { recursive: true, force: true });
-  await rm(tokenFixture, { recursive: true, force: true });
 }

package/tests/nestbox.ps1

@@ -91,11 +91,6 @@ function Invoke-Http([string]$Path, [string]$HostHeader = '', [string]$Method =
 
 try {
     New-Item -ItemType Directory -Path $TempDirectory | Out-Null
-    $configuredTokenFile = [regex]::Match([IO.File]::ReadAllText((Join-Path $Root '.env')), '(?m)^NESTBOX_HOST_TOKEN_FILE=(.+)$').Groups[1].Value.Trim()
-    if (-not $env:NESTBOX_HOST_TOKEN_FILE -and -not $configuredTokenFile) {
-        $env:NESTBOX_HOST_TOKEN_FILE = Join-Path $TempDirectory 'host-token'
-        [IO.File]::WriteAllText($env:NESTBOX_HOST_TOKEN_FILE, 'test-token-' + ('0' * 54))
-    }
 
     if (Get-Command docker -ErrorAction SilentlyContinue) { Pass 'docker is available' } else { Fail 'docker is required'; throw 'Missing Docker' }
     if (Get-Command curl.exe -ErrorAction SilentlyContinue) { Pass 'curl.exe is available' } else { Fail 'curl.exe is required'; throw 'Missing curl.exe' }
@@ -126,7 +121,7 @@ try {
     $openCodeConfig = [IO.File]::ReadAllText((Join-Path $Root 'home\configs\opencode\opencode.json'))
     if ($openCodeConfig.Contains('"instance.md"')) { Pass 'OpenCode loads instance policy directly' } else { Fail 'OpenCode does not load instance policy' }
     if ($openCodeConfig.Contains('"control"')) { Pass 'OpenCode registers the control MCP' } else { Fail 'OpenCode does not register the control MCP' }
-    if ((Test-Path -LiteralPath (Join-Path $Root 'docker\control\server.py')) -and (Test-Path -LiteralPath (Join-Path $Root 'host-runner.mjs'))) { Pass 'Control and host runner sources exist' } else { Fail 'Control or host runner source is missing' }
+    if ((Test-Path -LiteralPath (Join-Path $Root 'docker\control\server.py')) -and (Test-Path -LiteralPath (Join-Path $Root 'docker\control\host_bridge.py')) -and (Test-Path -LiteralPath (Join-Path $Root 'host-runner.mjs'))) { Pass 'Control and host runner sources exist' } else { Fail 'Control or host runner source is missing' }
 
     $result = Invoke-Compose @('config', '--quiet') -Quiet
     if ($result.Code -eq 0) { Pass 'Compose configuration is valid' } else { Fail 'Compose configuration is invalid' }
@@ -254,14 +249,14 @@ try {
     if ($null -eq $controlInspect.NetworkSettings.Ports.'4088/tcp') { Pass 'Control API is not published on the host' } else { Fail 'Control API is published on the host' }
     $runnerBinding = $controlInspect.NetworkSettings.Ports.'4089/tcp'
     if ($null -eq $runnerBinding) { Pass 'Host runner API is not published separately' } else { Fail 'Host runner API is published separately' }
+    if ($null -eq $controlInspect.Config.ExposedPorts.'4089/tcp') { Pass 'Host runner API is not exposed by the control image' } else { Fail 'Host runner API is exposed by the control image' }
     $response = Invoke-Http '/_nestbox/host/health'
-    if ($response.Status -eq 401) { Pass 'Nginx routes the authenticated host runner API' } else { Fail "Host runner gateway returned HTTP $($response.Status) instead of 401" }
+    if ($response.Status -eq 404) { Pass 'Public host runner path is unavailable' } else { Fail "Host runner gateway returned HTTP $($response.Status) instead of 404" }
     $openCodeId = Get-ContainerId 'opencode'
     $openCodeInspect = @(& docker inspect $openCodeId 2>$null | ConvertFrom-Json)[0]
     if (@($openCodeInspect.Mounts.Destination) -notcontains '/var/run/docker.sock') { Pass 'OpenCode does not receive the Docker socket' } else { Fail 'OpenCode receives the Docker socket' }
-    if (@($openCodeInspect.Mounts.Destination) -notcontains '/run/secrets/nestbox-host-token' -and @($openCodeInspect.Config.Env) -notmatch '^NESTBOX_HOST_TOKEN=') { Pass 'OpenCode cannot read the host runner token' } else { Fail 'OpenCode can read the host runner token' }
     if (@($controlInspect.Mounts.Destination) -contains '/var/run/docker.sock') { Pass 'Control receives the Docker socket' } else { Fail 'Control does not receive the Docker socket' }
-    if (@($controlInspect.Mounts.Destination) -contains '/run/secrets/nestbox-host-token') { Pass 'Control receives the host runner token file' } else { Fail 'Control does not receive the host runner token file' }
+    if (@($controlInspect.Mounts.Destination) -notcontains '/run/secrets/nestbox-host-token' -and @($controlInspect.Config.Env) -notmatch '^NESTBOX_HOST_TOKEN') { Pass 'Control has no host token mount or environment' } else { Fail 'Control still has host token configuration' }
 
     if ($indexPresent) {
         $result = Invoke-Compose @('exec', '-T', 'php-fpm', 'php', '-l', '/home/code/index.php') -Quiet

package/tests/nestbox.sh

@@ -141,8 +141,6 @@ else
 fi
 
 TEMP_DIR="$(mktemp -d "${TMPDIR:-/tmp}/nestbox-test.XXXXXX")"
-configured_token_file="$(sed -n 's/^NESTBOX_HOST_TOKEN_FILE=//p' "$ROOT/.env" | tail -n 1)"
-if [[ -z "${NESTBOX_HOST_TOKEN_FILE:-}" && -z "$configured_token_file" ]]; then export NESTBOX_HOST_TOKEN_FILE="$TEMP_DIR/host-token"; printf 'test-token-%054d\n' 0 >"$NESTBOX_HOST_TOKEN_FILE"; fi
 
 [[ -f "$ROOT/.env" ]] && pass '.env exists' || fail '.env is missing'
 [[ ! -d "$ROOT/home/.git" ]] && pass 'Page and configuration tree has no embedded Git repository' || fail 'home/.git must not be included in an installation'
@@ -163,7 +161,7 @@ grep -Fq 'Commit policy:' "$ROOT/home/configs/opencode/instance.md" && pass 'Ope
 grep -Fq 'Communication language:' "$ROOT/home/configs/opencode/instance.md" && pass 'OpenCode instance policy records communication language' || fail 'OpenCode instance policy omits communication language'
 grep -Fq '"instance.md"' "$ROOT/home/configs/opencode/opencode.json" && pass 'OpenCode loads instance policy directly' || fail 'OpenCode does not load instance policy'
 grep -Fq '"control"' "$ROOT/home/configs/opencode/opencode.json" && pass 'OpenCode registers the control MCP' || fail 'OpenCode does not register the control MCP'
-[[ -f "$ROOT/docker/control/server.py" && -f "$ROOT/host-runner.mjs" ]] && pass 'Control and host runner sources exist' || fail 'Control or host runner source is missing'
+[[ -f "$ROOT/docker/control/server.py" && -f "$ROOT/docker/control/host_bridge.py" && -f "$ROOT/host-runner.mjs" ]] && pass 'Control and host runner sources exist' || fail 'Control or host runner source is missing'
 
 if compose config --quiet; then
     pass 'Compose configuration is valid'
@@ -349,16 +347,17 @@ control_binding="$(docker inspect --format '{{json (index .NetworkSettings.Ports
 [[ -z "$control_binding" || "$control_binding" == "null" ]] && pass 'Control API is not published on the host' || fail 'Control API is published on the host'
 runner_binding="$(docker inspect --format '{{json (index .NetworkSettings.Ports "4089/tcp")}}' "$control_id" 2>/dev/null || true)"
 [[ -z "$runner_binding" || "$runner_binding" == "null" ]] && pass 'Host runner API is not published separately' || fail 'Host runner API is published separately'
+runner_exposed="$(docker inspect --format '{{json (index .Config.ExposedPorts "4089/tcp")}}' "$control_id" 2>/dev/null || true)"
+[[ -z "$runner_exposed" || "$runner_exposed" == "null" ]] && pass 'Host runner API is not exposed by the control image' || fail 'Host runner API is exposed by the control image'
 status="$(http_request '/_nestbox/host/health' 2>/dev/null || printf '000')"
-[[ "$status" == "401" ]] && pass 'Nginx routes the authenticated host runner API' || fail "Host runner gateway returned HTTP $status instead of 401"
+[[ "$status" == "404" ]] && pass 'Public host runner path is unavailable' || fail "Host runner gateway returned HTTP $status instead of 404"
 opencode_id="$(container_id opencode)"
 opencode_mounts="$(docker inspect --format '{{range .Mounts}}{{println .Source .Destination}}{{end}}' "$opencode_id" 2>/dev/null || true)"
 grep -Fq '/var/run/docker.sock' <<<"$opencode_mounts" && fail 'OpenCode receives the Docker socket' || pass 'OpenCode does not receive the Docker socket'
-opencode_env="$(docker inspect --format '{{range .Config.Env}}{{println .}}{{end}}' "$opencode_id" 2>/dev/null || true)"
-if ! grep -Fq '/run/secrets/nestbox-host-token' <<<"$opencode_mounts" && ! grep -Eq '^NESTBOX_HOST_TOKEN=' <<<"$opencode_env"; then pass 'OpenCode cannot read the host runner token'; else fail 'OpenCode can read the host runner token'; fi
 control_mounts="$(docker inspect --format '{{range .Mounts}}{{println .Source .Destination}}{{end}}' "$control_id" 2>/dev/null || true)"
 grep -Fq '/var/run/docker.sock' <<<"$control_mounts" && pass 'Control receives the Docker socket' || fail 'Control does not receive the Docker socket'
-grep -Fq '/run/secrets/nestbox-host-token' <<<"$control_mounts" && pass 'Control receives the host runner token file' || fail 'Control does not receive the host runner token file'
+control_env="$(docker inspect --format '{{range .Config.Env}}{{println .}}{{end}}' "$control_id" 2>/dev/null || true)"
+if ! grep -Fq '/run/secrets/nestbox-host-token' <<<"$control_mounts" && ! grep -Eq '^NESTBOX_HOST_TOKEN' <<<"$control_env"; then pass 'Control has no host token mount or environment'; else fail 'Control still has host token configuration'; fi
 
 if ((INDEX_PRESENT)); then
     if compose exec -T php-fpm php -l /home/code/index.php >/dev/null 2>&1; then