@runuai/host 0.9.73 → 0.9.75

package/lib/machine-provider-aws.ts

@@ -103,7 +103,12 @@ export function awsUserData(authorizedPublicKey: string): string {
   const script = [
     "#!/bin/sh",
     "set -e",
-    "id node >/dev/null 2>&1 || useradd -m -u 1000 -s /bin/bash node",
+    // uid 1000 is often TAKEN on stock cloud images (Debian's `admin`) —
+    // insisting on it aborted the whole script under set -e and left no key
+    // installed for anyone (live 2026-08-27, first EC2 smoke). Prefer 1000,
+    // fall back to auto: on a machine the task owns the whole filesystem,
+    // so the exact uid is convention, not correctness.
+    "id node >/dev/null 2>&1 || useradd -m -u 1000 -s /bin/bash node 2>/dev/null || useradd -m -s /bin/bash node",
     "for account in node root; do",
     '  home=$(getent passwd "$account" | cut -d: -f6)',
     '  mkdir -p "$home/.ssh"',
@@ -114,7 +119,12 @@ export function awsUserData(authorizedPublicKey: string): string {
     "done",
     "",
   ].join("\n");
-  return Buffer.from(script, "utf8").toString("base64");
+  // RAW script, not base64: AWS CLI v2 base64-encodes --user-data ITSELF.
+  // Pre-encoding double-encoded it, cloud-init saw garbage and silently ran
+  // nothing — no key installed for anyone (live 2026-08-27, second EC2
+  // smoke failure; the uid-1000 collision fixed just before was real too,
+  // but masked by this).
+  return script;
 }
 
 type LiveInstance = {
@@ -144,6 +154,7 @@ function parseReservations(stdout: string): LiveInstance[] | null {
         InstanceId?: unknown;
         State?: { Name?: unknown };
         PrivateIpAddress?: unknown;
+        PublicIpAddress?: unknown;
         Tags?: Array<{ Key?: unknown; Value?: unknown }>;
       };
       if (typeof record.InstanceId !== "string") return null;
@@ -162,10 +173,16 @@ function parseReservations(stdout: string): LiveInstance[] | null {
       instances.push({
         instanceId: record.InstanceId,
         state,
+        // Prefer the public address when the subnet assigns one: an
+        // orchestrator OUTSIDE the VPC (the local smoke, a dev box) can only
+        // dial that, while the production in-VPC orchestrator sees no public
+        // IP on its machines and keeps dialing private, unchanged.
         privateIp:
-          typeof record.PrivateIpAddress === "string"
-            ? record.PrivateIpAddress
-            : null,
+          typeof record.PublicIpAddress === "string"
+            ? record.PublicIpAddress
+            : typeof record.PrivateIpAddress === "string"
+              ? record.PrivateIpAddress
+              : null,
         taskLabel,
       });
     }
@@ -325,6 +342,38 @@ export function createAwsMachineProvider(
           }`,
         );
       }
+      // EC2 sits in `stopping` for tens of seconds, and StartInstances
+      // refuses it with IncorrectInstanceState — an immediate stop→resume
+      // (a user pressing Resume right after Stop; the live 2026-08-27
+      // smoke) failed exactly there because our state map folds `stopping`
+      // into "stopped". Stop resolves only once the instance can actually
+      // be started again, mirroring terminate's poll-to-absent.
+      const deadline = Date.now() + 180_000;
+      for (;;) {
+        const raw = await runner([
+          "ec2",
+          "describe-instances",
+          "--instance-ids",
+          instance.instanceId,
+          "--query",
+          "Reservations[].Instances[].State.Name",
+          "--output",
+          "text",
+        ]);
+        const state = raw.status === 0 ? raw.stdout.trim() : "";
+        if (state === "stopped") return;
+        if (state === "terminated" || state === "shutting-down") {
+          throw new Error(
+            `machine ${machineId} terminated while stopping (${state})`,
+          );
+        }
+        if (Date.now() >= deadline) {
+          throw new Error(
+            `machine ${machineId} did not reach stopped within the stop deadline (${state || "unknown"})`,
+          );
+        }
+        await new Promise<void>((resolve) => setTimeout(resolve, 5_000));
+      }
     },
 
     async start(machineId: string): Promise<MachineInfo> {

package/package.json

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

package/src/main.ts

@@ -252,6 +252,12 @@ const bridgeUrl =
 let ws: WebSocket | null = null;
 let stopping = false;
 let fatal = false;
+/** Auth-rejected (4001) retry cadence. A genuinely revoked credential costs
+ * one connection attempt per interval; a transient rejection (the bridge's
+ * own DB down during a cloud restart, an auth frame lost on a slow link)
+ * heals without an operator visit — the 2026-08-27 outage stranded every
+ * connected host overnight because 4001 was treated as terminal. */
+const AUTH_REJECTED_RETRY_MS = 5 * 60_000;
 let reconnectAttempt = 0;
 let connectionRequestGeneration = 0;
 let inFlight = 0;
@@ -1642,12 +1648,16 @@ async function connect(): Promise<void> {
       return;
     }
     if (code === 4001) {
-      fatal = true;
       markDisconnected(text || "auth rejected by bridge");
       console.error(
-        `[host-agent] auth rejected by bridge${text ? `: ${text}` : ""}`,
+        `[host-agent] auth rejected by bridge${text ? `: ${text}` : ""} — retrying in ${Math.round(AUTH_REJECTED_RETRY_MS / 60_000)} minutes`,
       );
-      process.exitCode = 1;
+      addHostBreadcrumb("bridge", "auth-rejected", {
+        retryInMs: AUTH_REJECTED_RETRY_MS,
+      });
+      setTimeout(() => {
+        void connect();
+      }, AUTH_REJECTED_RETRY_MS);
       return;
     }
     const delay = reconnectDelay();