@p10i/create-nestbox 0.3.0 → 0.5.0

package/docker-compose.yaml

@@ -114,9 +114,6 @@ services:
       dockerfile: ./docker/control/Dockerfile
     expose:
       - "4088"
-    ports:
-      # Authenticated native runner transport; never bind beyond loopback.
-      - "127.0.0.1:${NESTBOX_CONTROL_HOST_PORT:-4089}:4089"
     volumes:
       - ${DOCKER_SOCKET_PATH:-/var/run/docker.sock}:/var/run/docker.sock
       - type: bind
@@ -125,17 +122,9 @@ services:
         read_only: true
         bind:
           create_host_path: false
-      - type: bind
-        source: ${NESTBOX_HOST_TOKEN_FILE:?NESTBOX_HOST_TOKEN_FILE must be configured}
-        target: /run/secrets/nestbox-host-token
-        read_only: true
-        bind:
-          create_host_path: false
     environment:
       - COMPOSE_PROJECT_NAME=${COMPOSE_PROJECT_NAME}
       - NESTBOX_CONTROL_SERVICE=control
-      - NESTBOX_CONTROL_HOST_PORT=4089
-      - NESTBOX_HOST_TOKEN_FILE=/run/secrets/nestbox-host-token
       - NESTBOX_CONTROL_LOG_OUTPUT=${NESTBOX_CONTROL_LOG_OUTPUT:-text}
       - NESTBOX_CONTROL_LOG_MAX_BYTES=${NESTBOX_CONTROL_LOG_MAX_BYTES:-262144}
     healthcheck:

package/home/configs/opencode/control-mcp.js

@@ -74,7 +74,7 @@ async function call(name, raw) {
 
 function emit(value) { process.stdout.write(`${JSON.stringify(value)}\n`); }
 async function handle(message) {
-  if (message.method === 'initialize') return emit({ jsonrpc: '2.0', id: message.id, result: { protocolVersion: '2024-11-05', capabilities: { tools: { listChanged: false } }, serverInfo: { name: 'nestbox-control-mcp', version: '0.3.0' } } });
+  if (message.method === 'initialize') return emit({ jsonrpc: '2.0', id: message.id, result: { protocolVersion: '2024-11-05', capabilities: { tools: { listChanged: false } }, serverInfo: { name: 'nestbox-control-mcp', version: '0.5.0' } } });
   if (message.method === 'initialized') return;
   if (message.method === 'tools/list') return emit({ jsonrpc: '2.0', id: message.id, result: { tools } });
   if (message.method === 'tools/call') {

package/home/configs/opencode/instructions.md

@@ -204,7 +204,7 @@ The default Compose application has five services:
 - `opencode`: runs this agent, mounts the engine and workspace, and edits the page tree through `/nestbox/home/code`.
 - `control`: owns the Docker socket and privately brokers label-gated container exec and host-runner jobs.
 
-The default host port is `4180` after installer confirmation. Nginx container port `80` serves both Nestbox and OpenCode through host-based routing. Nginx container port `8080` is only the internal Nchan publisher.
+The default host port is `4180` after installer confirmation. Nginx container port `80` serves Nestbox and OpenCode through host-based routing. Nginx container port `8080` is only the internal Nchan publisher. The native runner enters `control` with `docker compose exec -T` and uses a versioned stdio bridge to its loopback-only API. No other service publishes a host port.
 
 Important files:
 

package/host-runner.mjs

@@ -1,64 +1,41 @@
 import { spawn } from 'node:child_process';
 import { createHash, randomBytes, randomUUID } from 'node:crypto';
 import { hostname, platform } from 'node:os';
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { readFile, realpath, rename, unlink, writeFile } from 'node:fs/promises';
+import { readFile, rename, unlink, writeFile } from 'node:fs/promises';
 
 const installDirectory = dirname(fileURLToPath(import.meta.url));
 const defaultWorkspace = basename(installDirectory) === '.nestbox' ? dirname(installDirectory) : installDirectory;
 const workspace = resolve(process.env.NESTBOX_HOST_WORKSPACE || defaultWorkspace);
-const canonicalInstallDirectory = await realpath(installDirectory).catch(() => resolve(installDirectory));
-const canonicalWorkspace = await realpath(workspace).catch(() => workspace);
-
-function parseEnv(contents) {
-  const values = {};
-  for (const line of contents.split(/\r?\n/)) {
-    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
-    if (!match) continue;
-    let value = match[2].trim();
-    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) value = value.slice(1, -1);
-    values[match[1]] = value;
-  }
-  return values;
-}
-
-const fileEnv = await readFile(join(installDirectory, '.env'), 'utf8').then(parseEnv, error => error?.code === 'ENOENT' ? {} : Promise.reject(error));
-const controlUrl = (process.env.NESTBOX_CONTROL_HOST_URL || fileEnv.NESTBOX_CONTROL_HOST_URL || `http://127.0.0.1:${process.env.NESTBOX_CONTROL_HOST_PORT || fileEnv.NESTBOX_CONTROL_HOST_PORT || '4089'}`).replace(/\/$/, '');
-const tokenPath = process.env.NESTBOX_HOST_TOKEN_FILE || fileEnv.NESTBOX_HOST_TOKEN_FILE || '';
-const resolvedTokenPath = tokenPath ? await realpath(resolve(tokenPath)).catch(() => resolve(tokenPath)) : '';
-function containsPath(root, target) {
-  const child = relative(resolve(root), target);
-  return child === '' || (!child.startsWith(`..${sep}`) && child !== '..' && !isAbsolute(child));
-}
-if (resolvedTokenPath && (containsPath(canonicalWorkspace, resolvedTokenPath) || containsPath(canonicalInstallDirectory, resolvedTokenPath))) {
-  throw new Error('NESTBOX_HOST_TOKEN_FILE must be outside the workspace and Nestbox installation.');
-}
-const fileToken = resolvedTokenPath ? await readFile(resolvedTokenPath, 'utf8').then(value => value.trim(), () => '') : '';
-const hostToken = fileToken;
-if (hostToken.length < 32) throw new Error('NESTBOX_HOST_TOKEN_FILE must contain a token of at least 32 characters.');
-
-const runnerId = randomUUID();
+const hostPlatform = platform();
+const hostName = hostname();
+// Stable for this runner process; each Docker Compose exec gets a new session ID.
+const runnerId = `runner-${randomUUID()}`;
 const once = process.argv.slice(2).includes('--once');
 const jsonOutput = process.argv.slice(2).includes('--json');
+const dockerExecutable = process.env.NESTBOX_HOST_DOCKER || 'docker';
+const dockerPrefixArgs = process.env.NESTBOX_HOST_DOCKER_ARGS ? JSON.parse(process.env.NESTBOX_HOST_DOCKER_ARGS) : [];
+if (!Array.isArray(dockerPrefixArgs) || !dockerPrefixArgs.every(value => typeof value === 'string')) throw new Error('NESTBOX_HOST_DOCKER_ARGS must be a JSON string array.');
 const npmExecutable = process.env.NESTBOX_HOST_NPM || 'npm';
 const npmCli = process.env.npm_execpath || (!process.env.NESTBOX_HOST_NPM && process.platform === 'win32' ? join(dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js') : '');
 const maximumOutputBytes = Number(process.env.NESTBOX_HOST_MAX_OUTPUT_BYTES || 4 * 1024 * 1024);
 const approvalTtlMs = Number(process.env.NESTBOX_HOST_APPROVAL_TTL_MS || 5 * 60 * 1000);
 const approvalMaximumAttempts = Number(process.env.NESTBOX_HOST_APPROVAL_ATTEMPTS || 3);
 const maximumPendingApprovals = Number(process.env.NESTBOX_HOST_APPROVAL_MAX_PENDING || 20);
-const hostPlatform = platform();
-const hostName = hostname();
 const approvals = new Map();
 const activeChildren = new Set();
-let heartbeatTimer;
+let activeBridge;
 let stopping = false;
-let shutdownDeadline = 0;
+let announced = false;
+let activeJobId;
+let activeJobPromise;
+let retainedResult;
 
 function emit(type, fields = {}) {
   const event = { ...fields, type, timestamp: new Date().toISOString() };
   if (jsonOutput) return process.stdout.write(`${JSON.stringify(event)}\n`);
-  if (type === 'runner.ready') console.log(`Nestbox host runner connected to ${controlUrl} for ${workspace}`);
+  if (type === 'runner.ready') console.log(`Nestbox host runner connected through Docker Compose for ${workspace}`);
   else if (type === 'npm.scripts.confirmation_required') {
     console.log(`\nApproval ${event.requestId}: ${event.operation} npm script "${event.name}"`);
     if (event.command !== undefined) console.log(`Command: ${event.command}`);
@@ -67,40 +44,6 @@ function emit(type, fields = {}) {
   else if (type === 'runner.error') console.error(event.error);
 }
 
-function headers(json = false) {
-  return {
-    Authorization: `Bearer ${hostToken}`,
-    'X-Nestbox-Runner-Id': runnerId,
-    'X-Nestbox-Runner-Pid': String(process.pid),
-    'X-Nestbox-Runner-Platform': hostPlatform,
-    'X-Nestbox-Runner-Host': hostName,
-    ...(json ? { 'Content-Type': 'application/json' } : {}),
-  };
-}
-
-async function controlRequest(method, path, body, timeoutMs = 35000) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(controlUrl + path, {
-      method,
-      headers: headers(body !== undefined),
-      body: body === undefined ? undefined : JSON.stringify(body),
-      signal: controller.signal,
-    });
-    const text = await response.text();
-    const value = text ? JSON.parse(text) : null;
-    if (!response.ok) {
-      const error = new Error(`Control ${method} ${path} returned ${response.status}: ${JSON.stringify(value)}`);
-      error.status = response.status;
-      throw error;
-    }
-    return { status: response.status, value };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
 async function packageText() { return readFile(join(workspace, 'package.json'), 'utf8'); }
 function parsePackageDocument(text) {
   const document = JSON.parse(text);
@@ -232,57 +175,140 @@ async function stopChildren() {
   })));
 }
 
+function sendBridge(child, message) {
+  if (!child.stdin.writable) throw new Error('The Docker Compose bridge input closed unexpectedly.');
+  child.stdin.write(`${JSON.stringify({ protocolVersion: 1, ...message })}\n`);
+}
+
+function bridgeSession() {
+  const sessionId = randomUUID();
+  const args = [...dockerPrefixArgs, 'compose', 'exec', '-T', 'control', '/usr/local/bin/nestbox-host-bridge'];
+  const child = spawn(dockerExecutable, args, { cwd: installDirectory, env: process.env, shell: false, windowsHide: true, detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'pipe'] });
+  activeBridge = child;
+  let diagnostics = '', buffer = '', settled = false;
+  const finish = (resolveSession, rejectSession, error, value) => {
+    if (settled) return;
+    settled = true;
+    if (activeBridge === child) activeBridge = undefined;
+    error ? rejectSession(error) : resolveSession(value);
+  };
+  return new Promise((resolveSession, rejectSession) => {
+    child.stdin.on('error', () => {});
+    child.stderr.on('data', chunk => {
+      diagnostics = (diagnostics + chunk.toString('utf8')).slice(-65536);
+      if (!jsonOutput) process.stderr.write(chunk);
+    });
+    child.stdout.on('data', chunk => {
+      buffer += chunk.toString('utf8');
+      if (Buffer.byteLength(buffer) > 64 * 1024 * 1024) {
+        child.stdin.end();
+        finish(resolveSession, rejectSession, new Error('The host bridge protocol line exceeded 64 MiB.'));
+        return;
+      }
+      let newline;
+      while ((newline = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1);
+        if (!line) continue;
+        let message;
+        try { message = JSON.parse(line); }
+        catch { finish(resolveSession, rejectSession, new Error('The host bridge returned invalid JSON.')); child.stdin.end(); return; }
+        if (message?.protocolVersion !== 1 || typeof message.type !== 'string') {
+          finish(resolveSession, rejectSession, new Error('The host bridge returned an unsupported protocol message.')); child.stdin.end(); return;
+        }
+        if (message.type === 'ready') {
+          if (!announced) {
+            announced = true;
+            emit('runner.ready', { workspace, pid: process.pid, platform: hostPlatform, hostname: hostName });
+          }
+        } else if (message.type === 'idle' && once && !retainedResult && !activeJobPromise) {
+          child.stdin.end();
+          finish(resolveSession, rejectSession, null, { done: true });
+        } else if (message.type === 'job') {
+          const job = message.job;
+          if (retainedResult) {
+            if (job?.jobId !== retainedResult.jobId) { finish(resolveSession, rejectSession, new Error('The bridge assigned new work before acknowledging the previous result.')); child.stdin.end(); }
+            else sendBridge(child, { type: 'result', result: retainedResult });
+            continue;
+          }
+          if (activeJobPromise && activeJobId !== job?.jobId) {
+            finish(resolveSession, rejectSession, new Error('The bridge assigned new work while another host job was still running.')); child.stdin.end(); continue;
+          }
+          if (!activeJobPromise) {
+            activeJobId = job?.jobId;
+            activeJobPromise = Promise.resolve().then(async () => {
+              if (stopping) {
+                const timestamp = new Date().toISOString();
+                return { jobId: job?.jobId, exitCode: 1, stdout: '', stderr: 'The host runner stopped before executing the assigned job.', pid: null, hostPlatform, hostName, interrupted: true, startedAt: timestamp, completedAt: timestamp };
+              }
+              try { return await execute(job); }
+              catch (error) { return { jobId: job?.jobId, exitCode: 1, stdout: '', stderr: error instanceof Error ? error.message : String(error), pid: null, hostPlatform, hostName, startedAt: new Date().toISOString(), completedAt: new Date().toISOString() }; }
+            }).then(result => {
+              retainedResult = result;
+              activeJobId = undefined;
+              activeJobPromise = undefined;
+              return result;
+            });
+          }
+          activeJobPromise.then(result => { if (!settled) sendBridge(child, { type: 'result', result }); }).catch(error => {
+            child.stdin.end();
+            finish(resolveSession, rejectSession, error);
+          });
+        } else if (message.type === 'result.ack') {
+          if (!retainedResult || message.jobId !== retainedResult.jobId) { finish(resolveSession, rejectSession, new Error('The bridge acknowledged an unknown result.')); child.stdin.end(); return; }
+          retainedResult = undefined;
+          if (once) { child.stdin.end(); finish(resolveSession, rejectSession, null, { done: true }); }
+        } else if (message.type === 'gone') {
+          if (retainedResult?.jobId === message.jobId) retainedResult = undefined;
+          emit('runner.error', { jobId: message.jobId, error: message.error || 'The assigned host job is no longer available.' });
+          if (once) { child.stdin.end(); finish(resolveSession, rejectSession, null, { done: true }); }
+        } else if (message.type === 'result.rejected') {
+          if (retainedResult?.jobId === message.jobId) retainedResult = undefined;
+          emit('runner.error', { jobId: message.jobId, error: message.error || 'Control rejected the retained host result.' });
+          if (once) { child.stdin.end(); finish(resolveSession, rejectSession, null, { done: true }); }
+        }
+      }
+    });
+    child.once('error', error => finish(resolveSession, rejectSession, new Error(`Unable to start Docker Compose: ${error.message}`)));
+    child.once('close', code => {
+      if (settled) return;
+      const stale = /nestbox-host-bridge|not found|no such file/i.test(diagnostics) || code === 126 || code === 127;
+      const message = stale
+        ? 'The control image is stale or missing the Nestbox host bridge. Run `docker compose build control` and `docker compose up -d control`, then retry.'
+        : `Docker Compose host bridge exited with code ${code}${diagnostics.trim() ? `: ${diagnostics.trim()}` : ''}`;
+      const error = new Error(message);
+      if (stale) error.code = 'STALE_CONTROL_IMAGE';
+      finish(resolveSession, rejectSession, stopping ? null : error, { done: stopping });
+    });
+    sendBridge(child, { type: 'hello', runnerId, sessionId, metadata: { pid: process.pid, platform: hostPlatform, hostname: hostName }, ...(retainedResult ? { retainedResult } : {}) });
+  });
+}
+
 async function main() {
-  let announced = false;
   let backoffMs = 500;
   while (!stopping) {
     try {
-      await controlRequest('POST', '/host/heartbeat', {});
-      if (!announced) {
-        announced = true;
-        heartbeatTimer = setInterval(() => controlRequest('POST', '/host/heartbeat', {}).catch(error => emit('runner.error', { error: error.message })), 2000);
-        emit('runner.ready', { workspace, controlUrl, pid: process.pid, platform: hostPlatform, hostname: hostName });
-      }
-      const response = await controlRequest('GET', '/host/jobs/next?timeout=25', undefined, 35000);
+      const session = bridgeSession();
+      const outcome = await session;
       backoffMs = 500;
-      if (response.status === 204) {
-        if (once) break;
-        continue;
-      }
-      const job = response.value;
-      let result;
-      if (stopping) {
-        const timestamp = new Date().toISOString();
-        result = { jobId: job?.jobId, exitCode: 1, stdout: '', stderr: 'The host runner stopped before executing the assigned job.', pid: null, hostPlatform, hostName, interrupted: true, startedAt: timestamp, completedAt: timestamp };
-      }
-      else try { result = await execute(job); }
-      catch (error) { const message = error instanceof Error ? error.message : String(error); result = { jobId: job?.jobId, exitCode: 1, stdout: '', stderr: message, pid: null, hostPlatform, hostName, startedAt: new Date().toISOString(), completedAt: new Date().toISOString() }; }
-      do {
-        try {
-          await controlRequest('POST', `/host/jobs/${encodeURIComponent(result.jobId)}/result`, result);
-          break;
-        } catch (error) {
-          if (error.status && error.status < 500) { emit('runner.error', { error: error.message }); break; }
-          await new Promise(resolveWait => setTimeout(resolveWait, backoffMs));
-          backoffMs = Math.min(10000, backoffMs * 2);
-        }
-      } while (!stopping || Date.now() < shutdownDeadline);
-      if (once) break;
+      if (outcome?.done) break;
     } catch (error) {
-      if (error.status === 401) throw error;
+      if (error.code === 'STALE_CONTROL_IMAGE') throw error;
       emit('runner.error', { error: `${error.message}; reconnecting` });
       await new Promise(resolveWait => setTimeout(resolveWait, backoffMs));
       backoffMs = Math.min(10000, backoffMs * 2);
     }
   }
-  clearInterval(heartbeatTimer);
 }
 
 for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => {
   if (stopping) return;
   stopping = true;
-  shutdownDeadline = Date.now() + 5000;
-  clearInterval(heartbeatTimer);
+  activeBridge?.stdin.end();
+  const bridge = activeBridge;
+  if (bridge?.pid) setTimeout(() => {
+    if (process.platform === 'win32') spawn('taskkill', ['/pid', String(bridge.pid), '/t', '/f'], { windowsHide: true, stdio: 'ignore' });
+    else try { process.kill(-bridge.pid, 'SIGTERM'); } catch {}
+  }, 2000).unref();
   stopChildren().catch(error => emit('runner.error', { error: error.message || String(error) }));
 });
-main().catch(error => { emit('runner.error', { error: error.message || String(error) }); clearInterval(heartbeatTimer); stopChildren().finally(() => process.exit(1)); });
+main().catch(error => { emit('runner.error', { error: error.message || String(error) }); stopChildren().finally(() => process.exit(1)); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@p10i/create-nestbox",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Create Nestbox projects.",
   "license": "MIT",
   "type": "module",

package/scripts/check-package.js

@@ -11,6 +11,7 @@ const requiredPaths = [
   'docker/rollup/Dockerfile',
   'docker/control/Dockerfile',
   'docker/control/server.py',
+  'docker/control/host_bridge.py',
   'host-runner.mjs',
   'package.host.json',
   'CHANGELOG.md',

package/tests/control.mjs

@@ -3,6 +3,7 @@ import { resolve } from 'node:path';
 
 const python = process.env.PYTHON || (process.platform === 'win32' ? 'python' : 'python3');
 const server = resolve('docker/control/server.py');
+const bridge = resolve('docker/control/host_bridge.py');
 const policyTest = String.raw`
 import importlib.util
 spec = importlib.util.spec_from_file_location("control", r"${server}")
@@ -26,24 +27,81 @@ assert "not allowed" in control.policy_error(source, target, "1000")
 source["Labels"].pop("nestbox.exec.targets")
 assert "no allowed" in control.policy_error(source, target, "1000")
 broker = control.HostBroker()
-headers = {"X-Nestbox-Runner-Pid": "123", "X-Nestbox-Runner-Platform": "test", "X-Nestbox-Runner-Host": "host"}
-broker.touch("runner-test-1234", headers)
+metadata = {"pid": 123, "platform": "test", "hostname": "host"}
+broker.connect("runner-test-1234", "session-test-1234", metadata)
 assert broker.status()["available"]
 job = {"jobId": "job-test", "type": "npm.run"}
 broker.enqueue(job)
-assert broker.next("runner-test-1234", headers, 1) == job
-broker.complete("runner-test-1234", "job-test", {"jobId": "job-test", "exitCode": 0, "stdout": "", "stderr": ""})
+assert broker.next("runner-test-1234", "session-test-1234", 1) == job
+# A new exec session for the same stable runner recovers the assignment and supersedes the old helper.
+broker.connect("runner-test-1234", "session-test-5678", metadata)
+assert broker.next("runner-test-1234", "session-test-5678", 1) == job
+try:
+    broker.touch("runner-test-1234", "session-test-1234")
+    raise AssertionError("stale session was accepted")
+except PermissionError:
+    pass
+result = {"jobId": "job-test", "exitCode": 0, "stdout": "", "stderr": ""}
+assert broker.complete("runner-test-1234", "session-test-5678", "job-test", result) is False
+assert broker.complete("runner-test-1234", "session-test-5678", "job-test", result) is True
+try:
+    broker.complete("runner-test-1234", "session-test-5678", "job-test", {**result, "stdout": "different"})
+    raise AssertionError("conflicting replay was accepted")
+except RuntimeError:
+    pass
 assert broker.wait("job-test", 1)["exitCode"] == 0
-stale = control.HostBroker()
-stale.touch("runner-stale-1234", headers)
-stale.enqueue({"jobId": "job-stale", "type": "npm.run"})
-assert stale.next("runner-stale-1234", headers, 1)["jobId"] == "job-stale"
+assert broker.complete("runner-test-1234", "session-test-5678", "job-test", result) is True
+try:
+    broker.complete("runner-test-1234", "session-test-5678", "job-missing", {"jobId": "job-missing", "exitCode": 0, "stdout": "", "stderr": ""})
+    raise AssertionError("missing job result was accepted")
+except FileNotFoundError:
+    pass
+original_ttl = control.HOST_HEARTBEAT_TTL
 control.HOST_HEARTBEAT_TTL = 0
-assert stale.wait("job-stale", 1)["interrupted"] is True
-pending = control.HostBroker()
-pending.touch("runner-pending-1234", headers)
-pending.enqueue({"jobId": "job-pending", "type": "npm.run"})
-assert pending.wait("job-pending", 1)["interrupted"] is True
+stale_assigned = control.HostBroker()
+stale_assigned.connect("runner-stale-1234", "session-stale-1234", metadata)
+stale_assigned.enqueue({"jobId": "job-stale-assigned", "type": "npm.run"})
+assert stale_assigned.next("runner-stale-1234", "session-stale-1234", 1)["jobId"] == "job-stale-assigned"
+assert stale_assigned.wait("job-stale-assigned", 1)["interrupted"] is True
+stale_pending = control.HostBroker()
+stale_pending.connect("runner-pending-1234", "session-pending-1234", metadata)
+stale_pending.enqueue({"jobId": "job-stale-pending", "type": "npm.run"})
+assert stale_pending.wait("job-stale-pending", 1)["interrupted"] is True
+control.HOST_HEARTBEAT_TTL = original_ttl
+expired = control.HostBroker()
+expired.connect("runner-expired-1234", "session-expired-1234", metadata)
+expired.enqueue({"jobId": "job-expired", "type": "npm.run"})
+assert expired.next("runner-expired-1234", "session-expired-1234", 1)["jobId"] == "job-expired"
+try:
+    expired.wait("job-expired", 0)
+    raise AssertionError("expired job returned")
+except TimeoutError:
+    pass
+try:
+    expired.complete("runner-expired-1234", "session-expired-1234", "job-expired", {"jobId": "job-expired", "exitCode": 0, "stdout": "", "stderr": ""})
+    raise AssertionError("expired result was accepted")
+except FileNotFoundError:
+    pass
+bridge_spec = importlib.util.spec_from_file_location("host_bridge", r"${bridge}")
+host_bridge = importlib.util.module_from_spec(bridge_spec)
+bridge_spec.loader.exec_module(host_bridge)
+sent = []
+host_bridge.send = sent.append
+host_bridge.request = lambda *args, **kwargs: (409, {"error": "conflicting host result replay"})
+host_bridge.deliver_result("runner-test", "session-test", {"jobId": "job-conflict"})
+assert sent[-1]["type"] == "result.rejected"
+host_bridge.request = lambda *args, **kwargs: (400, {"error": "invalid npm run result"})
+host_bridge.deliver_result("runner-test", "session-test", {"jobId": "job-invalid"})
+assert sent[-1]["type"] == "result.rejected"
+host_bridge.request = lambda *args, **kwargs: (410, {"error": "host job expired"})
+host_bridge.deliver_result("runner-test", "session-test", {"jobId": "job-gone"})
+assert sent[-1]["type"] == "gone"
+host_bridge.request = lambda *args, **kwargs: (409, {"error": "host runner session was superseded"})
+try:
+    host_bridge.deliver_result("runner-test", "session-test", {"jobId": "job-session"})
+    raise AssertionError("superseded session was treated as terminal")
+except RuntimeError:
+    pass
 `;
 
 let result = spawnSync(python, ['-c', policyTest], {
@@ -52,6 +110,9 @@ let result = spawnSync(python, ['-c', policyTest], {
 });
 if (result.status !== 0) throw new Error(`Control policy test failed: ${result.stderr || result.stdout}`);
 
+result = spawnSync(python, [bridge], { input: '', encoding: 'utf8', timeout: 2000, env: { ...process.env, PYTHONDONTWRITEBYTECODE: '1' } });
+if (result.status !== 0 || result.error?.code === 'ETIMEDOUT') throw new Error(`Host bridge did not close cleanly on stdin EOF: ${result.error?.message || result.stderr}`);
+
 result = spawnSync(python, [server], { encoding: 'utf8', env: { ...process.env, COMPOSE_PROJECT_NAME: '', PYTHONDONTWRITEBYTECODE: '1' } });
 if (result.status === 0 || !result.stderr.includes('COMPOSE_PROJECT_NAME')) throw new Error('Control did not fail closed without a project name.');
 

package/tests/creator.mjs

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 
@@ -19,8 +19,8 @@ try {
   if (nestedPackage.name !== 'existing' || nestedPackage.scripts.build !== 'node build.mjs') throw new Error('Creator replaced existing package metadata.');
   if (nestedPackage.scripts.host !== 'node .nestbox/host-runner.mjs') throw new Error('Nested host script has the wrong path.');
   const nestedEnv = await readFile(join(nested, '.nestbox', '.env'), 'utf8');
-  const tokenPath = nestedEnv.match(/^NESTBOX_HOST_TOKEN_FILE=(.+)$/m)?.[1]?.trim();
-  if (!/^WORKSPACE_PATH=\.\.$/m.test(nestedEnv) || !tokenPath || !/^[a-f0-9]{64}$/.test((await readFile(tokenPath, 'utf8')).trim())) throw new Error('Nested runtime authentication was not configured.');
+  if (!/^WORKSPACE_PATH=\.\.$/m.test(nestedEnv) || /NESTBOX_HOST_TOKEN/.test(nestedEnv)) throw new Error('Nested runtime configuration still contains host token state.');
+  if ((await readdir(fixture)).includes('state')) throw new Error('Creator wrote external host state.');
   const npmCommand = process.env.npm_execpath ? process.execPath : (process.platform === 'win32' ? 'npm.cmd' : 'npm');
   const npmArgs = process.env.npm_execpath ? [process.env.npm_execpath, 'run', 'test:host'] : ['run', 'test:host'];
   const nestedHostTest = spawnSync(npmCommand, npmArgs, { cwd: nested, encoding: 'utf8' });