@runuai/host 0.9.59 → 0.9.60

package/lib/engine-login.ts

@@ -555,20 +555,34 @@ export class EngineLoginManager {
   /** Validate and replay a Codex callback only to this operation's listener. */
   async callback(opId: string, value: string): Promise<boolean> {
     const operation = this.operations.get(opId);
-    if (
-      !operation ||
-      !this.isCurrent(operation) ||
-      operation.engine !== "codex" ||
-      operation.stage !== "awaiting_callback" ||
-      operation.callbackUsed ||
-      operation.finishing ||
-      !operation.process ||
-      !operation.callbackTarget
-    ) {
+    // Same named-rejection contract as input() (0.9.51): every silent exit
+    // here left an operator staring at "Waiting for the host…" with zero
+    // evidence on either side (live 2026-08-21 — the callback path was the
+    // last breadcrumb-free room in the login pipeline).
+    const refuse = (reason: string): false => {
+      console.log(
+        `[engine-login] callback refused for ${opId}: ${reason}`,
+      );
       return false;
+    };
+    if (!operation) return refuse("unknown opId");
+    if (!this.isCurrent(operation)) return refuse("superseded operation");
+    if (operation.engine !== "codex") return refuse("wrong engine");
+    if (operation.stage !== "awaiting_callback") {
+      return refuse(`wrong stage (${operation.stage})`);
     }
+    if (operation.callbackUsed) return refuse("callback already used");
+    if (operation.finishing) return refuse("operation finishing");
+    if (!operation.process) return refuse("no login process");
+    if (!operation.callbackTarget) return refuse("no callback target");
+    console.log(
+      `[engine-login] callback accepted for ${opId} (${value.length} chars); validating`,
+    );
     const query = validateCodexCallback(value, operation.callbackTarget);
     if (!query) {
+      console.warn(
+        `[engine-login] callback failed validation for ${opId} (state/shape mismatch with this attempt's authorize URL)`,
+      );
       await this.fail(
         operation,
         "invalid_callback",
@@ -576,6 +590,9 @@ export class EngineLoginManager {
       );
       return false;
     }
+    console.log(
+      `[engine-login] callback validated for ${opId}; replaying into the login container`,
+    );
     operation.callbackUsed = true;
     const callbackUrl = callbackReplayUrl(operation.callbackTarget, query);
     const replay = (async () => {
@@ -584,6 +601,9 @@ export class EngineLoginManager {
           operation.process!.containerName,
           callbackUrl,
         );
+        console.log(
+          `[engine-login] callback replay delivered for ${operation.opId}; waiting for the CLI to finish`,
+        );
       } catch {
         if (this.isCurrent(operation)) {
           await this.fail(
@@ -2036,6 +2056,13 @@ export function codexCallbackReplayDockerRequest(
       "--fail",
       "--silent",
       "--show-error",
+      // Follow the callback's redirect to the CLI's /success page: codex
+      // writes auth.json on the callback but EXITS only after serving that
+      // page — a real browser follows; a replay that stops at the redirect
+      // leaves a completed login waiting forever (live 2026-08-24: the
+      // first-ever completed pane codex login needed a manual /success
+      // fetch to let the CLI exit).
+      "--location",
       "--max-time",
       "10",
       "--output",

package/lib/mcp-gateway.ts

@@ -73,21 +73,25 @@ function gatewayPort(value: string | undefined): number {
 export const MCP_GATEWAY_PORT = gatewayPort(
   process.env.UAI_MCP_GATEWAY_PORT,
 );
-/** Loopback for Docker (Desktop/OrbStack forward host.docker.internal to it).
- * Apple vmnet guests cannot reach host loopback at all, so the apple backend
- * defaults to all interfaces — the unguessable per-task path token remains
- * the auth (same posture the operator override has always allowed). Resolved
- * per call: the runtime pin lands before the production listener starts, and
- * a pin never changes within a process. */
+/** Loopback works only where the container runtime forwards
+ * host.docker.internal INTO the host loopback — macOS Docker
+ * (Desktop/OrbStack). Native Linux docker resolves host.docker.internal to
+ * the bridge gateway IP, where a loopback bind is unreachable: every task's
+ * MCP config carried a dead URL and the gateway showed connection-refused
+ * from inside containers (live 2026-08-24, first Linux host with an MCP
+ * connection). Apple vmnet guests cannot reach host loopback either. Both
+ * non-mac-docker cases therefore bind all interfaces — the unguessable
+ * per-task path token remains the auth (same posture the operator override
+ * has always allowed). Resolved per call: the runtime pin lands before the
+ * production listener starts, and a pin never changes within a process. */
 function gatewayBindAddress(): string {
   const configured = process.env.UAI_MCP_GATEWAY_BIND;
   if (configured) return configured;
   // The pin, not the ready-gated identity: the production listener starts
   // during boot while activation still reports `checking`, and a loopback
   // bind chosen then would strand every vmnet guest.
-  return pinnedContainerRuntimeProvider() === "apple-container"
-    ? "0.0.0.0"
-    : "127.0.0.1";
+  if (pinnedContainerRuntimeProvider() === "apple-container") return "0.0.0.0";
+  return process.platform === "darwin" ? "127.0.0.1" : "0.0.0.0";
 }
 
 /** Host address a task container dials to reach this gateway. Docker guests

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.59",
+  "version": "0.9.60",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",