@runuai/host 0.9.150 → 0.9.152

package/lib/machine-provider-aws.ts

@@ -148,16 +148,55 @@ export function awsUserData(authorizedPublicKey: string): string {
     '  chmod 700 "$home/.ssh"',
     '  chmod 600 "$home/.ssh/authorized_keys"',
     "done",
+    // This user-data is emitted only by the task-machine provider. Owned
+    // runners use the host installer and never execute it, so their OS swap
+    // remains untouched.
+    //
     // Swap BEFORE any workload: an Opus agent + a bundler + Chromium on a
-    // swapless machine hits the memory wall as a thrash (load 14, RAM 100%,
-    // sshd/code-server accept loops starved — live 2026-08-31 on the first
-    // real machine task; the HOSTS got their swapfile in 0.9.85, the
-    // machines never did). Best-effort: a machine without fallocate still
-    // boots.
+    // swapless machine hits the memory wall. The backing file is encrypted
+    // by a plain dm-crypt mapping whose key is read from /dev/urandom every
+    // time the mapping is created. /run's marker makes this idempotent within
+    // one boot; crypttab recreates the mapping (and therefore the key) after
+    // every boot. The persistent marker only says the backing file has been
+    // scrubbed once and has never subsequently held plaintext swap.
+    "if ! command -v cryptsetup >/dev/null 2>&1 || [ ! -x /lib/systemd/system-generators/systemd-cryptsetup-generator ]; then apt-get update -qq && DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends cryptsetup; fi",
+    "mkdir -p /run/uai /var/lib/uai",
+    "chmod 700 /run/uai /var/lib/uai",
+    "touch /etc/crypttab /etc/fstab",
+    "crypttab_tmp=$(mktemp /etc/crypttab.uai.XXXXXX)",
+    "awk 'BEGIN { managed=0 } $0 == \"# BEGIN UAI TASK MACHINE SWAP\" { managed=1; next } $0 == \"# END UAI TASK MACHINE SWAP\" { managed=0; next } managed { next } /^[[:space:]]*#/ { print; next } $1 == \"uai-swap\" || $4 ~ /(^|,)swap(,|$)/ { print \"# uai-replaced-swap \" $0; next } { print }' /etc/crypttab > \"$crypttab_tmp\"",
+    "printf '%s\\n' '# BEGIN UAI TASK MACHINE SWAP' 'uai-swap /swapfile /dev/urandom swap,cipher=aes-xts-plain64,size=512' '# END UAI TASK MACHINE SWAP' >> \"$crypttab_tmp\"",
+    "chown root:root \"$crypttab_tmp\" && chmod 600 \"$crypttab_tmp\" && mv -f -- \"$crypttab_tmp\" /etc/crypttab",
+    "fstab_tmp=$(mktemp /etc/fstab.uai.XXXXXX)",
+    "awk 'BEGIN { managed=0 } $0 == \"# BEGIN UAI TASK MACHINE SWAP\" { managed=1; next } $0 == \"# END UAI TASK MACHINE SWAP\" { managed=0; next } managed { next } /^[[:space:]]*#/ { print; next } NF >= 3 && $3 == \"swap\" { print \"# uai-disabled-raw-swap \" $0; next } { print }' /etc/fstab > \"$fstab_tmp\"",
+    "printf '%s\\n' '# BEGIN UAI TASK MACHINE SWAP' '/dev/mapper/uai-swap none swap sw 0 0' '# END UAI TASK MACHINE SWAP' >> \"$fstab_tmp\"",
+    "chown root:root \"$fstab_tmp\" && chmod 644 \"$fstab_tmp\" && mv -f -- \"$fstab_tmp\" /etc/fstab",
+    "active_swap=$(awk 'NR > 1 { print $1 }' /proc/swaps)",
+    "if [ ! -f /run/uai/swap-ready-v1 ] || [ \"$active_swap\" != /dev/mapper/uai-swap ]; then",
+    // Failing to page every old raw-swap page back into RAM is fatal: the
+    // sidecar must not start beside durable plaintext merely to keep booting.
+    "  swapoff -a",
+    "  cryptsetup close uai-swap 2>/dev/null || true",
+    "  if [ ! -f /var/lib/uai/swap-backing-initialized-v1 ]; then",
+    "    if [ -L /swapfile ] || { [ -e /swapfile ] && [ ! -f /swapfile ]; }; then echo 'unsafe /swapfile type' >&2; exit 1; fi",
+    // An older task-machine release used this file as raw swap. One complete
+    // zero pass removes any pages it left before the file is reused solely as
+    // ciphertext backing. Crashes are safe: without the marker the next run
+    // repeats the scrub.
+    "    if [ -f /swapfile ]; then shred --iterations=0 --zero -- /swapfile; fi",
+    "    rm -f -- /swapfile",
+    "  fi",
     // 16G (owner decision 2026-08-31): the graceful-degradation floor has to
-    // absorb the whole heavy shape, not soften its first half — 4G filled
-    // and the wall moved instead of vanishing. Disk is already paid for.
-    "(fallocate -l 16G /swapfile && chmod 600 /swapfile && mkswap /swapfile && swapon /swapfile && echo '/swapfile none swap sw 0 0' >> /etc/fstab) || true",
+    // absorb the whole heavy shape. Every command is mandatory; failure keeps
+    // cloud-init and therefore the task machine unavailable.
+    "  fallocate -l 16G /swapfile",
+    "  chown root:root /swapfile && chmod 600 /swapfile",
+    "  cryptsetup open --batch-mode --type plain --cipher aes-xts-plain64 --key-size 512 --key-file /dev/urandom /swapfile uai-swap",
+    "  mkswap /dev/mapper/uai-swap >/dev/null",
+    "  swapon /dev/mapper/uai-swap",
+    "  touch /var/lib/uai/swap-backing-initialized-v1 /run/uai/swap-ready-v1",
+    "  chmod 600 /var/lib/uai/swap-backing-initialized-v1 /run/uai/swap-ready-v1",
+    "fi",
     // The task OWNS its machine (ADR-121 — per-customer kernel isolation is
     // the whole point); denying sudo just breaks project setups that
     // container tasks handle fine (live 2026-08-31: a Hightop machine task
@@ -609,6 +648,8 @@ export function createAwsMachineProvider(
       id: machineId,
       taskLabel: instance.taskLabel,
       state,
+      // Still stopping: its processes run until the instance is stopped.
+      ...(instance.state === "stopping" ? { frozen: true as const } : {}),
       address: state === "running" ? instance.privateIp : null,
     };
   }
@@ -860,6 +901,7 @@ export function createAwsMachineProvider(
               : instance.instanceId,
           taskLabel: instance.taskLabel,
           state,
+          ...(instance.state === "stopping" ? { frozen: true as const } : {}),
           address: state === "running" ? instance.privateIp : null,
         };
       });

package/lib/machine-provider-local.ts

@@ -75,6 +75,7 @@ interface InspectShape {
   name: string;
   taskLabel: string | null;
   state: MachineState;
+  frozen?: true;
   address: string | null;
   sshPort: number | null;
 }
@@ -148,6 +149,7 @@ function parseInspect(id: string, stdout: string): InspectShape | null {
     name,
     taskLabel,
     state: stateFromDocker(stateObj?.Status),
+    ...(stateObj?.Status === "paused" ? { frozen: true as const } : {}),
     address,
     sshPort,
   };
@@ -171,6 +173,7 @@ export function createLocalMachineProvider(
         id,
         taskLabel: record.taskLabel,
         state: record.state,
+        ...(record.frozen ? { frozen: true as const } : {}),
         address: record.state === "running" ? record.address : null,
         ...(record.state === "running" && record.sshPort !== null
           ? { sshPort: record.sshPort }
@@ -322,6 +325,7 @@ export function createLocalMachineProvider(
           id: record.name,
           taskLabel: record.taskLabel,
           state: record.state,
+          ...(record.frozen ? { frozen: true as const } : {}),
           address: record.state === "running" ? record.address : null,
           ...(record.state === "running" && record.sshPort !== null
             ? { sshPort: record.sshPort }

package/lib/machine-provider.ts

@@ -48,6 +48,10 @@ export interface MachineSpec {
 export interface MachineInfo {
   /** Backend-native identifier: instance id or container id/name. */
   id: string;
+  /** Stopped as far as work goes, yet its processes still exist (a paused
+   * container, an instance still stopping): they could run or write again
+   * without a new start. */
+  frozen?: true;
   /** The recorded task ownership label, null when the machine carries none
    * (a foreign machine occupying a reserved name is never ours to touch). */
   taskLabel: string | null;

package/lib/managed-operation-drain.ts

@@ -6,6 +6,7 @@
 export class ManagedOperationDrain {
   private active = 0;
   private accepting = true;
+  private idleWaiters: Array<() => void> = [];
 
   constructor(private readonly onSettled: () => void) {}
 
@@ -22,6 +23,12 @@ export class ManagedOperationDrain {
     this.accepting = false;
   }
 
+  /** Resolves once nothing tracked is under way (at once when nothing is). */
+  idle(): Promise<void> {
+    if (this.active === 0) return Promise.resolve();
+    return new Promise<void>((resolve) => this.idleWaiters.push(resolve));
+  }
+
   track<T>(operation: () => Promise<T>): Promise<T> {
     if (!this.accepting) {
       return Promise.reject(
@@ -44,6 +51,7 @@ export class ManagedOperationDrain {
     if (this.active < 0) {
       throw new Error("managed operation drain settled more work than it tracked");
     }
+    if (this.active === 0) for (const resolve of this.idleWaiters.splice(0)) resolve();
     this.onSettled();
   }
 }