@runuai/host 0.9.80 → 0.9.82

package/lib/machine-provider-aws.ts

@@ -33,6 +33,17 @@ import type {
 
 export const AWS_MACHINE_TAG = "com.uai.machine";
 
+/** ADR-125 BYO-AWS: the Uai account that publishes the public payload AMIs,
+ * and the name prefix build-ami.sh stamps on them. A host with no
+ * UAI_MACHINE_IMAGE resolves the newest published payload in its region. */
+export const PAYLOAD_AMI_OWNER = "277057415208";
+export const PAYLOAD_AMI_NAME_PREFIX = "uai-machine-payload";
+/** Name of the security group auto-created in the default VPC when the host
+ * config names none. Inbound: all TCP from the HOST's egress /32 only —
+ * code-server runs auth-none and preview ports are plain HTTP, so exposure
+ * wider than the orchestrator would hand the editor to the internet. */
+const MANAGED_SECURITY_GROUP = "uai-machines";
+
 export interface AwsMachineConfig {
   region: string;
   /** AMI id used when the spec's image is not already an ami-*. */
@@ -219,6 +230,30 @@ function unknown(id: string, detail: string): MachineInfo {
   return { id, taskLabel: null, state: "unknown", address: null, detail };
 }
 
+/** The host's public egress address, for scoping the auto-created security
+ * group. Only consulted when the group must be CREATED — an existing group
+ * (explicit config or a prior run) never re-resolves. Overridable for hosts
+ * whose egress the checker cannot see (e.g. VPN'd). */
+async function hostEgressIp(): Promise<string> {
+  const configured = process.env.UAI_HOST_EGRESS_IP;
+  if (configured && /^\d{1,3}(\.\d{1,3}){3}$/.test(configured)) {
+    return configured;
+  }
+  try {
+    const res = await fetch("https://checkip.amazonaws.com", {
+      signal: AbortSignal.timeout(5_000),
+    });
+    const ip = (await res.text()).trim();
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) return ip;
+  } catch {
+    // fall through to the instruction below
+  }
+  throw new Error(
+    "could not determine this host's public address to scope the machine " +
+      "security group — set UAI_HOST_EGRESS_IP or UAI_AWS_SECURITY_GROUP_ID",
+  );
+}
+
 export function createAwsMachineProvider(
   config: AwsMachineConfig,
   runner: Runner = defaultRunner(config.region),
@@ -265,6 +300,171 @@ export function createAwsMachineProvider(
     return device;
   }
 
+  // -------------------------------------------------------------------------
+  // ADR-125 BYO-AWS zero-config discovery. Every resolver prefers explicit
+  // host config, resolves once per process, and fails with an instruction
+  // rather than a guess — a wrong subnet or security group is a machine the
+  // orchestrator can never reach.
+  // -------------------------------------------------------------------------
+
+  let resolvedImage: string | null = null;
+  async function resolveImage(specImage: string): Promise<string> {
+    if (specImage.startsWith("ami-")) return specImage;
+    if (resolvedImage) return resolvedImage;
+    const res = await runner([
+      "ec2",
+      "describe-images",
+      "--owners",
+      PAYLOAD_AMI_OWNER,
+      "--filters",
+      `Name=name,Values=${PAYLOAD_AMI_NAME_PREFIX}-*`,
+      "Name=state,Values=available",
+      "--query",
+      "sort_by(Images, &CreationDate)[-1].ImageId",
+    ]);
+    let image: unknown = null;
+    if (res.status === 0) {
+      try {
+        image = JSON.parse(res.stdout);
+      } catch {
+        image = null;
+      }
+    }
+    if (typeof image !== "string" || !image.startsWith("ami-")) {
+      throw new Error(
+        `no uai machine payload AMI is published in ${config.region} — set ` +
+          "UAI_MACHINE_IMAGE to an AMI id, or ask Uai to publish this region",
+      );
+    }
+    resolvedImage = image;
+    return image;
+  }
+
+  let resolvedSubnet: string | null = null;
+  async function resolveSubnet(): Promise<string> {
+    if (config.subnetId) return config.subnetId;
+    if (resolvedSubnet) return resolvedSubnet;
+    const res = await runner([
+      "ec2",
+      "describe-subnets",
+      "--filters",
+      "Name=default-for-az,Values=true",
+      "--query",
+      "sort_by(Subnets, &AvailabilityZone)[].{id: SubnetId, public: MapPublicIpOnLaunch, vpc: VpcId}",
+    ]);
+    let subnets: Array<{ id?: unknown; public?: unknown }> = [];
+    if (res.status === 0) {
+      try {
+        const parsed = JSON.parse(res.stdout);
+        if (Array.isArray(parsed)) subnets = parsed;
+      } catch {
+        subnets = [];
+      }
+    }
+    const chosen =
+      subnets.find((s) => s.public === true && typeof s.id === "string") ??
+      subnets.find((s) => typeof s.id === "string");
+    if (!chosen || typeof chosen.id !== "string") {
+      throw new Error(
+        `no default-VPC subnet found in ${config.region} — set ` +
+          "UAI_AWS_SUBNET_ID to a public subnet",
+      );
+    }
+    resolvedSubnet = chosen.id;
+    return chosen.id;
+  }
+
+  let resolvedSecurityGroup: string | null = null;
+  async function resolveSecurityGroup(subnetId: string): Promise<string> {
+    if (config.securityGroupId) return config.securityGroupId;
+    if (resolvedSecurityGroup) return resolvedSecurityGroup;
+    const vpcRes = await runner([
+      "ec2",
+      "describe-subnets",
+      "--subnet-ids",
+      subnetId,
+      "--query",
+      "Subnets[0].VpcId",
+    ]);
+    const vpcId = vpcRes.status === 0 ? JSON.parse(vpcRes.stdout) : null;
+    if (typeof vpcId !== "string") {
+      throw new Error(`could not resolve the VPC of subnet ${subnetId}`);
+    }
+    const found = await runner([
+      "ec2",
+      "describe-security-groups",
+      "--filters",
+      `Name=group-name,Values=${MANAGED_SECURITY_GROUP}`,
+      `Name=vpc-id,Values=${vpcId}`,
+      "--query",
+      "SecurityGroups[0].GroupId",
+    ]);
+    if (found.status === 0) {
+      try {
+        const existing = JSON.parse(found.stdout);
+        if (typeof existing === "string" && existing.startsWith("sg-")) {
+          resolvedSecurityGroup = existing;
+          return existing;
+        }
+      } catch {
+        // fall through to creation
+      }
+    }
+    const egress = await hostEgressIp();
+    const created = await runner([
+      "ec2",
+      "create-security-group",
+      "--group-name",
+      MANAGED_SECURITY_GROUP,
+      "--description",
+      "uai task machines: reachable only from the orchestrating host",
+      "--vpc-id",
+      vpcId,
+      "--query",
+      "GroupId",
+    ]);
+    const groupId = created.status === 0 ? JSON.parse(created.stdout) : null;
+    if (typeof groupId !== "string") {
+      throw new Error(
+        `could not create the ${MANAGED_SECURITY_GROUP} security group: ${
+          created.stderr.trim() || `exit ${created.status ?? "killed"}`
+        }`,
+      );
+    }
+    const authorized = await runner([
+      "ec2",
+      "authorize-security-group-ingress",
+      "--group-id",
+      groupId,
+      "--ip-permissions",
+      JSON.stringify([
+        {
+          IpProtocol: "tcp",
+          FromPort: 0,
+          ToPort: 65535,
+          IpRanges: [
+            {
+              CidrIp: `${egress}/32`,
+              Description: "uai orchestrating host",
+            },
+          ],
+        },
+      ]),
+    ]);
+    if (authorized.status !== 0) {
+      throw new Error(
+        `created ${groupId} but could not authorize the host's address: ${
+          authorized.stderr.trim() || `exit ${authorized.status ?? "killed"}`
+        }`,
+      );
+    }
+    console.log(
+      `[machine-aws] created security group ${groupId} (${MANAGED_SECURITY_GROUP}) allowing ${egress}/32`,
+    );
+    resolvedSecurityGroup = groupId;
+    return groupId;
+  }
+
   /** Resolve the logical machine id to its live instances via the tag. */
   async function resolveLive(
     machineId: string,
@@ -338,16 +538,21 @@ export function createAwsMachineProvider(
       // name the AMI's actual root device — a wrong name would ADD a blank
       // volume while the root stays small — so resolve it per image.
       const diskGiB = config.diskGiB ?? DEFAULT_DISK_GIB;
-      const rootDevice = await rootDeviceName(spec.image);
+      // ADR-125 BYO-AWS: explicit config wins; otherwise resolve the newest
+      // published payload AMI and the default-VPC network per process.
+      const image = await resolveImage(spec.image);
+      const subnetId = await resolveSubnet();
+      const securityGroupId = await resolveSecurityGroup(subnetId);
+      const rootDevice = await rootDeviceName(image);
       // a live machine.
       const launchFingerprint = createHash("sha256")
         .update(
           JSON.stringify([
-            spec.image,
+            image,
             type,
             spec.authorizedPublicKey ?? null,
-            config.subnetId ?? null,
-            config.securityGroupId ?? null,
+            subnetId,
+            securityGroupId,
             config.iamInstanceProfileArn ?? null,
             diskGiB,
           ]),
@@ -358,7 +563,7 @@ export function createAwsMachineProvider(
         "ec2",
         "run-instances",
         "--image-id",
-        spec.image,
+        image,
         "--instance-type",
         type,
         "--count",
@@ -383,10 +588,10 @@ export function createAwsMachineProvider(
         ...(spec.authorizedPublicKey
           ? ["--user-data", awsUserData(spec.authorizedPublicKey)]
           : []),
-        ...(config.subnetId ? ["--subnet-id", config.subnetId] : []),
-        ...(config.securityGroupId
-          ? ["--security-group-ids", config.securityGroupId]
-          : []),
+        "--subnet-id",
+        subnetId,
+        "--security-group-ids",
+        securityGroupId,
         ...(config.iamInstanceProfileArn
           ? ["--iam-instance-profile", `Arn=${config.iamInstanceProfileArn}`]
           : []),
@@ -399,7 +604,20 @@ export function createAwsMachineProvider(
           }`,
         );
       }
-      const info = await describe(machineId);
+      // DescribeInstances TAG FILTERS are eventually consistent: the query
+      // can miss an instance RunInstances just created (live 2026-08-28 —
+      // the machine was running the whole time while launch reported
+      // "absent"). Absence immediately after a successful launch is
+      // therefore not evidence yet; give the filter a bounded window.
+      let info = await describe(machineId);
+      for (
+        let attempt = 0;
+        (info.state === "absent" || info.state === "unknown") && attempt < 5;
+        attempt += 1
+      ) {
+        await new Promise<void>((resolve) => setTimeout(resolve, 3_000));
+        info = await describe(machineId);
+      }
       if (info.state === "absent" || info.state === "unknown") {
         throw new Error(
           `machine ${machineId} launched but could not be described (${info.state}${

package/package.json

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