@p10i/create-nestbox 0.4.0 → 0.5.0

package/.env.example

@@ -8,10 +8,6 @@ COMPOSE_PROJECT_NAME=nestbox-change-me
 # directory, or .. when this installation is <workspace>/.nestbox.
 WORKSPACE_PATH=.
 
-# The native runner uses the shared WEB_PORT gateway. The creator generates a
-# private token file outside the workspace and mounts it only into control.
-NESTBOX_HOST_TOKEN_FILE=
-
 # Override for rootless or nonstandard Docker Engine installations.
 DOCKER_SOCKET_PATH=/var/run/docker.sock
 

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.5.0
+
+- Replace the public token-authenticated host API with a persistent `docker compose exec -T control` stdio bridge.
+- Bind the bridge API to container loopback and add reconnect-safe runner sessions with idempotent result replay.
+- Remove host tokens, the Nginx host proxy, and all `4089` exposure while retaining one Nginx-published host port.
+- Existing `0.3.x` and `0.4.x` installations may remove `NESTBOX_HOST_TOKEN_FILE` and its referenced token file after upgrading.
+
 ## 0.4.0
 
 - Route the authenticated host runner through `/_nestbox/host/` on the existing Nginx gateway.

package/INSTALL.md

@@ -101,8 +101,8 @@ Configure the host bridge in the workspace root before Compose starts:
 - For `.nestbox` layout, create `package.json` from `.nestbox/package.host.json` when absent, or merge only its `host` and `test:host` scripts into the existing manifest.
 - For direct layout, use `node host-runner.mjs` and `node tests/host-runner.mjs` for those scripts. A source clone's publisher-oriented `package.json` may be replaced by this installation manifest after preserving any intentional project metadata.
 - Never overwrite a conflicting script. Stop and ask for a different script name.
-- Set `NESTBOX_HOST_TOKEN_FILE` to a private file outside every container-mounted workspace. The npm creator writes a 64-character token there with owner-only permissions. Only `control` mounts the file; never paste the token into chat or expose it through a page.
-- Start `npm run host --` after `control` is healthy. The runner authenticates through `/_nestbox/host/` on the existing `WEB_PORT`, long-polls for work, sends heartbeats, and posts results without opening a host listener, publishing a second port, or sharing queue files.
+- Start `npm run host --` after `control` is healthy. The runner opens a persistent `docker compose exec -T control` stdio bridge from the installation directory. The image-resident helper sends heartbeats and job results through the server's container-loopback API without a host listener, token, published port, or shared queue files.
+- If the runner reports a stale control image, rebuild and recreate `control` with `docker compose build control` and `docker compose up -d control`.
 - The workspace manifest is mounted read-only in runtime containers. Confirmed changes are written only by the native host runner.
 
 Update the new `home/configs/opencode/instance.md` with:

package/README.md

@@ -12,7 +12,7 @@ Nestbox runs with Docker Compose using Nginx, PHP-FPM, Rollup, OpenCode, and a p
 
 The `control` service is the only container with `/var/run/docker.sock`. Its internal-only API permits exec only when caller, target, project, and root-user labels allow it. OpenCode reaches the API through the bundled control MCP and can target PHP-FPM and Rollup by default. Trusted PHP pages can use `nestbox_control_exec()` and are restricted to PHP-FPM self-exec.
 
-Native host commands are limited to scripts already declared in the workspace `package.json`. Keep `npm run host --` running from the workspace when host scripts are needed. The native runner authenticates with an external token file mounted only into `control`, long-polls `/_nestbox/host/` through the shared Nginx gateway port, and posts results; no host server, second published port, or shared filesystem queue is used. MCP can request script additions, edits, or deletions, but the host runner applies them only after the user supplies a short-lived code displayed exclusively in the host terminal.
+Native host commands are limited to scripts already declared in the workspace `package.json`. Keep `npm run host --` running from the workspace when host scripts are needed. The native runner maintains a `docker compose exec -T control` stdio bridge; its image-resident helper talks only to the control server on container loopback. No host API, runner token, second published port, or shared filesystem queue is used. MCP can request script additions, edits, or deletions, but the host runner applies them only after the user supplies a short-lived code displayed exclusively in the host terminal.
 
 Control emits bounded structured events to ordinary container logs. Use `docker compose logs control`; no telemetry collector, database, or observability dependency is installed. Docker socket access is root-equivalent on the host, and host scripts execute in the trusted writable workspace, so neither mechanism is a sandbox.
 

package/bin/create-nestbox.js

@@ -1,22 +1,15 @@
 #!/usr/bin/env node
 import { spawnSync } from 'node:child_process';
-import { randomBytes, randomUUID } from 'node:crypto';
-import { homedir } from 'node:os';
 import { createInterface } from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { cp, mkdir, readdir, readFile, realpath, stat, writeFile } from 'node:fs/promises';
+import { cp, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { constants } from 'node:fs';
 
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const packageJson = JSON.parse(await readFile(join(packageRoot, 'package.json'), 'utf8'));
 
-function containsPath(root, target) {
-  const child = relative(resolve(root), resolve(target));
-  return child === '' || (!child.startsWith(`..${sep}`) && child !== '..' && !isAbsolute(child));
-}
-
 const copyEntries = [
   'docker',
   'home',
@@ -227,22 +220,6 @@ async function configureHostPackage(installDir, workspaceDir, layout) {
     private: true,
     scripts
   }, null, 2)}\n`, 'utf8');
-  const envPath = join(installDir, '.env');
-  const token = randomBytes(32).toString('hex');
-  const stateBase = process.env.NESTBOX_CREATOR_STATE_ROOT
-    || process.env.LOCALAPPDATA
-    || process.env.XDG_STATE_HOME
-    || (process.platform === 'darwin' ? join(homedir(), 'Library', 'Application Support') : join(homedir(), '.local', 'state'));
-  const tokenDirectory = join(stateBase, 'nestbox', 'host-control');
-  await mkdir(tokenDirectory, { recursive: true });
-  const tokenPath = join(await realpath(tokenDirectory), `${randomUUID()}.token`);
-  const canonicalWorkspace = await realpath(workspaceDir);
-  const canonicalInstall = await realpath(installDir);
-  if (containsPath(canonicalWorkspace, tokenPath) || containsPath(canonicalInstall, tokenPath)) throw new Error('Host token state directory must be outside the workspace and Nestbox installation.');
-  await writeFile(tokenPath, `${token}\n`, { encoding: 'utf8', mode: 0o600 });
-  const composeTokenPath = tokenPath.replaceAll('\\', '/');
-  const configuredEnv = (await readFile(envPath, 'utf8')).replace(/^NESTBOX_HOST_TOKEN_FILE=.*\r?$/m, () => `NESTBOX_HOST_TOKEN_FILE=${composeTokenPath}`);
-  await writeFile(envPath, configuredEnv, 'utf8');
 }
 
 function commandExists(command) {

package/docker/control/Dockerfile

@@ -1,9 +1,10 @@
 FROM python:3.12-alpine
 
 COPY ./docker/control/server.py /usr/local/bin/nestbox-control
+COPY ./docker/control/host_bridge.py /usr/local/bin/nestbox-host-bridge
 
-RUN python -m py_compile /usr/local/bin/nestbox-control && \
-    chmod 0755 /usr/local/bin/nestbox-control
+RUN python -m py_compile /usr/local/bin/nestbox-control /usr/local/bin/nestbox-host-bridge && \
+    chmod 0755 /usr/local/bin/nestbox-control /usr/local/bin/nestbox-host-bridge
 
 WORKDIR /workspace
 

package/docker/control/host_bridge.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+import http.client
+import json
+import signal
+import sys
+import threading
+import time
+from urllib.parse import quote
+
+PROTOCOL_VERSION = 1
+MAX_LINE_BYTES = 64 * 1024 * 1024
+HEARTBEAT_SECONDS = 4
+stopping = threading.Event()
+input_condition = threading.Condition()
+input_messages = []
+input_error = None
+input_eof = False
+connections = set()
+connections_lock = threading.Lock()
+
+
+def diagnostic(message):
+    sys.stderr.write(f"nestbox host bridge: {message}\n")
+    sys.stderr.flush()
+
+
+def stop_requests():
+    stopping.set()
+    with connections_lock:
+        active = list(connections)
+    for connection in active:
+        connection.close()
+    with input_condition:
+        input_condition.notify_all()
+
+
+def send(message):
+    data = json.dumps({"protocolVersion": PROTOCOL_VERSION, **message}, separators=(",", ":"))
+    sys.stdout.write(data + "\n")
+    sys.stdout.flush()
+
+
+def read_input():
+    global input_error, input_eof
+    try:
+        while True:
+            line = sys.stdin.buffer.readline(MAX_LINE_BYTES + 1)
+            if not line:
+                with input_condition:
+                    input_eof = True
+                    input_condition.notify_all()
+                stop_requests()
+                return
+            if len(line) > MAX_LINE_BYTES or not line.endswith(b"\n"):
+                raise ValueError("protocol line exceeds the limit")
+            value = json.loads(line)
+            if not isinstance(value, dict) or value.get("protocolVersion") != PROTOCOL_VERSION:
+                raise ValueError("unsupported protocol message")
+            with input_condition:
+                if len(input_messages) >= 2:
+                    raise ValueError("too many queued protocol messages")
+                input_messages.append(value)
+                input_condition.notify_all()
+    except Exception as error:
+        with input_condition:
+            input_error = error
+            input_condition.notify_all()
+        stop_requests()
+
+
+def receive():
+    with input_condition:
+        while not input_messages and not input_eof and input_error is None and not stopping.is_set():
+            input_condition.wait()
+        if input_error is not None:
+            raise input_error
+        if not input_messages:
+            raise EOFError
+        return input_messages.pop(0)
+
+
+def request(method, path, runner_id, session_id, body=None, timeout=35):
+    payload = json.dumps(body, separators=(",", ":")).encode() if body is not None else None
+    headers = {
+        "X-Nestbox-Runner-Id": runner_id,
+        "X-Nestbox-Session-Id": session_id,
+        "Content-Type": "application/json",
+    }
+    connection = http.client.HTTPConnection("127.0.0.1", 4089, timeout=timeout)
+    with connections_lock:
+        connections.add(connection)
+    try:
+        connection.request(method, path, body=payload, headers=headers)
+        response = connection.getresponse()
+        data = response.read(MAX_LINE_BYTES + 1)
+    finally:
+        connection.close()
+        with connections_lock:
+            connections.discard(connection)
+    if len(data) > MAX_LINE_BYTES:
+        raise RuntimeError("control response exceeds the limit")
+    value = json.loads(data) if data else None
+    return response.status, value
+
+
+def heartbeat(runner_id, session_id, metadata):
+    while not stopping.wait(HEARTBEAT_SECONDS):
+        try:
+            status, value = request("POST", "/host/heartbeat", runner_id, session_id, metadata, timeout=5)
+            if status == 409:
+                diagnostic((value or {}).get("error", "session was superseded"))
+                stop_requests()
+                return
+            if status >= 400:
+                diagnostic(f"heartbeat returned HTTP {status}")
+        except Exception as error:
+            if not stopping.is_set():
+                diagnostic(f"heartbeat failed: {error}")
+
+
+def deliver_result(runner_id, session_id, result):
+    job_id = result.get("jobId")
+    delay = 0.5
+    while not stopping.is_set():
+        try:
+            status, response = request("POST", f"/host/jobs/{quote(str(job_id), safe='')}/result", runner_id, session_id, result)
+            if status in (200, 202):
+                send({"type": "result.ack", "jobId": job_id, "duplicate": bool((response or {}).get("duplicate"))})
+                return
+            error = (response or {}).get("error", f"result returned HTTP {status}")
+            if status == 410:
+                send({"type": "gone", "jobId": job_id, "error": error})
+                return
+            if status == 409 and "session was superseded" in error.lower():
+                raise RuntimeError(error)
+            if status < 500:
+                send({"type": "result.rejected", "jobId": job_id, "error": error})
+                return
+        except (OSError, http.client.HTTPException) as error:
+            if stopping.is_set():
+                raise EOFError from error
+            diagnostic(f"result delivery failed: {error}; retrying")
+        stopping.wait(delay)
+        delay = min(10, delay * 2)
+
+
+def main():
+    threading.Thread(target=read_input, daemon=True).start()
+    hello = receive()
+    if hello.get("type") != "hello":
+        raise ValueError("first protocol message must be hello")
+    runner_id, session_id = hello.get("runnerId"), hello.get("sessionId")
+    metadata = hello.get("metadata") or {}
+    if not isinstance(runner_id, str) or not isinstance(session_id, str) or not isinstance(metadata, dict):
+        raise ValueError("invalid hello message")
+    status, value = request("POST", "/host/connect", runner_id, session_id, metadata)
+    if status >= 400:
+        raise RuntimeError(f"connect returned HTTP {status}: {(value or {}).get('error', value)}")
+    thread = threading.Thread(target=heartbeat, args=(runner_id, session_id, metadata), daemon=True)
+    thread.start()
+    retained_result = hello.get("retainedResult")
+    if retained_result is not None:
+        if not isinstance(retained_result, dict):
+            raise ValueError("invalid retained result")
+        deliver_result(runner_id, session_id, retained_result)
+        if stopping.is_set():
+            return
+    send({"type": "ready"})
+    while not stopping.is_set():
+        status, value = request("GET", "/host/jobs/next?timeout=25", runner_id, session_id, timeout=30)
+        if status == 204:
+            send({"type": "idle"})
+            continue
+        if status == 409:
+            raise RuntimeError((value or {}).get("error", "session was superseded"))
+        if status == 410:
+            send({"type": "gone", "jobId": (value or {}).get("jobId"), "error": (value or {}).get("error", "job is gone")})
+            continue
+        if status >= 400 or not isinstance(value, dict):
+            raise RuntimeError(f"next job returned HTTP {status}: {value}")
+        send({"type": "job", "job": value})
+        result = receive()
+        if result.get("type") != "result" or not isinstance(result.get("result"), dict):
+            raise ValueError("expected a result message")
+        job_id = result["result"].get("jobId")
+        if job_id != value.get("jobId"):
+            raise ValueError("result does not match the assigned job")
+        deliver_result(runner_id, session_id, result["result"])
+
+
+def stop(_signum, _frame):
+    stop_requests()
+
+
+if __name__ == "__main__":
+    signal.signal(signal.SIGTERM, stop)
+    signal.signal(signal.SIGINT, stop)
+    try:
+        main()
+    except EOFError:
+        pass
+    except Exception as error:
+        if not stopping.is_set():
+            diagnostic(str(error))
+            sys.exit(1)

package/docker/control/server.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
+import hashlib
 import http.client
-import hmac
 import json
 import os
 import re
@@ -17,12 +17,6 @@ DOCKER_SOCKET = os.environ.get("DOCKER_SOCKET", "/var/run/docker.sock")
 WORKSPACE_PATH = os.environ.get("WORKSPACE_PATH", "/workspace")
 PROJECT_NAME = os.environ.get("COMPOSE_PROJECT_NAME", "").strip()
 SERVICE_NAME = os.environ.get("NESTBOX_CONTROL_SERVICE", "control")
-HOST_TOKEN_FILE = os.environ.get("NESTBOX_HOST_TOKEN_FILE", "/run/secrets/nestbox-host-token")
-try:
-    with open(HOST_TOKEN_FILE, encoding="utf-8") as token_stream:
-        HOST_TOKEN = token_stream.read().strip()
-except OSError:
-    HOST_TOKEN = ""
 HOST_TIMEOUT = int(os.environ.get("NESTBOX_HOST_RUNNER_TIMEOUT", "3600"))
 HOST_HEARTBEAT_TTL = int(os.environ.get("NESTBOX_HOST_RUNNER_HEARTBEAT_TTL", "10"))
 HOST_LONG_POLL_TIMEOUT = int(os.environ.get("NESTBOX_HOST_LONG_POLL_TIMEOUT", "25"))
@@ -206,10 +200,16 @@ class HostBroker:
         self.pending = []
         self.jobs = {}
         self.runner = {}
+        self.gone = {}
 
-    def touch(self, runner_id, headers):
+    def _validate_ids(self, runner_id, session_id):
         if not re.fullmatch(r"[A-Za-z0-9._:-]{8,128}", runner_id):
             raise ValueError("invalid runner ID")
+        if not re.fullmatch(r"[A-Za-z0-9._:-]{8,128}", session_id):
+            raise ValueError("invalid session ID")
+
+    def connect(self, runner_id, session_id, metadata):
+        self._validate_ids(runner_id, session_id)
         now = time.monotonic()
         with self.condition:
             active_id = self.runner.get("id")
@@ -228,13 +228,22 @@ class HostBroker:
                         }
             self.runner = {
                 "id": runner_id,
+                "sessionId": session_id,
                 "seen": now,
-                "pid": headers.get("X-Nestbox-Runner-Pid"),
-                "platform": headers.get("X-Nestbox-Runner-Platform"),
-                "hostname": headers.get("X-Nestbox-Runner-Host"),
+                "pid": metadata.get("pid"),
+                "platform": metadata.get("platform"),
+                "hostname": metadata.get("hostname"),
             }
             self.condition.notify_all()
 
+    def touch(self, runner_id, session_id):
+        self._validate_ids(runner_id, session_id)
+        with self.condition:
+            if self.runner.get("id") != runner_id or self.runner.get("sessionId") != session_id:
+                raise PermissionError("host runner session was superseded")
+            self.runner["seen"] = time.monotonic()
+            self.condition.notify_all()
+
     def status(self):
         with self.condition:
             if not self.runner:
@@ -256,14 +265,16 @@ class HostBroker:
             self.pending.append(job["jobId"])
             self.condition.notify_all()
 
-    def next(self, runner_id, headers, timeout):
+    def next(self, runner_id, session_id, timeout):
         deadline = time.monotonic() + timeout
         with self.condition:
             while True:
-                if self.runner.get("id") != runner_id:
-                    raise PermissionError("another host runner is active")
-                if time.monotonic() - self.runner.get("seen", 0) > HOST_HEARTBEAT_TTL:
-                    return None
+                if self.runner.get("id") != runner_id or self.runner.get("sessionId") != session_id:
+                    raise PermissionError("host runner session was superseded")
+                self.runner["seen"] = time.monotonic()
+                for record in self.jobs.values():
+                    if record.get("runnerId") == runner_id and record.get("result") is None:
+                        return record["job"]
                 if self.pending:
                     identifier = self.pending.pop(0)
                     record = self.jobs.get(identifier)
@@ -275,13 +286,28 @@ class HostBroker:
                     return None
                 self.condition.wait(min(1, remaining))
 
-    def complete(self, runner_id, identifier, result):
+    def complete(self, runner_id, session_id, identifier, result):
         with self.condition:
+            if self.runner.get("id") != runner_id or self.runner.get("sessionId") != session_id:
+                raise PermissionError("host runner session was superseded")
+            serialized = json.dumps(result, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode()
+            fingerprint = hashlib.sha256(serialized).hexdigest()
             record = self.jobs.get(identifier)
-            if not record or record.get("runnerId") != runner_id:
-                raise ValueError("host job is unknown or belongs to another runner")
+            terminal = self.gone.get(identifier)
+            if not record and terminal:
+                if terminal.get("fingerprint") == fingerprint:
+                    return True
+                if terminal.get("fingerprint"):
+                    raise RuntimeError("conflicting host result replay")
+                raise FileNotFoundError(terminal["error"])
+            if not record:
+                raise FileNotFoundError("host job is no longer available")
+            if record.get("runnerId") != runner_id:
+                raise ValueError("host job belongs to another runner")
             if record.get("result") is not None:
-                raise ValueError("host job already has a result")
+                if record.get("fingerprint") == fingerprint:
+                    return True
+                raise RuntimeError("conflicting host result replay")
             if result.get("jobId") != identifier:
                 raise ValueError("host result contains a mismatched job ID")
             job = record["job"]
@@ -298,6 +324,31 @@ class HostBroker:
                 if result.get("status") != "success" and not isinstance(result.get("exitCode"), int):
                     raise ValueError("invalid script confirmation result")
             record["result"] = result
+            record["fingerprint"] = fingerprint
+            self.condition.notify_all()
+            return False
+
+    def _remember(self, identifier, record=None, error="host job is gone"):
+        self.gone[identifier] = {
+            "fingerprint": record.get("fingerprint") if record else None,
+            "error": error,
+            "time": time.monotonic(),
+        }
+        while len(self.gone) > MAX_HOST_JOBS:
+            del self.gone[next(iter(self.gone))]
+
+    def reject(self, runner_id, identifier, error):
+        with self.condition:
+            record = self.jobs.get(identifier)
+            if not record or record.get("runnerId") != runner_id or record.get("result") is not None:
+                return
+            record["result"] = {
+                "jobId": identifier,
+                "exitCode": 1,
+                "stdout": "",
+                "stderr": f"Host result was rejected: {error}",
+                "interrupted": True,
+            }
             self.condition.notify_all()
 
     def wait(self, identifier, timeout=HOST_TIMEOUT):
@@ -305,33 +356,31 @@ class HostBroker:
         with self.condition:
             while True:
                 record = self.jobs.get(identifier)
-                if record and record.get("runnerId") and record.get("result") is None:
-                    owner = record["runnerId"]
-                    if self.runner.get("id") != owner or time.monotonic() - self.runner.get("seen", 0) > HOST_HEARTBEAT_TTL:
+                if record and record.get("result") is None:
+                    age = time.monotonic() - self.runner.get("seen", 0) if self.runner else float("inf")
+                    owner = record.get("runnerId")
+                    lost_owner = bool(owner and self.runner.get("id") != owner)
+                    if lost_owner or age > HOST_HEARTBEAT_TTL:
                         record["result"] = {
                             "jobId": identifier,
                             "exitCode": 1,
                             "stdout": "",
-                            "stderr": "The assigned host runner disconnected before returning a result.",
+                            "stderr": "The assigned host runner disconnected before returning a result." if owner else "The host runner disconnected before accepting the job.",
                             "interrupted": True,
                         }
-                elif record and record.get("result") is None and self.runner and time.monotonic() - self.runner.get("seen", 0) > HOST_HEARTBEAT_TTL:
-                    record["result"] = {
-                        "jobId": identifier,
-                        "exitCode": 1,
-                        "stdout": "",
-                        "stderr": "The host runner disconnected before accepting the job.",
-                        "interrupted": True,
-                    }
                 if record and record.get("result") is not None:
                     result = record["result"]
                     del self.jobs[identifier]
+                    if identifier in self.pending:
+                        self.pending.remove(identifier)
+                    self._remember(identifier, record)
                     return result
                 remaining = deadline - time.monotonic()
                 if remaining <= 0:
-                    self.jobs.pop(identifier, None)
+                    expired = self.jobs.pop(identifier, None)
                     if identifier in self.pending:
                         self.pending.remove(identifier)
+                    self._remember(identifier, expired, f"host job expired after {timeout} seconds")
                     raise TimeoutError(f"host runner did not finish within {timeout} seconds")
                 self.condition.wait(min(1, remaining))
 
@@ -372,7 +421,7 @@ def valid_command(command):
 
 
 class Handler(BaseHTTPRequestHandler):
-    server_version = "nestbox-control/0.4"
+    server_version = "nestbox-control/0.5"
 
     def setup(self):
         super().setup()
@@ -560,7 +609,7 @@ class Handler(BaseHTTPRequestHandler):
 
 
 class HostHandler(BaseHTTPRequestHandler):
-    server_version = "nestbox-host-control/0.4"
+    server_version = "nestbox-host-control/0.5"
 
     def setup(self):
         super().setup()
@@ -577,14 +626,12 @@ class HostHandler(BaseHTTPRequestHandler):
         self.end_headers()
         self.wfile.write(payload)
 
-    def authorized(self):
-        supplied = self.headers.get("Authorization", "")
-        expected = f"Bearer {HOST_TOKEN}"
-        return hmac.compare_digest(supplied.encode(), expected.encode())
-
     def runner(self):
         return self.headers.get("X-Nestbox-Runner-Id", "")
 
+    def session(self):
+        return self.headers.get("X-Nestbox-Session-Id", "")
+
     def body(self):
         if self.headers.get("Transfer-Encoding"):
             raise ValueError("transfer encoding is not supported")
@@ -596,12 +643,9 @@ class HostHandler(BaseHTTPRequestHandler):
             raise ValueError("request body must be a JSON object")
         return value
 
-    def authenticate(self):
-        if not self.authorized():
-            self.send_json(401, {"error": "invalid host runner token"})
-            return False
+    def active_session(self):
         try:
-            HOST_BROKER.touch(self.runner(), self.headers)
+            HOST_BROKER.touch(self.runner(), self.session())
             return True
         except PermissionError as error:
             self.send_json(409, {"error": str(error)})
@@ -612,26 +656,36 @@ class HostHandler(BaseHTTPRequestHandler):
     def do_GET(self):
         parsed = urlparse(self.path)
         if parsed.path == "/host/health":
-            if not self.authenticate(): return
+            if not self.active_session(): return
             self.send_json(200, {"ok": True, "hostRunner": host_status()})
             return
         if parsed.path == "/host/jobs/next":
-            if not self.authenticate(): return
             try:
                 requested = int((parse_qs(parsed.query).get("timeout") or [HOST_LONG_POLL_TIMEOUT])[0])
                 timeout = max(1, min(HOST_LONG_POLL_TIMEOUT, requested))
-                job = HOST_BROKER.next(self.runner(), self.headers, timeout)
+                job = HOST_BROKER.next(self.runner(), self.session(), timeout)
                 if job is None:
                     self.send_response(204); self.end_headers(); return
                 self.send_json(200, job)
+            except PermissionError as error:
+                self.send_json(409, {"error": str(error)})
             except (TypeError, ValueError) as error:
                 self.send_json(400, {"error": str(error)})
             return
         self.send_json(404, {"error": "not found"})
 
     def do_POST(self):
-        if not self.authenticate(): return
         path = urlparse(self.path).path
+        if path == "/host/connect":
+            try:
+                HOST_BROKER.connect(self.runner(), self.session(), self.body())
+                self.send_json(200, {"ok": True})
+            except PermissionError as error:
+                self.send_json(409, {"error": str(error)})
+            except ValueError as error:
+                self.send_json(400, {"error": str(error)})
+            return
+        if not self.active_session(): return
         if path == "/host/heartbeat":
             self.send_json(200, {"ok": True})
             return
@@ -640,18 +694,23 @@ class HostHandler(BaseHTTPRequestHandler):
             self.send_json(404, {"error": "not found"}); return
         try:
             result = self.body()
-            HOST_BROKER.complete(self.runner(), match.group(1), result)
-            self.send_json(202, {"accepted": True})
+            duplicate = HOST_BROKER.complete(self.runner(), self.session(), match.group(1), result)
+            self.send_json(202, {"accepted": True, "duplicate": duplicate})
+        except FileNotFoundError as error:
+            self.send_json(410, {"error": str(error), "jobId": match.group(1)})
+        except PermissionError as error:
+            self.send_json(409, {"error": str(error)})
+        except RuntimeError as error:
+            self.send_json(409, {"error": str(error)})
         except ValueError as error:
+            HOST_BROKER.reject(self.runner(), match.group(1), str(error))
             self.send_json(400, {"error": str(error)})
 
 
 def main():
     if not re.fullmatch(r"[a-z0-9][a-z0-9_-]*", PROJECT_NAME):
         raise SystemExit("COMPOSE_PROJECT_NAME must be a non-empty lowercase project slug")
-    if len(HOST_TOKEN) < 32:
-        raise SystemExit("NESTBOX_HOST_TOKEN_FILE must contain a token of at least 32 characters")
-    host_server = ThreadingHTTPServer(("0.0.0.0", 4089), HostHandler)
+    host_server = ThreadingHTTPServer(("127.0.0.1", 4089), HostHandler)
     threading.Thread(target=host_server.serve_forever, daemon=True).start()
     ThreadingHTTPServer(("0.0.0.0", int(os.environ.get("NESTBOX_CONTROL_PORT", "4088"))), Handler).serve_forever()
 

package/docker-compose.yaml

@@ -114,8 +114,6 @@ services:
       dockerfile: ./docker/control/Dockerfile
     expose:
       - "4088"
-      # Authenticated host-runner transport, proxied only through Nginx.
-      - "4089"
     volumes:
       - ${DOCKER_SOCKET_PATH:-/var/run/docker.sock}:/var/run/docker.sock
       - type: bind
@@ -124,16 +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_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: