@aloud/runner 0.3.1 → 0.3.3

package/dist/cli.js

@@ -866,6 +866,22 @@ async function evaluateTargetUrl(rawUrl, options = {}) {
   }
   return { allowed: true, hostname: hostname2, addresses };
 }
+async function targetNetworkAccess(rawUrl, resolver) {
+  const verdict = await evaluateTargetUrl(rawUrl, {
+    allowPrivateNetwork: false,
+    ...resolver ? { resolver } : {}
+  });
+  if (verdict.allowed) return { kind: "public", hostname: verdict.hostname };
+  let hostname2 = null;
+  try {
+    hostname2 = new URL(rawUrl).hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  } catch {
+  }
+  if ((verdict.code === "loopback" || verdict.code === "private_network") && hostname2) {
+    return { kind: "private", hostname: hostname2, code: verdict.code, reason: verdict.reason };
+  }
+  return { kind: "blocked", hostname: hostname2, code: verdict.code, reason: verdict.reason };
+}
 function normaliseHosts(hosts) {
   return [...new Set(hosts.map((host) => host.toLowerCase().replace(/^\*\./, "").trim()).filter(Boolean))];
 }
@@ -3152,6 +3168,83 @@ async function waitForApproval(start2, deps) {
   }
 }
 
+// src/version.ts
+var RUNNER_VERSION = "0.3.3";
+var RUNNER_VERSION_HEADER = "x-aloud-runner-version";
+function versionParts(value) {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(value);
+  if (!match) return null;
+  const parts = [Number(match[1]), Number(match[2]), Number(match[3])];
+  return parts.every(Number.isSafeInteger) ? parts : null;
+}
+function compareRunnerVersions(left, right) {
+  const a = versionParts(left);
+  const b = versionParts(right);
+  if (!a || !b) return null;
+  for (let index = 0; index < a.length; index += 1) {
+    if (a[index] > b[index]) return 1;
+    if (a[index] < b[index]) return -1;
+  }
+  return 0;
+}
+function runnerVersionPolicyFrom(value) {
+  if (!value || typeof value !== "object") return null;
+  const policy = value;
+  if (typeof policy.minimum !== "string" || typeof policy.recommended !== "string") return null;
+  const order = compareRunnerVersions(policy.recommended, policy.minimum);
+  if (order === null || order < 0) return null;
+  return { minimum: policy.minimum, recommended: policy.recommended };
+}
+function runnerUpdateFor(policy, current = RUNNER_VERSION) {
+  const recommendedOrder = compareRunnerVersions(policy.recommended, current);
+  const minimumOrder = compareRunnerVersions(policy.minimum, current);
+  if (recommendedOrder === null || minimumOrder === null) return null;
+  if (recommendedOrder <= 0) return null;
+  return { target: policy.recommended, required: minimumOrder > 0 };
+}
+
+// src/protocol/presence.ts
+async function readRunnerPresence(input) {
+  const fetchImpl = input.fetchImpl ?? fetch;
+  try {
+    const response = await fetchImpl(new URL("api/runner/me", input.server + "/"), {
+      headers: {
+        authorization: `Bearer ${input.token}`,
+        accept: "application/json",
+        [RUNNER_VERSION_HEADER]: RUNNER_VERSION
+      },
+      signal: AbortSignal.timeout(input.timeoutMs ?? 5e3)
+    });
+    if (response.status === 401 || response.status === 403) return { state: "revoked" };
+    if (!response.ok) return { state: "unreachable" };
+    const body = await response.json().catch(() => ({}));
+    return {
+      state: "ok",
+      presence: {
+        online: body.online === true,
+        lastSeenAt: typeof body.lastSeenAt === "string" ? body.lastSeenAt : null,
+        lastVersion: typeof body.lastVersion === "string" ? body.lastVersion : null
+      }
+    };
+  } catch {
+    return { state: "unreachable" };
+  }
+}
+async function waitForRunnerCheckIn(input) {
+  const now = input.now ?? Date.now;
+  const sleep = input.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const deadline = now() + (input.timeoutMs ?? 15e3);
+  for (; ; ) {
+    const result = await readRunnerPresence(input);
+    if (result.state === "revoked") return "revoked";
+    if (result.state === "ok" && result.presence.online && result.presence.lastSeenAt !== null && result.presence.lastSeenAt !== input.previousLastSeenAt && result.presence.lastVersion === (input.expectedVersion ?? RUNNER_VERSION)) {
+      return "confirmed";
+    }
+    if (now() >= deadline) return "timeout";
+    await sleep(Math.min(input.pollMs ?? 750, Math.max(0, deadline - now())));
+  }
+}
+
 // src/config/mcp-credentials.ts
 import { chmod, mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { constants } from "node:fs";
@@ -3384,41 +3477,6 @@ function alive(pid) {
   }
 }
 
-// src/version.ts
-var RUNNER_VERSION = "0.3.1";
-var RUNNER_VERSION_HEADER = "x-aloud-runner-version";
-function versionParts(value) {
-  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(value);
-  if (!match) return null;
-  const parts = [Number(match[1]), Number(match[2]), Number(match[3])];
-  return parts.every(Number.isSafeInteger) ? parts : null;
-}
-function compareRunnerVersions(left, right) {
-  const a = versionParts(left);
-  const b = versionParts(right);
-  if (!a || !b) return null;
-  for (let index = 0; index < a.length; index += 1) {
-    if (a[index] > b[index]) return 1;
-    if (a[index] < b[index]) return -1;
-  }
-  return 0;
-}
-function runnerVersionPolicyFrom(value) {
-  if (!value || typeof value !== "object") return null;
-  const policy = value;
-  if (typeof policy.minimum !== "string" || typeof policy.recommended !== "string") return null;
-  const order = compareRunnerVersions(policy.recommended, policy.minimum);
-  if (order === null || order < 0) return null;
-  return { minimum: policy.minimum, recommended: policy.recommended };
-}
-function runnerUpdateFor(policy, current = RUNNER_VERSION) {
-  const recommendedOrder = compareRunnerVersions(policy.recommended, current);
-  const minimumOrder = compareRunnerVersions(policy.minimum, current);
-  if (recommendedOrder === null || minimumOrder === null) return null;
-  if (recommendedOrder <= 0) return null;
-  return { target: policy.recommended, required: minimumOrder > 0 };
-}
-
 // src/protocol/client.ts
 var LeaseLostError = class extends Error {
   constructor(message) {
@@ -3619,7 +3677,8 @@ var TerminalReporter = class {
     this.say("");
     this.say(`  Chromium          ${input.chromium ? GREEN + "ready" + RESET : YELLOW + "not installed yet" + RESET}`);
     this.say(`  Connection        ${input.server}`);
-    this.say(`  Allowed here      ${input.allowedHosts.join(", ") || "nothing yet - run `aloud allow <host>`"}`);
+    this.say(`  Public sites      ${GREEN}automatic per study${RESET}`);
+    this.say(`  Private/local     ${input.allowedHosts.join(", ") || "nothing approved"}`);
     this.say("");
   }
   waiting(url) {
@@ -8104,6 +8163,26 @@ var VISUAL_SIGNATURE_STYLE = `
     box-shadow: none !important;
   }
 `;
+async function browserRequestRefusal(rawUrl, options, resourceType, resolver) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return `Not a valid request URL: ${rawUrl}`;
+  }
+  if (url.protocol === "data:" || url.protocol === "blob:") return null;
+  if (url.protocol !== "http:" && url.protocol !== "https:" && url.protocol !== "ws:" && url.protocol !== "wss:") {
+    return `Only HTTP(S) and WebSocket network requests are supported, got ${url.protocol}`;
+  }
+  const evaluatedUrl = url.protocol === "ws:" || url.protocol === "wss:" ? `${url.protocol === "wss:" ? "https:" : "http:"}//${url.host}${url.pathname}${url.search}` : rawUrl;
+  const restrictDocument = resourceType === "document" && options.blockOffDomainNavigation && options.allowedDomains.length > 0;
+  const verdict = await evaluateTargetUrl(evaluatedUrl, {
+    ...restrictDocument ? { allowedDomains: options.allowedDomains } : {},
+    allowPrivateNetwork: options.allowPrivateNetwork ?? false,
+    ...resolver ? { resolver } : {}
+  });
+  return verdict.allowed ? null : verdict.reason;
+}
 function digestOf(payload) {
   return createHash4("sha256").update(payload.title + " " + payload.controls + " " + payload.text + " " + payload.scrollY).digest("hex").slice(0, 24);
 }
@@ -8164,17 +8243,19 @@ var PlaywrightBrowserWorker = class {
         if (typeof window.__aloudRecordSubmit === "function") window.__aloudRecordSubmit();
       }, true);
     `);
-    if (this.options.blockOffDomainNavigation && this.options.allowedDomains.length > 0) {
-      const allowed = this.options.allowedDomains;
-      await this.context.route("**/*", async (route) => {
-        const url = route.request().url();
-        if (route.request().resourceType() === "document" && !isDomainAllowed(url, allowed)) {
-          await route.abort("blockedbyclient");
-          return;
-        }
-        await route.continue();
-      });
-    }
+    await this.context.route("**/*", async (route) => {
+      const request = route.request();
+      const refusal = await browserRequestRefusal(
+        request.url(),
+        this.options,
+        request.resourceType()
+      );
+      if (refusal) {
+        await route.abort("blockedbyclient");
+        return;
+      }
+      await route.continue();
+    });
     await this.page.goto(startUrl, { waitUntil: "domcontentloaded" });
     await this.settle();
     const capture = await this.capture();
@@ -8789,26 +8870,37 @@ var SnapshotRefused = class extends Error {
 async function sanitiseSnapshot(snapshot, lease, local, nowIso, resolver) {
   const granted = normaliseHosts(lease.allowedHosts);
   const permitted = normaliseHosts(local.allowedHosts);
-  const effective = intersectHosts(granted, permitted);
-  if (effective.length === 0) {
-    throw new SnapshotRefused(
-      `This study wants ${granted.join(", ") || "nothing"}, and this machine allows ${permitted.join(", ") || "nothing"}. Nothing in common, so nothing will be opened. Add a host with \`aloud allow <host>\` if that is wrong.`
-    );
-  }
   const startUrl = snapshot.study?.startUrl;
   if (typeof startUrl !== "string" || startUrl.length === 0) {
     throw new SnapshotRefused("This study has no start URL.");
   }
-  const verdict = leasePermits({ ...lease, allowedHosts: effective }, startUrl, nowIso);
+  const verdict = leasePermits({ ...lease, allowedHosts: granted }, startUrl, nowIso);
   if (!verdict.allowed) throw new SnapshotRefused(verdict.reason);
+  const access = await targetNetworkAccess(startUrl, resolver);
+  if (access.kind === "blocked") throw new SnapshotRefused(access.reason);
+  let effective;
+  let allowPrivateNetwork;
+  if (access.kind === "public") {
+    effective = granted.some((entry2) => hostPermitted(access.hostname, [entry2])) ? [access.hostname] : [];
+    allowPrivateNetwork = false;
+  } else {
+    effective = intersectHosts(granted, permitted);
+    allowPrivateNetwork = local.allowPrivateNetwork;
+  }
+  if (effective.length === 0) {
+    throw new SnapshotRefused(
+      `This private or local study wants ${granted.join(", ") || "nothing"}, and this machine allows ${permitted.join(", ") || "nothing"}. Nothing in common, so nothing will be opened. Add the private host with \`aloud allow <host>\` if that is intentional.`
+    );
+  }
   const target = await evaluateTargetUrl(startUrl, {
     allowedDomains: effective,
-    allowPrivateNetwork: local.allowPrivateNetwork,
+    allowPrivateNetwork,
     ...resolver ? { resolver } : {}
   });
   if (!target.allowed) throw new SnapshotRefused(target.reason);
   return {
     allowedHosts: effective,
+    allowPrivateNetwork,
     snapshot: {
       ...snapshot,
       environment: {
@@ -8923,7 +9015,7 @@ async function executeLease(deps) {
   const workers = new GuardedWorkerFactory(
     deps.workers ?? new PlaywrightWorkerFactory(),
     effective.allowedHosts,
-    deps.local
+    { ...deps.local, allowPrivateNetwork: effective.allowPrivateNetwork }
   );
   coordinator = new RunCoordinator(
     {
@@ -9093,13 +9185,16 @@ var MAX_PAGES = 6;
 var MAX_LINKS_PER_PAGE = 200;
 var PAGE_TIMEOUT_MS = 15e3;
 async function discoverProduct(job, local) {
-  const effectiveHosts = intersectHosts(job.allowedHosts, local.allowedHosts);
+  const access = await targetNetworkAccess(job.url);
+  if (access.kind === "blocked") throw new Error(`Refusing product discovery: ${access.reason}`);
+  const effectiveHosts = access.kind === "public" ? job.allowedHosts.some((host) => hostPermitted(access.hostname, [host])) ? [access.hostname] : [] : intersectHosts(job.allowedHosts, local.allowedHosts);
   if (effectiveHosts.length === 0) {
     throw new Error(
-      `Product discovery wants ${job.allowedHosts.join(", ")}, but this machine allows ${local.allowedHosts.join(", ") || "nothing"}.`
+      `Private product discovery wants ${job.allowedHosts.join(", ")}, but this machine allows ${local.allowedHosts.join(", ") || "nothing"}.`
     );
   }
-  await assertTarget(job.url, effectiveHosts, local);
+  const allowPrivateNetwork = access.kind === "private" && local.allowPrivateNetwork;
+  await assertTarget(job.url, effectiveHosts, allowPrivateNetwork);
   const browser = await chromium2.launch({
     args: ["--disable-dev-shm-usage"],
     handleSIGINT: false,
@@ -9115,7 +9210,7 @@ async function discoverProduct(job, local) {
     serviceWorkers: "block"
   });
   try {
-    await guardRequests(context, effectiveHosts, local);
+    await guardRequests(context, effectiveHosts, allowPrivateNetwork);
     const start2 = canonicalUrl(job.url);
     const origin = new URL(start2).origin;
     const queued = [start2];
@@ -9126,7 +9221,7 @@ async function discoverProduct(job, local) {
       if (seen.has(url)) continue;
       seen.add(url);
       try {
-        await assertTarget(url, effectiveHosts, local);
+        await assertTarget(url, effectiveHosts, allowPrivateNetwork);
         const page = await context.newPage();
         try {
           page.setDefaultTimeout(PAGE_TIMEOUT_MS);
@@ -9135,7 +9230,7 @@ async function discoverProduct(job, local) {
             await page.waitForLoadState("networkidle", { timeout: 1500 });
           } catch {
           }
-          await assertTarget(page.url(), effectiveHosts, local);
+          await assertTarget(page.url(), effectiveHosts, allowPrivateNetwork);
           const captured = await extractPage(page);
           pages.push(captured);
           const candidates = prioritiseDiscoveryLinks(captured.links, origin).map((link) => canonicalUrl(link.href)).filter((href) => !seen.has(href) && !queued.includes(href));
@@ -9156,14 +9251,14 @@ async function discoverProduct(job, local) {
     await browser.close();
   }
 }
-async function assertTarget(url, allowedDomains, local) {
+async function assertTarget(url, allowedDomains, allowPrivateNetwork) {
   const verdict = await evaluateTargetUrl(url, {
     allowedDomains,
-    allowPrivateNetwork: local.allowPrivateNetwork
+    allowPrivateNetwork
   });
   if (!verdict.allowed) throw new Error(`Refusing product discovery: ${verdict.reason}`);
 }
-async function guardRequests(context, allowedDomains, local) {
+async function guardRequests(context, allowedDomains, allowPrivateNetwork) {
   await context.route("**/*", async (route) => {
     const request = route.request();
     let url;
@@ -9181,15 +9276,13 @@ async function guardRequests(context, allowedDomains, local) {
       await route.abort("blockedbyclient");
       return;
     }
-    if (request.resourceType() === "document") {
-      const verdict = await evaluateTargetUrl(url.toString(), {
-        allowedDomains,
-        allowPrivateNetwork: local.allowPrivateNetwork
-      });
-      if (!verdict.allowed) {
-        await route.abort("blockedbyclient");
-        return;
-      }
+    const verdict = await evaluateTargetUrl(url.toString(), {
+      allowedDomains,
+      allowPrivateNetwork
+    });
+    if (!verdict.allowed) {
+      await route.abort("blockedbyclient");
+      return;
     }
     await route.continue();
   });
@@ -9278,9 +9371,13 @@ async function runLoop(deps) {
   deps.ui.waiting?.(deps.webUrl);
   while (!deps.signal?.aborted) {
     let claim = null;
+    const pollLocal = deps.loadLocalPolicy ? await deps.loadLocalPolicy() : deps.local;
     try {
       const response = await deps.client.request("api/runner/claim", {
         method: "POST",
+        // The machine owns private-network policy. Mirroring it on every outbound poll makes one
+        // `aloud allow` command sufficient and repairs a missed sync without human intervention.
+        body: { localAllowedHosts: pollLocal.allowedHosts },
         // A poll should fail fast and come back, not block for a minute holding the loop.
         retry: false,
         ...deps.signal ? { signal: deps.signal } : {}
@@ -9298,11 +9395,17 @@ async function runLoop(deps) {
       }
       throw error;
     }
+    if (claim?.kind === "runner_update") {
+      const policy = runnerVersionPolicyFrom(claim.runnerVersionPolicy);
+      if (policy && deps.onUpdateRequested && await deps.onUpdateRequested(policy)) break;
+      await sleep(POLL_NORMAL_MS);
+      continue;
+    }
     if (claim?.kind === "product_discovery" && claim.setupJob) {
       lastActivityAt = now();
       deps.ui.note(`Learning what ${new URL(claim.setupJob.url).hostname} does from its public pages.`);
       try {
-        const evidence = await discoverProduct(claim.setupJob, deps.local);
+        const evidence = await discoverProduct(claim.setupJob, pollLocal);
         await deps.client.request("api/runner/discovery", {
           method: "POST",
           body: { setupJobId: claim.setupJob.id, evidence },
@@ -9345,7 +9448,7 @@ async function runLoop(deps) {
       run: claim.run,
       productId: claim.productId ?? "",
       routing: claim.routing ?? {},
-      local: deps.local,
+      local: pollLocal,
       spool,
       ui: deps.ui,
       ...deps.workers ? { workers: deps.workers } : {},
@@ -10600,7 +10703,7 @@ function printHelp() {
       "  aloud start [--once] [--quiet] [--no-update]",
       "                                  Update, then wait for studies and run them here",
       "  aloud status                    What is set up, and whether it is running",
-      "  aloud allow <host>              Let studies open this host from this machine",
+      "  aloud allow <host>              Approve a private or local host on this machine",
       "  aloud mcp                       Serve MCP to an editor, using the saved credential",
       "  aloud mcp connect               Connect an editor, approving it in your browser",
       "  aloud logout                    Forget the token on this machine",
@@ -10700,7 +10803,8 @@ async function connectWith(server, token) {
   process.stdout.write(`
 Connected as ${credentials.runnerName}.
 `);
-  process.stdout.write(`Allowed here: ${credentials.allowedHosts.join(", ")}
+  process.stdout.write("Public sites: automatic for the study that names them.\n");
+  process.stdout.write(`Private/local: ${credentials.allowedHosts.join(", ") || "nothing approved"}
 `);
   reporter.privacyNote();
   process.stdout.write("Run `aloud start` and leave it running.\n\n");
@@ -10802,8 +10906,21 @@ async function setup() {
   );
   out(`  chromium       ${checks.chromiumInstalled ? "ready" : "downloads on first start, about 350 MB"}`);
   out(`  running        ${running ? `yes (pid ${running.pid})` : "no"}`);
+  out(
+    `  Aloud sees      ${signedIn.state === "ok" ? signedIn.online ? `yes${signedIn.lastVersion ? ` (v${signedIn.lastVersion})` : ""}${signedIn.lastSeenAt ? `, checked in ${when(signedIn.lastSeenAt)}` : ""}` : running ? "not yet. The local process exists, but no current check-in is confirmed" : "no" : signedIn.state === "unreachable" ? "unknown, the server did not answer" : "no"}`
+  );
   out();
-  if (process.stdin.isTTY) return interactiveSetup({ installed, stale, latest, signedIn, running, credentials });
+  if (process.stdin.isTTY) {
+    return interactiveSetup({
+      installed,
+      stale,
+      latest,
+      signedIn,
+      running,
+      credentials,
+      chromiumInstalled: checks.chromiumInstalled
+    });
+  }
   const steps = [];
   if (!installed) {
     steps.push(["npm install -g @aloud/runner"]);
@@ -10832,6 +10949,20 @@ async function setup() {
     out();
     return 1;
   }
+  if (steps.length === 0 && running && signedIn.state === "ok" && !signedIn.online) {
+    out("The runner process exists locally, but Aloud has not confirmed a current check-in.");
+    out(`Read ${join6(dirname5(credentialsPath()), "runner.log")} and run \`aloud status\` again.`);
+    out("Do not report this machine ready until `Aloud sees` says yes.");
+    out();
+    return 1;
+  }
+  if (steps.length === 0 && running && signedIn.state === "ok" && signedIn.online && signedIn.lastVersion !== RUNNER_VERSION) {
+    out(`The live process is checking in as v${signedIn.lastVersion ?? "unknown"}, not v${RUNNER_VERSION}.`);
+    out(`Restart it with:  kill ${running.pid} && aloud start`);
+    out("Do not report the update complete until `aloud status` shows the expected version.");
+    out();
+    return 1;
+  }
   if (steps.length === 0) {
     out("Nothing to do. This machine is set up and waiting for studies.");
     out();
@@ -10905,12 +11036,28 @@ async function interactiveSetup(state) {
         out("Start it when you are ready, and leave it running:  aloud start");
         return 1;
       }
-      return startDetached(out);
+      return startDetached(out, { waitForConfirmation: state.chromiumInstalled });
+    }
+    if (state.signedIn.state === "ok" && state.signedIn.online && state.signedIn.lastVersion === RUNNER_VERSION) {
+      out("");
+      out("Set up and confirmed by Aloud. This machine is waiting for eligible studies.");
+      out("");
+      return 0;
+    }
+    if (state.signedIn.state === "ok" && state.signedIn.online) {
+      out("");
+      out(
+        `The live process is checking in as v${state.signedIn.lastVersion ?? "unknown"}, not v${RUNNER_VERSION}.`
+      );
+      out(`Restart it with:  kill ${state.running.pid} && aloud start`);
+      out("");
+      return 1;
     }
     out("");
-    out("Set up. This machine is waiting for studies.");
+    out("The runner process exists locally, but Aloud has not confirmed a current check-in.");
+    out(`Read ${join6(dirname5(credentialsPath()), "runner.log")} and run \`aloud status\` again.`);
     out("");
-    return 0;
+    return 1;
   } finally {
     rl.close();
   }
@@ -10930,9 +11077,11 @@ async function run(command, args, out) {
     child.on("close", (code) => resolve(code === 0));
   });
 }
-async function startDetached(out) {
+async function startDetached(out, options) {
   const log = join6(dirname5(credentialsPath()), "runner.log");
   await mkdir5(dirname5(log), { recursive: true, mode: 448 });
+  const credentials = await readCredentials();
+  const before = credentials ? await readRunnerPresence({ server: credentials.server, token: credentials.token }) : null;
   const handle = openSync(log, "a");
   const child = spawn2(process.execPath, [process.argv[1] ?? "", "start"], {
     detached: true,
@@ -10945,23 +11094,50 @@ async function startDetached(out) {
   out("  Check it    aloud status");
   out(`  Stop it     kill ${child.pid}`);
   out("");
-  out("The first start downloads Chromium, about 350 MB, once. Studies will wait until it is done.");
+  if (!options.waitForConfirmation) {
+    out("The runner is preparing Chromium in the background. It is started locally, but not yet");
+    out("confirmed by Aloud. The Machines page updates automatically after its first check-in.");
+    out("");
+    return 0;
+  }
+  if (!credentials || before?.state !== "ok") {
+    out("Started locally, but Aloud could not establish a before-start status to confirm this launch.");
+    out(`Read ${log} and run \`aloud status\`; do not call it ready until \`Aloud sees\` says yes.`);
+    out("");
+    return 1;
+  }
+  out("Waiting for Aloud to confirm the first check-in\u2026");
+  const confirmation = await waitForRunnerCheckIn({
+    server: credentials.server,
+    token: credentials.token,
+    previousLastSeenAt: before.presence.lastSeenAt
+  });
+  if (confirmation === "confirmed") {
+    out("Confirmed by Aloud. This machine is online and waiting for eligible studies.");
+    out("");
+    return 0;
+  }
+  if (confirmation === "revoked") {
+    out("Aloud refused the saved connection. Run `aloud login` to approve this machine again.");
+  } else {
+    out("The process started, but Aloud did not confirm a check-in within 15 seconds.");
+    out(`Read ${log} and run \`aloud status\`; do not call it ready until \`Aloud sees\` says yes.`);
+  }
   out("");
-  return 0;
+  return 1;
 }
 async function signedInState(credentials) {
   if (!credentials) return { state: "none" };
-  try {
-    const response = await fetch(new URL("api/runner/me", credentials.server + "/"), {
-      headers: { authorization: `Bearer ${credentials.token}` },
-      signal: AbortSignal.timeout(5e3)
-    });
-    if (response.status === 401 || response.status === 403) return { state: "revoked" };
-    if (!response.ok) return { state: "unreachable", server: credentials.server };
-    return { state: "ok", name: credentials.runnerName };
-  } catch {
-    return { state: "unreachable", server: credentials.server };
-  }
+  const result = await readRunnerPresence({ server: credentials.server, token: credentials.token });
+  if (result.state === "revoked") return { state: "revoked" };
+  if (result.state === "unreachable") return { state: "unreachable", server: credentials.server };
+  return {
+    state: "ok",
+    name: credentials.runnerName,
+    online: result.presence.online,
+    lastSeenAt: result.presence.lastSeenAt,
+    lastVersion: result.presence.lastVersion
+  };
 }
 async function npmPrefix() {
   const path = await new Promise((resolve) => {
@@ -11136,6 +11312,7 @@ async function status() {
   });
   const checks = await preflight();
   const running = await readRunning();
+  const signedIn = await signedInState(credentials);
   process.stdout.write("\n");
   if (!credentials) {
     process.stdout.write("Signed in       no. Run `aloud login`.\n");
@@ -11144,8 +11321,11 @@ async function status() {
 `);
     process.stdout.write(`Server          ${credentials.server}
 `);
-    process.stdout.write(`Allowed here    ${credentials.allowedHosts.join(", ") || "nothing yet"}
-`);
+    process.stdout.write("Public sites    automatic per study\n");
+    process.stdout.write(
+      `Private/local  ${credentials.allowedHosts.join(", ") || "nothing approved"}
+`
+    );
   }
   process.stdout.write(
     `Chromium        ${checks.chromiumInstalled ? `ready (${checks.chromiumPath})` : "not installed yet"}
@@ -11153,15 +11333,19 @@ async function status() {
   );
   process.stdout.write(
     `Running         ${running ? `yes, since ${when(running.startedAt)} (pid ${running.pid})` : "no. Run `aloud start`."}
+`
+  );
+  process.stdout.write(
+    `Aloud sees      ${signedIn.state === "ok" ? signedIn.online ? `yes${signedIn.lastVersion ? ` (v${signedIn.lastVersion})` : ""}${signedIn.lastSeenAt ? `, checked in ${when(signedIn.lastSeenAt)}` : ""}` : "no current check-in" : signedIn.state === "unreachable" ? "unknown, server did not answer" : "no"}
 `
   );
   process.stdout.write("\n");
-  return credentials && checks.chromiumInstalled && running ? 0 : 1;
+  return credentials && checks.chromiumInstalled && running && signedIn.state === "ok" && signedIn.online ? 0 : 1;
 }
 async function allow(argv) {
   const host = argv.find((arg) => !arg.startsWith("-"));
   if (!host) {
-    process.stderr.write("Which host? For example: aloud allow staging.acme.com\n");
+    process.stderr.write("Which private or local host? For example: aloud allow internal.acme.test\n");
     return 1;
   }
   const credentials = await readCredentials();
@@ -11172,9 +11356,10 @@ async function allow(argv) {
   const next = normaliseHosts([...credentials.allowedHosts, host]);
   await writeCredentials({ ...credentials, allowedHosts: next });
   process.stdout.write(`
-Studies on this machine may now open: ${next.join(", ")}
+Private/local access approved for: ${next.join(", ")}
 `);
-  process.stdout.write("Nothing the server sends can change that list. Only this command can.\n\n");
+  process.stdout.write("A running runner syncs this on its next poll; otherwise the next start does.\n");
+  process.stdout.write("Public sites work automatically per study. Nothing the server sends can widen this private list.\n\n");
   return 0;
 }
 async function start(argv) {
@@ -11207,10 +11392,6 @@ To restart it: kill ${existing.pid} && aloud start
     }
   }
   const local = policyOf(credentials, argv);
-  if (local.allowedHosts.length === 0) {
-    process.stderr.write("This machine is not allowed to open anything. Try `aloud allow localhost`.\n");
-    return 1;
-  }
   const client = new RunnerClient({
     server: credentials.server,
     token: credentials.token,
@@ -11227,14 +11408,35 @@ To restart it: kill ${existing.pid} && aloud start
   installSignalHandlers(controller, reporter);
   await writeRunning({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString(), server: credentials.server });
   process.on("exit", () => clearRunningSync());
+  let attemptedIdleUpdate = null;
   try {
     await runLoop({
       client,
       local,
+      loadLocalPolicy: async () => {
+        const current = await readCredentials();
+        return current && current.runnerId === credentials.runnerId ? policyOf(current, argv) : policyFrom({ allowedHosts: [], allowPrivateNetwork: false });
+      },
       ui: reporter,
       webUrl: `${credentials.server}/app`,
       once: argv.includes("--once"),
-      signal: controller.signal
+      signal: controller.signal,
+      onUpdateRequested: async (policy) => {
+        if (attemptedIdleUpdate === policy.recommended) return false;
+        attemptedIdleUpdate = policy.recommended;
+        reporter.note(`Runner ${policy.recommended} is ready. Updating now while this machine is idle.`);
+        await clearRunning();
+        const result = await updateBeforeStart(credentials, argv, {
+          versionPolicy: async () => policy
+        });
+        if (result !== null) return true;
+        await writeRunning({
+          pid: process.pid,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          server: credentials.server
+        });
+        return false;
+      }
     });
     return 0;
   } catch (error) {