@runuai/host 0.9.74 → 0.9.76

package/lib/machine-provider-aws.ts

@@ -22,6 +22,8 @@
 import { spawn } from "node:child_process";
 
 import type { DockerResult } from "./docker-exec";
+import { createHash } from "node:crypto";
+
 import type {
   MachineInfo,
   MachineProvider,
@@ -103,7 +105,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 +121,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 +156,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 +175,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,
       });
     }
@@ -265,6 +284,28 @@ export function createAwsMachineProvider(
     async launch(spec: MachineSpec): Promise<MachineInfo> {
       const machineId = awsMachineName(spec.taskId);
       const type = (config.instanceType ?? defaultInstanceType)(spec);
+      // The idempotency token binds the machine id TO these exact launch
+      // arguments: EC2 remembers a client token's arguments for ~24h (even
+      // past termination) and rejects reuse with different ones
+      // (IdempotentParameterMismatch — live 2026-08-27: a Resume after a
+      // provider fix changed the user-data and the retry was refused). An
+      // identical retry still cannot mint a second instance; a CHANGED
+      // launch legitimately gets a fresh token, and the resume-aware
+      // provision's describe-first step remains the guard against doubling
+      // a live machine.
+      const launchFingerprint = createHash("sha256")
+        .update(
+          JSON.stringify([
+            spec.image,
+            type,
+            spec.authorizedPublicKey ?? null,
+            config.subnetId ?? null,
+            config.securityGroupId ?? null,
+            config.iamInstanceProfileArn ?? null,
+          ]),
+        )
+        .digest("hex")
+        .slice(0, 16);
       const args = [
         "ec2",
         "run-instances",
@@ -277,7 +318,7 @@ export function createAwsMachineProvider(
         // Idempotency across crashed/retried provisions: the same token can
         // never mint a second instance.
         "--client-token",
-        machineId,
+        `${machineId}-${launchFingerprint}`.slice(0, 64),
         "--tag-specifications",
         `ResourceType=instance,Tags=[{Key=${AWS_MACHINE_TAG},Value=${spec.taskId}},{Key=Name,Value=${machineId}}]`,
         ...(spec.authorizedPublicKey
@@ -325,6 +366,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.74",
+  "version": "0.9.76",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",