@nomac/cli 0.11.6 → 0.11.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomac/cli",
-  "version": "0.11.6",
+  "version": "0.11.8",
   "description": "Cloud Mac sessions over SSH and HTTPS, plus iOS builds and publishing — built for agents.",
   "license": "UNLICENSED",
   "type": "module",

package/skill/SKILL.md

@@ -21,32 +21,47 @@ commands and tools. Mac time is prepaid credit, separate from Builder.
    details yourself. Poll credits until the balance appears; a checkout URL is
    not a payment. No Apple Developer account is needed for an unsigned build.
 2. Install `npm install -g @nomac/cli`, run `nomac login`, and give the human
-   the printed device URL and code. MCP: `claude mcp add nomac -- npx @nomac/cli mcp`.
+   the printed device URL and code. With a key the human made at
+   https://nomac.app/keys: `nomac login --with-token < key.txt`, or set
+   `NOMAC_API_KEY`. MCP: `claude mcp add nomac -- npx @nomac/cli mcp`.
    Hosted MCP: https://mcp.nomac.app/mcp with `Authorization: Bearer <nmk_key>`.
 3. `nomac start --json`, wait until ready, `nomac sync .`, then `nomac ssh`.
    Run commands with `nomac exec -- COMMAND`: it prints the output and exits
    with the command's code, waiting at most 30 s. For builds and tests use
    `nomac exec --wait 600 -- COMMAND`. Exit code 75 means still running: wait
    with `nomac job JOB_ID --wait 600`, never rerun. In scripts add
-   `--request-key stable-key-0001`. Over ten minutes, use `nomac ssh -- COMMAND`. MCP equivalents are `start_mac`, `exec_mac` (also waits),
+   `--request-key stable-key-0001`. A command may run an hour (`--timeout
+   3600`); longer, use `nomac ssh -- COMMAND`. A command ends with everything
+   it started, so keep a dev server running with `nomac exec -- nomac-service
+   start api -- npx wrangler dev` (`nomac-service logs api`, `stop api`).
+   `nomac cancel JOB_ID` stops a command. MCP equivalents are `start_mac`, `exec_mac` (also waits),
    `write_mac_file`, `read_mac_file`, `fetch_to_mac`, `stop_mac`. For a file
    up to 2 GiB from the human, or to hand them a build, use
    `create_mac_upload_link` and `create_mac_download_link`: each returns a url
    they open in a browser.
-4. Download work with `nomac pull ./build` (use `--from PATH` for another
-   remote directory), then `nomac stop --json`. Confirm `cleanup_confirmed`.
-
-Stopping deletes files and logs. Download before stopping. SSH disconnects
+4. Download work with `nomac pull ./build`, or to any local path with the
+   folder on the Mac named: `nomac pull /tmp/out --from build/export`. Then
+   `nomac stop --json` and confirm `cleanup_confirmed`.
+
+The CLI keeps the project on the account's drive, in `~/drive/src/<folder
+name>`, which is kept between sessions; stopping deletes everything else on
+the Mac, logs included. Download what you need from outside `~/drive` before
+stopping. SSH disconnects
 do not stop the session. Ready time includes idle time; queue/setup are free.
 One-minute minimum, then by the minute. One session at a time; no overage.
 If start returns `insufficient_credit`, buy credit as in step 1, then retry
 with the same request key.
 Keep the same request key and arguments after uncertain responses; inspect
 the original job before retrying. Output retrieval failure is not job failure.
-Managed jobs have a 600-second limit; SSH can run longer within session limits.
+A command runs up to its `timeout_seconds` (300 by default, 3600 at most) and
+says so when that limit stops it; SSH can run longer within session limits.
 CLI sync sends every file (.env and keys included) and symlinks as links, and
 skips dependency and build folders, .git and folders .gitignore lists; a `!`
-line in .nomacignore sends any of them. It preserves remote extra files. See the screen with `nomac screenshot` (saves
+line in .nomacignore sends any of them. A file changed on the Mac since the
+last sync is left alone and named (the rest is sent, and sync exits 1): `nomac
+pull` it, or `nomac sync . --overwrite`. Sync deletes nothing on the Mac
+unless `--delete`, which removes what it sent earlier and you deleted here.
+See the screen with `nomac screenshot` (saves
 `nomac-screenshot.jpg`; `--simulator` for the iOS Simulator) or MCP
 `screenshot_mac`, which returns an image you can look at. Record a video for
 the human with `nomac record`, do the work, then `nomac record stop` (saves the
@@ -58,7 +73,10 @@ keyboard and mouse, also on the lock screen and in password dialogs, use
 and give the human `open_mac_desktop` when they want to see the screen.
 `get_mac_session` (and `nomac status --json`) lists what
 is installed: Ruby with CocoaPods, xcbeautify, xcodegen, gh, Git LFS, jq.
-Pipe xcodebuild through `xcbeautify`. Persistent disks are not currently offered.
+Pipe xcodebuild through `xcbeautify`. Simulator devices share names across iOS
+runtimes: pick one by ID (`xcrun simctl list devices available`) or with
+`OS=27.0` in `-destination`. Apple Intelligence cannot generate on a virtual
+Mac, in the Simulator either: test it on a device.
 Report failures using `report_issue` with `session_id`, optional `job_id` and
 a description without secrets. Read https://nomac.app/llms.txt for full limits.
 
@@ -84,7 +102,10 @@ secrets as variables and files, masked in command output; `nomac secrets
 install` refreshes a running Mac.
 
 The human connects Apple once at https://nomac.app/apple; the App Store
-Connect key stays on NoMac's server. Then, on the Mac:
+Connect key stays on NoMac's server. Check `nomac apple` (MCP
+`connect_status`) before asking them: it shows the key, certificates and
+profiles already there. Then, from your project folder (the CLI acts on the
+Mac):
 
 1. `nomac sign [path]` (MCP `set_up_signing`) makes and installs the App Store
    profiles the project needs and prints the files, the reserved build number

package/src/cli.mjs

@@ -17,6 +17,7 @@ Use it:
   nomac exec -- ls             run a command; prints its output, keeps its exit code
   nomac exec --wait 600 -- xcodebuild test
                                wait up to 10 minutes (the default is 30 seconds)
+  nomac cancel JOB_ID          stop a running command and everything it started
   nomac ssh                    open a shell (nomac ssh -- command runs one)
   nomac sync .                 upload changed project files
   nomac pull ./build           download a folder from the Mac
@@ -31,6 +32,7 @@ Use it:
   nomac record                 record a video; nomac record stop saves it with a share link
   nomac status                 state, cost so far and when it stops
   nomac secrets                variables and files every Mac receives (nomac secrets --help)
+  nomac apple                  whether Apple is connected: team key, certificates, profiles
   nomac sign [path]            set up App Store signing for the project on the Mac
   nomac testflight app.ipa     send a signed .ipa on the Mac to TestFlight
   nomac publish app.ipa        submit it for App Review (--confirm sends it)
@@ -151,14 +153,20 @@ export async function main(argv) {
       return secretsCommand(rest, { store: sessionStore() });
     }
     case "login": {
-      const key = rest[0];
+      // A key the person made at nomac.app/keys: as an argument, or on stdin with --with-token
+      // (kept out of shell history and the process list).
+      const key = rest[0] === "--with-token" ? (await readStdin()).trim() : rest[0];
       if (key) {
-        // direct-key path for CI / power users
-        if (!key.startsWith("nmk_")) {
-          throw new CliError("bad key", "Usage: nomac login nmk_…  (or just `nomac login` to approve in the browser)");
+        if (!/^nmk_[0-9a-f]{40}$/.test(key)) {
+          throw new CliError("bad key", "Usage: nomac login --with-token < key.txt, or nomac login nmk_…  (or just `nomac login` to approve in the browser). Keys start with nmk_ and are made at https://nomac.app/keys.");
         }
+        // Checked before it replaces the saved one.
+        const previous = process.env.NOMAC_API_KEY;
+        process.env.NOMAC_API_KEY = key;
+        let me;
+        try { me = await api("GET", "/api/v1/me"); }
+        finally { if (previous === undefined) delete process.env.NOMAC_API_KEY; else process.env.NOMAC_API_KEY = previous; }
         saveApiKey(key);
-        const me = await api("GET", "/api/v1/me");
         console.log(`✅ logged in: org "${me.org.name}" (${me.org.id})`);
         return;
       }
@@ -182,6 +190,13 @@ export async function main(argv) {
       const { runMcpServer } = await import("./mcp.mjs");
       return runMcpServer();
     }
+    case "apple": {
+      if (rest.some(arg => arg !== "--json")) throw new CliError("apple usage", "Usage: nomac apple [--json]\n  The account's Apple connection, signing certificates and profiles.");
+      const view = await api("GET", "/api/v1/apple");
+      if (rest.includes("--json")) { console.log(JSON.stringify(view, null, 2)); return view; }
+      console.log(describeApple(view));
+      return view;
+    }
     case "whoami": {
       const [me, credit] = await Promise.all([api("GET", "/api/v1/me"), api("GET", "/api/v1/mac/credits").catch(() => null)]);
       const o = me.org ?? {}, c = credit?.credits ?? credit ?? {};
@@ -208,6 +223,27 @@ export async function main(argv) {
   }
 }
 
+async function readStdin() {
+  if (process.stdin.isTTY) throw new CliError("no key on stdin", "Pipe the key in: nomac login --with-token < key.txt");
+  let text = "";
+  for await (const chunk of process.stdin) { text += chunk; if (text.length > 1024) break; }
+  return text;
+}
+
+/** What the account has for Apple, for a person or an agent deciding whether to ask anyone. */
+export function describeApple(view) {
+  const accounts = view.apple_accounts ?? [], identities = (view.identities ?? []).filter(id => id.state === "active"), profiles = view.profiles ?? [];
+  if (!accounts.length && !identities.length) {
+    return "Apple: not connected. The account owner connects an App Store Connect team key once at https://nomac.app/apple (only a person can); until then nomac sign and nomac testflight cannot reach Apple.";
+  }
+  const lines = accounts.map(a => `Apple: connected (App Store Connect key ${a.key_id}, issuer ${a.issuer_id}), ${a.status}, since ${String(a.connected_at).slice(0, 10)}.`);
+  if (!accounts.length) lines.push("Apple: no App Store Connect key connected; the certificates below still reach every Mac. Connect one at https://nomac.app/apple to make profiles and send to TestFlight.");
+  lines.push(identities.length ? `Certificates on every Mac: ${identities.map(id => `${id.name} (until ${String(id.expires_at).slice(0, 10)})`).join("; ")}.` : "Certificates: none yet; nomac sign makes the App Store one when needed.");
+  lines.push(profiles.length ? `Profiles: ${profiles.map(p => `${p.bundle_id} (${p.type})`).join(", ")}.` : "Profiles: none yet; nomac sign makes them for a project.");
+  lines.push("Next: nomac sign [path] from your project folder, then nomac testflight App.ipa.");
+  return lines.join("\n");
+}
+
 async function ensureProject() {
   const state = loadProjectState();
   if (state.project_id) return state;

package/src/hosted-sessions.mjs

@@ -19,9 +19,12 @@ const HELP = `Nomac cloud Mac sessions
                                     password prompts, its login password in
                                     $NOMAC_MAC_PASSWORD. --prompts ask keeps macOS's
                                     usual prompts.
-  nomac sync . [--dry-run]           upload changed files to the project folder on the Mac:
+  nomac sync . [--dry-run] [--delete]
+                                    upload changed files to the project folder on the Mac:
                                     ~/drive/src/<this folder's name>, kept between sessions
-                                    (~/workspace with --drive none)
+                                    (~/workspace with --drive none). A file changed on the Mac
+                                    since is left alone and named (--overwrite replaces it);
+                                    --delete also removes there what you deleted here
   nomac ssh [--forward 8080:3000]    full Mac shell and port forwarding
   nomac ssh -- command args         run any command over SSH
   nomac desktop [--no-open] [--json] the full macOS desktop in your browser
@@ -49,7 +52,9 @@ const HELP = `Nomac cloud Mac sessions
   nomac job JOB_ID [--wait 600]     wait for a command that outlasted --wait
   nomac output JOB_ID [--cursor 0] [--stream stdout|stderr]
   nomac cancel JOB_ID               stop a running command and everything it started
-  nomac pull ./output [--from PATH] retrieve files before stopping
+  nomac pull LOCAL [--from PATH]    copy files from the Mac: LOCAL is a folder or file here
+                                    (./out, /tmp/shots, ~/Downloads/App.ipa), PATH is relative
+                                    to the project folder on the Mac (default: LOCAL)
   nomac screenshot [--simulator] [-o FILE]
                                     save the screen (or the Simulator) as a JPEG,
                                     nomac-screenshot.jpg unless -o
@@ -73,7 +78,7 @@ const options = {
   help: { type: "boolean" }, json: { type: "boolean" }, wait: { type: "string" },
   "max-duration": { type: "string" }, "idle-timeout": { type: "string" },
   "max-cost": { type: "string" }, "request-key": { type: "string" }, timeout: { type: "string" },
-  overwrite: { type: "boolean" }, "dry-run": { type: "boolean" }, from: { type: "string" },
+  overwrite: { type: "boolean" }, "dry-run": { type: "boolean" }, from: { type: "string" }, delete: { type: "boolean" },
   forward: { type: "string", multiple: true }, cursor: { type: "string" }, stream: { type: "string" },
   "no-open": { type: "boolean" }, simulator: { type: "boolean" }, output: { type: "string", short: "o" }, max: { type: "string" },
   prompts: { type: "string" }, gatekeeper: { type: "string" }, copy: { type: "boolean" }, app: { type: "boolean" },
@@ -177,7 +182,15 @@ const NOTICE_MS = 5000;
  * running keeps running on the Mac; the CLI says how to wait for it and exits
  * 75. --wait 0 only starts it.
  */
-async function waitForCommand(id, base, started, waitSeconds, { request, transport, cache, print, stdout, stderr, exitWith, sleep, now, json }) {
+/** "13:05 UTC", when a running command's time limit stops it. */
+const stopsAt = job => Number.isFinite(job?.deadline) && job.deadline > Date.UTC(2020, 0) ? ` Its time limit (--timeout) stops it at ${new Date(job.deadline).toISOString().slice(11, 16)} UTC.` : "";
+/** Why a command ended without an exit code of its own: its time limit, or a cancel. */
+function endedBy(job, timeoutSeconds) {
+  if (job.reason === "timeout") return `${job.id} was stopped by its time limit${timeoutSeconds ? ` (--timeout ${timeoutSeconds})` : " (--timeout)"}, not by an error of its own. Run it again with a longer --timeout, up to 3600 seconds; for a server that should keep running, use nomac-service on the Mac.`;
+  if (job.reason === "cancelled") return `${job.id} was cancelled (nomac cancel).`;
+  return null;
+}
+async function waitForCommand(id, base, started, waitSeconds, { request, transport, cache, print, stdout, stderr, exitWith, sleep, now, json, timeoutSeconds }) {
   let job = started;
   const deadline = now() + waitSeconds * 1000;
   const begun = now();
@@ -204,10 +217,10 @@ async function waitForCommand(id, base, started, waitSeconds, { request, transpo
     const unknown = job.state === "unknown";
     const busyNote = busy ? "The Mac is busy (for example, the iOS Simulator is booting) and answers slowly. " : "";
     const next = unknown ? `The Mac could not confirm whether ${job.id} finished. Inspect it with nomac job ${job.id}; do not rerun it.`
-      : `${busyNote}Still running after ${waitSeconds} s; it keeps running on the Mac. Wait for it: nomac job ${job.id} --wait 600. Next time wait up front: nomac exec --wait 600 -- command. Over an hour: nomac ssh -- command. Do not rerun it; to stop it: nomac cancel ${job.id}.`;
+      : `${busyNote}Still running after ${waitSeconds} s; it keeps running on the Mac.${stopsAt(job)} Wait for it: nomac job ${job.id} --wait 600. Next time wait up front: nomac exec --wait 600 -- command. Over an hour: nomac ssh -- command. Do not rerun it; to stop it: nomac cancel ${job.id}.`;
     if (json) print(JSON.stringify({ ...job, ...(busy ? { busy: true } : {}), next_step: next }, null, 2));
     else if (unknown) stderr(`nomac: ${next}\n`);
-    else stderr(`nomac: ${busy ? "the Mac is busy (for example, the iOS Simulator is booting); " : ""}still running after ${waitSeconds} s (${job.id}); it keeps running on the Mac.\n  wait for it:            nomac job ${job.id} --wait 600\n  stop it:                nomac cancel ${job.id}\n  next time, wait longer: nomac exec --wait 600 -- command\n  over an hour:           nomac ssh -- command\n`);
+    else stderr(`nomac: ${busy ? "the Mac is busy (for example, the iOS Simulator is booting); " : ""}still running after ${waitSeconds} s (${job.id}); it keeps running on the Mac.${stopsAt(job)}\n  wait for it:            nomac job ${job.id} --wait 600\n  stop it:                nomac cancel ${job.id}\n  next time, wait longer: nomac exec --wait 600 -- command\n  over an hour:           nomac ssh -- command\n`);
     exitWith(unknown ? 1 : STILL_RUNNING);
     return job;
   }
@@ -225,9 +238,9 @@ async function waitForCommand(id, base, started, waitSeconds, { request, transpo
     return Buffer.concat(parts);
   };
   const [out, err] = await Promise.all([read("stdout"), read("stderr")]);
-  const streams = { stdout: out, stderr: err };
-  if (json) print(JSON.stringify({ ...job, stdout: streams.stdout.toString("utf8"), stderr: streams.stderr.toString("utf8") }, null, 2));
-  else { stdout(streams.stdout); stderr(streams.stderr); }
+  const streams = { stdout: out, stderr: err }, ended = endedBy(job, timeoutSeconds);
+  if (json) print(JSON.stringify({ ...job, stdout: streams.stdout.toString("utf8"), stderr: streams.stderr.toString("utf8"), ...(ended ? { next_step: ended } : {}) }, null, 2));
+  else { stdout(streams.stdout); stderr(streams.stderr); if (ended) stderr(`nomac: ${ended}\n`); }
   exitWith(typeof job.exit_code === "number" ? job.exit_code : 1);
   return job;
 }
@@ -413,7 +426,13 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
   if (command === "status") {
     if (positionals.length) throw new CliError("Usage: nomac status [--json]");
     const loaded = store.load();
-    if (!loaded) { print(values.json ? JSON.stringify({ session: null }) : "No Mac in this folder. Start one: nomac start"); return null; }
+    if (!loaded) {
+      // Run from another folder, the account's Mac may well be running: say so rather than "none".
+      const live = await liveSessions().catch(() => []);
+      if (values.json) print(JSON.stringify({ session: null, ...(live.length ? { running_elsewhere: live[0].id } : {}) }));
+      else print(live.length ? `No Mac in this folder, but your account's Mac ${live[0].id} is ${live[0].state}: run nomac in the project folder that started it, or use it from here with nomac attach.` : "No Mac in this folder. Start one: nomac start");
+      return null;
+    }
     const local = localSession(), result = await request("GET", `/api/v1/mac/sessions/${sessionId(local.id)}`);
     const session = saveView(local, result.session);
     // This folder's Mac has stopped, but the account may run another, started elsewhere.
@@ -468,7 +487,7 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
       throw error;
     });
     if (!waiting) return output(result);
-    return waitForCommand(local.id, base, result, integer(values.wait, 30, 0, 3600), { request, transport, cache, print, stdout, stderr, exitWith, sleep, now, json: Boolean(values.json) });
+    return waitForCommand(local.id, base, result, integer(values.wait, 30, 0, 3600), { request, transport, cache, print, stdout, stderr, exitWith, sleep, now, json: Boolean(values.json), timeoutSeconds: params.body?.timeout_seconds });
   }
   if (command === "screenshot") {
     if (positionals.length) throw new CliError("Usage: nomac screenshot [--simulator] [-o FILE]");
@@ -645,13 +664,13 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     await ready(local);
     if (command === "sync") {
       if (positionals.length > 1 || (positionals[0] && resolve(positionals[0]) !== store.project)) throw new CliError("Run nomac sync . from the attached project.");
-      const result = await syncProject(local, store, { overwrite: values.overwrite, dryRun: values["dry-run"], run });
+      const result = await syncProject(local, store, { overwrite: values.overwrite, dryRun: values["dry-run"], deleteMissing: values.delete, run });
       if (!values.json) { print(describeSync(result)); return result; }
       return output(result);
     }
     if (command === "pull") {
-      if (positionals.length !== 1) throw new CliError("Usage: nomac pull LOCAL_PATH [--from REMOTE_PATH]");
-      const result = await pullProject(local, store, positionals[0], { from: values.from ?? positionals[0], overwrite: values.overwrite, dryRun: values["dry-run"], run });
+      if (positionals.length !== 1) throw new CliError("Usage: nomac pull LOCAL_PATH [--from PATH_ON_THE_MAC]");
+      const result = await pullProject(local, store, positionals[0], { from: values.from, overwrite: values.overwrite, dryRun: values["dry-run"], run });
       if (!values.json) { print(describePull(result)); return result; }
       return output(result);
     }

package/src/mac-tools.mjs

@@ -40,7 +40,7 @@ export const MAC_TOOLS = [
     return text({ session_id, url, opened_in_browser: opened, message: opened ? "The desktop opened in the human's browser; they may need to sign in to nomac.app." : "Give the human this link; it opens after they sign in to nomac.app." });
   } },
   { name: "stop_mac", description: "Stop billing by shutting down the VM and deleting its files. Retrieve files first. Poll get_mac_session until cleanup_confirmed; stopping only acknowledges the request.", inputSchema: schema({ session_id: session }, ["session_id"]), handler: async args => text(await api("DELETE", base(args))) },
-  { name: "exec_mac", description: "Run any argv command in your cloud Mac workspace. Waits up to wait_seconds (default 20, max 50): a command that finishes in time returns its exit_code, stdout and stderr (first 64 KiB each, as text) in this one call, as soon as it finishes. For builds, tests and other slow commands pass wait_seconds: 50. A longer one returns its job ID: poll get_mac_job, then read_mac_output. Reuse request_key and identical arguments after lost responses; never rerun to get output. Use bash -lc explicitly for shell syntax. cwd runs it in another folder, such as ~/drive/src/app. timeout_seconds defaults to 300 and caps at 3600 (an hour) for builds and test runs; a first simulator boot takes about 90 seconds. cancel_mac_job stops a command. A command can be at most 64 KiB in total: put files on the Mac with write_mac_file (local_path, up to 2 GiB) or fetch_to_mac.", inputSchema: schema({ session_id: session, request_key: key, argv: { type: "array", items: { type: "string" }, minItems: 1 }, cwd: { type: "string", minLength: 1, maxLength: 1024, description: "The folder to run in: relative to the workspace, or ~/… and absolute paths anywhere on the Mac" }, timeout_seconds: { type: "integer", minimum: 1, maximum: 3600 }, wait_seconds: { type: "integer", minimum: 0, maximum: 50 } }, ["session_id", "request_key", "argv"]), handler: async ({ session_id, request_key, wait_seconds, ...body }) => text(await api("POST", `${base({ session_id })}/jobs?wait=${wait_seconds ?? 20}`, { body, idempotencyKey: request_key })) },
+  { name: "exec_mac", description: "Run any argv command in your cloud Mac workspace. Waits up to wait_seconds (default 20, max 50): a command that finishes in time returns its exit_code, stdout and stderr (first 64 KiB each, as text) in this one call, as soon as it finishes. For builds, tests and other slow commands pass wait_seconds: 50. A longer one returns its job ID: poll get_mac_job, then read_mac_output. Reuse request_key and identical arguments after lost responses; never rerun to get output. Use bash -lc explicitly for shell syntax. cwd runs it in another folder, such as ~/drive/src/app. timeout_seconds defaults to 300 and caps at 3600 (an hour) for builds and test runs; a first simulator boot takes about 90 seconds. cancel_mac_job stops a command. A command ends together with everything it started: keep a dev server running with [\"nomac-service\", \"start\", \"api\", \"--\", \"npx\", \"wrangler\", \"dev\"] (then nomac-service logs api, stop api). A command can be at most 64 KiB in total: put files on the Mac with write_mac_file (local_path, up to 2 GiB) or fetch_to_mac.", inputSchema: schema({ session_id: session, request_key: key, argv: { type: "array", items: { type: "string" }, minItems: 1 }, cwd: { type: "string", minLength: 1, maxLength: 1024, description: "The folder to run in: relative to the workspace, or ~/… and absolute paths anywhere on the Mac" }, timeout_seconds: { type: "integer", minimum: 1, maximum: 3600 }, wait_seconds: { type: "integer", minimum: 0, maximum: 50 } }, ["session_id", "request_key", "argv"]), handler: async ({ session_id, request_key, wait_seconds, ...body }) => text(await api("POST", `${base({ session_id })}/jobs?wait=${wait_seconds ?? 20}`, { body, idempotencyKey: request_key })) },
   { name: "write_mac_file", description: "Write a file on the Mac: local_path uploads a file from this machine, up to 2 GiB, without its content passing through you; or give content as text, or content_base64 for binary, up to 3 MiB. Relative Mac paths are in the session workspace; ~ is the home folder. Creates missing folders and replaces an existing file in one step; set executable for scripts. Safe to repeat. For a whole project use nomac sync; for larger files fetch_to_mac.", inputSchema: schema({ session_id: session, path: { type: "string", minLength: 1, maxLength: 1024 }, local_path: { type: "string" }, content: { type: "string" }, content_base64: { type: "string" }, executable: { type: "boolean" } }, ["session_id", "path"]), handler: async ({ session_id, path, local_path, content, content_base64, executable }) => {
     const given = [local_path, content, content_base64].filter(v => v !== undefined).length;
     if (given !== 1) return text({ error: { code: "invalid_request", message: "Give exactly one of local_path, content or content_base64." } });

package/src/session-store.mjs

@@ -13,6 +13,8 @@ export function sessionStore(projectDir = process.cwd(), stateDir = join(homedir
   chmodSync(directory, 0o700);
   const stateFile = join(directory, "session.json");
   const baselineFile = join(directory, "baseline.json");
+  // What each pull wrote, by local path: such a file, unchanged since, is not a local change.
+  const pulledFile = join(directory, "pulled.json");
   const read = (file) => {
     if (!existsSync(file)) return null;
     try { return JSON.parse(readFileSync(file, "utf8")); }
@@ -31,6 +33,8 @@ export function sessionStore(projectDir = process.cwd(), stateDir = join(homedir
     save: (value) => write(stateFile, value),
     baseline: () => read(baselineFile) ?? {},
     saveBaseline: (value) => write(baselineFile, value),
+    pulled: () => read(pulledFile) ?? {},
+    savePulled: (value) => write(pulledFile, value),
     async locked(operation) {
       const lock = join(directory, "operation.lock");
       try { mkdirSync(lock, { mode: 0o700 }); }

package/src/session-transfer.mjs

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { constants, copyFileSync, createReadStream, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, chmodSync, utimesSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import ignoreFactory from "ignore";
 import { CliError } from "./api.mjs";
@@ -23,6 +24,9 @@ const BUILT_IN = [
   { pattern: ".nomac/", reason: "NoMac's own files" },
   { pattern: ".nomac.json", reason: "NoMac's own files" },
   { pattern: ".nomac-transfer/", reason: "NoMac's own files" },
+  // nomac screenshot and nomac record save here unless -o says otherwise.
+  { pattern: "nomac-screenshot.jpg", reason: "saved by nomac screenshot" },
+  { pattern: "nomac-recording.mp4", reason: "saved by nomac record" },
 ];
 // Built-in patterns are names, matched against the entry's own name, so a folder
 // brought back with `!` is never skipped again through its parent.
@@ -93,7 +97,7 @@ export async function fingerprint(path) {
 }
 
 export function safeRelative(path) {
-  if (typeof path !== "string" || isAbsolute(path) || path.split(/[\\/]/).includes("..") || /[\x00-\x1f\x7f]/.test(path) || path.includes("\\")) throw new CliError("invalid relative path", "Use a path inside the Mac's workspace, relative and without '..' or control characters. Copy anything outside the workspace, such as /tmp, into it first.");
+  if (typeof path !== "string" || isAbsolute(path) || path.split(/[\\/]/).includes("..") || /[\x00-\x1f\x7f]/.test(path) || path.includes("\\")) throw new CliError("invalid relative path", `${JSON.stringify(String(path))} is not a path inside the project folder on the Mac: give one relative to it, without '..' (nomac status names the folder). Copy anything from elsewhere on the Mac, such as /tmp, into the project folder first.`);
   return posix.normalize(path || ".").replace(/\/$/, "") || ".";
 }
 
@@ -157,6 +161,46 @@ export async function remoteFingerprints(session, files, options) {
   return result;
 }
 
+// Removes files sync put on the Mac and the person has since deleted here: never through a
+// linked folder, and empty folders left behind go too (never the project folder itself).
+const REMOTE_DELETE = `
+use strict; use warnings;
+use JSON::PP; use Encode qw(encode_utf8);
+my $json = JSON::PP->new->utf8;
+my $names = $json->decode(do { local $/; <STDIN> });
+die "Invalid file list" unless ref($names) eq 'ARRAY';
+my (@removed, %folders);
+for my $name (@$names) {
+  die "Invalid path" if ref($name) || $name =~ m{^/|(?:^|/)\\.\\.(?:/|$)|[\\x00-\\x1f\\x7f\\\\]};
+  my $file = './' . encode_utf8($name);
+  my @parts = split m{/}, $file;
+  pop @parts;
+  my $unsafe = 0;
+  for (my @up = @parts; @up > 1; pop @up) { if (-l join('/', @up)) { $unsafe = 1; last; } }
+  next if $unsafe || !(-l $file || -f $file);
+  if (unlink $file) {
+    push @removed, $name;
+    for (my @up = @parts; @up > 1; pop @up) { $folders{join('/', @up)} = 1; }
+  }
+}
+rmdir $_ for sort { length($b) <=> length($a) } keys %folders;
+print $json->encode(\\@removed);
+`;
+
+async function removeOnMac(session, paths, options) {
+  const removed = [];
+  for (let offset = 0; offset < paths.length; offset += 1000) {
+    const batch = paths.slice(offset, offset + 1000);
+    for (const path of batch) safeRelative(path);
+    const { stdout } = await remote(session, `cd ${shellQuote(validateWorkspace(session.workspace))} && perl -e ${shellQuote(REMOTE_DELETE)}`, { ...options, input: JSON.stringify(batch) });
+    let values;
+    try { values = JSON.parse(stdout); } catch { throw new CliError("invalid remote delete response"); }
+    if (!Array.isArray(values) || values.some(value => !batch.includes(value))) throw new CliError("invalid remote delete response");
+    removed.push(...values);
+  }
+  return removed;
+}
+
 function transferArgs() {
   const bridge = fileURLToPath(new URL("../bin/rsync-ssh.mjs", import.meta.url));
   return ["-rpt", "--checksum", "--itemize-changes", "--stats", "--timeout=60", "-e", [process.execPath, bridge].map(rsyncQuote).join(" ")];
@@ -178,10 +222,12 @@ const megabytes = bytes => `${(bytes / 1_000_000).toFixed(bytes < 10_000_000 ? 1
 /** The human summary of a sync: what changed, how much was considered, and what stayed behind. */
 export function describeSync(result) {
   const lines = [`${result.dry_run ? "Would sync" : "Synced"} ${result.changed.length} changed of ${result.files} files (${megabytes(result.bytes)}${result.links ? `, ${result.links} links` : ""}).`];
+  if (result.conflicts?.length) lines.push(`Would not send, changed on the Mac since the last sync: ${result.conflicts.slice(0, 10).join(", ")}${result.conflicts.length > 10 ? ` and ${result.conflicts.length - 10} more` : ""}.`);
+  if (result.deleted?.length) lines.push(`${result.dry_run ? "Would delete" : "Deleted"} on the Mac, as here: ${result.deleted.slice(0, 10).join(", ")}${result.deleted.length > 10 ? ` and ${result.deleted.length - 10} more` : ""}.`);
+  if (result.kept_on_mac?.length) lines.push(`Kept on the Mac, changed there since: ${result.kept_on_mac.slice(0, 10).join(", ")}${result.kept_on_mac.length > 10 ? ` and ${result.kept_on_mac.length - 10} more` : ""}.`);
   if (result.skipped.length) {
-    lines.push("Skipped (add the line to .nomacignore to send it):");
-    for (const item of result.skipped.slice(0, 20)) lines.push(`  ${item.path}  ${item.reason}  ${item.send_with}`);
-    if (result.skipped.length > 20) lines.push(`  …and ${result.skipped.length - 20} more (--json lists all)`);
+    const shown = result.skipped.slice(0, 6).map(item => `${item.path} (${item.reason})`).join(", ");
+    lines.push(`Not sent: ${shown}${result.skipped.length > 6 ? `, and ${result.skipped.length - 6} more (--json lists them)` : ""}. To send one, add a line such as ${result.skipped[0].send_with} to .nomacignore.`);
   }
   return lines.join("\n");
 }
@@ -198,28 +244,57 @@ function conflictError(paths, side) {
   return error;
 }
 
-export async function syncProject(session, store, { overwrite = false, dryRun = false, run = runProcess } = {}) {
+/** Sync's own refusal: what was sent, and the files left alone because they changed on the Mac. */
+const listed = paths => paths.slice(0, 10).join(", ") + (paths.length > 10 ? ` and ${paths.length - 10} more` : "");
+function syncConflictError(paths, sent, removal = {}) {
+  // What --delete did in the same run is said too: the refusal is the last word, not the only one.
+  const removed = removal.deleted?.length ? ` Deleted on the Mac, as here: ${listed(removal.deleted)}.` : "";
+  const kept = removal.kept_on_mac?.length ? ` Kept on the Mac, changed there since: ${listed(removal.kept_on_mac)}.` : "";
+  const error = new CliError("transfer conflict", `${sent ? `Sent ${sent} changed ${sent === 1 ? "file" : "files"}. ` : ""}Not sent, because ${paths.length === 1 ? "it" : "they"} changed on the Mac since this folder last synced: ${listed(paths)}. Keep the Mac's version: nomac pull ${paths[0]}. Replace it with yours: nomac sync . --overwrite${removed}${kept}`);
+  error.code = "transfer_conflict";
+  error.details = { paths, side: "Remote", sent, ...removal };
+  return error;
+}
+
+/**
+ * Sends the project's changed files. A file that changed on the Mac since this folder last
+ * synced is left alone (unless --overwrite) and named; everything else is still sent, so one
+ * file a tool rewrote there (a lockfile) does not hold back the rest. With --delete, files an
+ * earlier sync sent and the person has since deleted here are removed on the Mac too, unless
+ * they changed there.
+ */
+export async function syncProject(session, store, { overwrite = false, dryRun = false, deleteMissing = false, run = runProcess } = {}) {
   const selection = projectFiles(store.project);
   const paths = [...selection.files, ...selection.links].sort();
-  if (!paths.length) throw new CliError("no project files", "Nothing to send: every file is in a skipped folder. Add `!` lines to .nomacignore for what the Mac needs.");
+  const baseline = Object.assign(Object.create(null), store.baseline());
+  const exists = path => lstatSync(join(store.project, path), { throwIfNoEntry: false }) !== undefined;
+  const gone = deleteMissing ? Object.keys(baseline).filter(path => { try { safeRelative(path); } catch { return false; } return !exists(path); }).sort() : [];
+  if (!paths.length && !gone.length) throw new CliError("no project files", "Nothing to send: every file is in a skipped folder. Add `!` lines to .nomacignore for what the Mac needs.");
   const local = Object.create(null);
   for (const path of paths) local[path] = await fingerprint(join(store.project, path));
-  const baseline = Object.assign(Object.create(null), store.baseline());
-  const previous = await remoteFingerprints(session, paths, { run });
+  const previous = paths.length ? await remoteFingerprints(session, paths, { run }) : {};
   const unsafe = paths.filter(path => ["symlink", "other"].includes(previous[path]));
   if (unsafe.length) throw new CliError("unsafe remote path", `Remote paths are below a symlinked folder or have incompatible types: ${unsafe.slice(0, 10).join(", ")}. Resolve them inside the workspace first.`);
-  const conflicts = paths.filter(path => previous[path] !== "missing" && previous[path] !== local[path] && previous[path] !== baseline[path]);
-  if (conflicts.length && !overwrite) throw conflictError(conflicts, "Remote");
-  const changed = paths.filter(path => previous[path] !== local[path]), summary = summarize(store.project, selection);
-  if (dryRun) return { dry_run: true, files: paths.length, changed, ...summary };
-  // --links sends a symlink as a link: its target is never read or followed.
-  const output = await run("rsync", [...transferArgs(), "--links", "--from0", "--files-from=-", `${store.project}/`, `${session.target}:./`], { input: Buffer.from(paths.join("\0") + "\0"), env: transferEnv(session) });
-  const after = await remoteFingerprints(session, paths, { run });
-  const changedDuringTransfer = paths.filter(path => after[path] !== local[path]);
-  for (const path of paths) if (after[path] === local[path]) baseline[path] = local[path];
+  const conflicts = overwrite ? [] : paths.filter(path => previous[path] !== "missing" && previous[path] !== local[path] && previous[path] !== baseline[path]);
+  const held = new Set(conflicts), send = paths.filter(path => !held.has(path));
+  const changed = send.filter(path => previous[path] !== local[path]), summary = summarize(store.project, selection);
+  const onMac = gone.length ? await remoteFingerprints(session, gone, { run }) : {};
+  const removable = gone.filter(path => onMac[path] === baseline[path]), keptOnMac = gone.filter(path => !["missing", baseline[path]].includes(onMac[path]));
+  if (dryRun) return { dry_run: true, files: paths.length, changed, ...(conflicts.length ? { conflicts } : {}), ...(deleteMissing ? { deleted: removable, kept_on_mac: keptOnMac } : {}), ...summary };
+  let output = "";
+  if (send.length) {
+    // --links sends a symlink as a link: its target is never read or followed.
+    output = (await run("rsync", [...transferArgs(), "--links", "--from0", "--files-from=-", `${store.project}/`, `${session.target}:./`], { input: Buffer.from(send.join("\0") + "\0"), env: transferEnv(session) })).stdout;
+  }
+  const after = send.length ? await remoteFingerprints(session, send, { run }) : {};
+  const changedDuringTransfer = send.filter(path => after[path] !== local[path]);
+  for (const path of send) if (after[path] === local[path]) baseline[path] = local[path];
+  const deleted = removable.length ? await removeOnMac(session, removable, { run }) : [];
+  for (const path of [...deleted, ...gone.filter(path => onMac[path] === "missing")]) delete baseline[path];
   store.saveBaseline(baseline);
   if (changedDuringTransfer.length) throw new CliError("transfer changed during verification", "Some files changed during transfer. Stop concurrent edits and rerun sync; verified files were recorded.");
-  return { files: paths.length, changed, ...summary, output: output.stdout };
+  if (conflicts.length) throw syncConflictError(conflicts, changed.length, deleteMissing ? { deleted, kept_on_mac: keptOnMac } : {});
+  return { files: paths.length, changed, ...(deleteMissing ? { deleted, kept_on_mac: keptOnMac } : {}), ...summary, output };
 }
 
 /** Refuse symlink ancestors, including the destination itself, before local writes. */
@@ -234,12 +309,26 @@ export function assertSafeDestination(root, target) {
   }
 }
 
-export async function pullProject(session, store, destination, { from = destination, overwrite = false, dryRun = false, run = runProcess } = {}) {
-  destination = safeRelative(destination); from = safeRelative(from);
-  // Local safety first: a symlinked destination is refused before anything is
-  // asked of the Mac.
-  const requested = resolve(store.project, destination);
-  assertSafeDestination(store.project, requested);
+/**
+ * Where a pull writes on this computer: anywhere the person names. A relative path is in the
+ * project folder (where the CLI runs); an absolute or ~ path may be outside it, such as /tmp.
+ */
+export function localDestination(store, destination) {
+  if (typeof destination !== "string" || !destination || /[\x00-\x1f\x7f]/.test(destination)) throw new CliError("invalid local path", "Give the local folder or file to write, such as ./out, /tmp/shots or ~/Downloads/App.ipa.");
+  const expanded = destination === "~" ? homedir() : destination.startsWith("~/") ? join(homedir(), destination.slice(2)) : destination;
+  const requested = resolve(store.project, expanded), rel = relative(store.project, requested);
+  const inProject = rel === "" || !(rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel));
+  return { requested, inProject, projectPath: inProject ? (rel.split(sep).join("/") || ".") : null };
+}
+
+export async function pullProject(session, store, destination, { from, overwrite = false, dryRun = false, run = runProcess } = {}) {
+  const { requested, inProject, projectPath } = localDestination(store, destination);
+  // A folder in the project comes from the same folder on the Mac unless --from says otherwise.
+  if (from === undefined && !inProject) throw new CliError("pull usage", `Name what to copy from the Mac: nomac pull ${destination} --from PATH, with PATH relative to the project folder there.`);
+  from = safeRelative(from ?? projectPath);
+  // Local safety first: a symlinked destination inside the project is refused before anything
+  // is asked of the Mac (outside it, the path the person named is theirs to choose).
+  if (inProject) assertSafeDestination(store.project, requested);
   // rsync reaches its source by cd'ing into it, so a single file has to be fetched
   // from its parent directory. Probe the remote path: pulling one file (a
   // screenshot, an .ipa) used to fail with a bare rsync "not a directory".
@@ -270,23 +359,27 @@ export async function pullProject(session, store, destination, { from = destinat
       }
     };
     walk(staging);
-    const baseline = Object.assign(Object.create(null), store.baseline()), plan = [], conflicts = [];
+    const baseline = Object.assign(Object.create(null), store.baseline()), pulled = Object.assign(Object.create(null), store.pulled()), plan = [], conflicts = [];
+    // Writes stay inside the folder pulled into, never through a link in it.
+    const safeRoot = inProject ? store.project : localRoot;
     for (const path of files) {
       const target = join(localRoot, rename ?? path), incoming = await fingerprint(join(staging, path));
-      assertSafeDestination(store.project, target);
+      assertSafeDestination(safeRoot, target);
       const current = existsSync(target) ? await fingerprint(target) : "missing";
       if (current === "other") throw new CliError("incompatible local path", `A directory or special file occupies ${target}.`);
       const remotePath = source === "." ? path : `${source.replace(/\/$/, "")}/${path}`;
       // A baseline is meaningful only when downloading to the original project-relative path.
       const samePath = relative(store.project, target).split(sep).join("/") === remotePath.split(sep).join("/");
-      if (current !== "missing" && current !== incoming && (!samePath || baseline[remotePath] !== current)) conflicts.push(path);
-      plan.push({ path, target, current, incoming, remotePath, samePath });
+      // A local file is the person's change unless sync or an earlier pull left it exactly so.
+      const known = (samePath && baseline[remotePath] === current) || pulled[target] === current;
+      if (current !== "missing" && current !== incoming && !known) conflicts.push(path);
+      plan.push({ path, target, current, incoming, remotePath, samePath: inProject && samePath });
     }
     if (conflicts.length && !overwrite) throw conflictError(conflicts, "Local");
     if (dryRun) return { dry_run: true, files: files.length, changed: plan.filter(file => file.current !== file.incoming).map(file => file.path) };
     let backups = false;
     for (const file of plan) {
-      assertSafeDestination(store.project, file.target);
+      assertSafeDestination(safeRoot, file.target);
       const current = existsSync(file.target) ? await fingerprint(file.target) : "missing";
       if (current !== file.current) throw new CliError("local file changed", "A local file changed during pull. Stop concurrent edits and retry. Earlier replacements have recovery copies.");
       if (current !== file.incoming) {
@@ -307,8 +400,9 @@ export async function pullProject(session, store, destination, { from = destinat
         } finally { rmSync(temporary, { force: true }); }
       }
       if (file.samePath) baseline[file.remotePath] = file.incoming;
+      pulled[file.target] = file.incoming;
     }
-    store.saveBaseline(baseline);
+    store.saveBaseline(baseline); store.savePulled(pulled);
     return { files: files.length, changed: plan.filter(file => file.current !== file.incoming).map(file => file.path), ...(backups ? { recovery_directory: backup } : {}) };
   } finally { rmSync(staging, { recursive: true, force: true }); }
 }

package/src/sessions.mjs

@@ -42,7 +42,7 @@ existing connections and remote processes continue. Manage rentals with their ow
 const commonOptions = { help: { type: "boolean" }, json: { type: "boolean" } };
 const commandOptions = {
   start: { host: { type: "string" }, identity: { type: "string" }, port: { type: "string" } },
-  sync: { overwrite: { type: "boolean" }, "dry-run": { type: "boolean" } },
+  sync: { overwrite: { type: "boolean" }, "dry-run": { type: "boolean" }, delete: { type: "boolean" } },
   pull: { overwrite: { type: "boolean" }, "dry-run": { type: "boolean" }, from: { type: "string" } },
   ssh: { forward: { type: "string", multiple: true } },
   stop: {}, session: {},
@@ -131,12 +131,12 @@ export async function sessionCommand(command, argv, { store: suppliedStore, run
     const session = requireReady(store);
     if (command === "sync") {
       if (positionals.length > 1 || (positionals[0] && realpathSync(resolve(positionals[0])) !== store.project)) throw new CliError("sync project mismatch", "Run nomac sync . from the project used by nomac start.");
-      const result = await syncProject(session, store, { overwrite: values.overwrite, dryRun: values["dry-run"], run });
+      const result = await syncProject(session, store, { overwrite: values.overwrite, dryRun: values["dry-run"], deleteMissing: values.delete, run });
       return output(result, describeSync(result));
     }
     if (command === "pull") {
       if (positionals.length !== 1) throw new CliError("pull usage", "Usage: nomac pull LOCAL_DIRECTORY [--from REMOTE_DIRECTORY] [--dry-run] [--overwrite]");
-      const result = await pullProject(session, store, positionals[0], { from: values.from ?? positionals[0], overwrite: values.overwrite, dryRun: values["dry-run"], run });
+      const result = await pullProject(session, store, positionals[0], { from: values.from, overwrite: values.overwrite, dryRun: values["dry-run"], run });
       return output(result, describePull(result));
     }
     throw new CliError("unknown session command");

package/src/testflight.mjs

@@ -17,11 +17,16 @@ needed, and NoMac puts it on TestFlight for your internal testers.
 const DONE = new Set(["on_testflight", "failed"]);
 
 
-function describe(view) {
+/** The line for a view; minutes so far for a send still going, so a slow upload is told from a hang. */
+export function describe(view, minutes = 0) {
   const app = `${view.app.bundle_id} ${view.app.version} (${view.app.build_number})`;
   switch (view.state) {
-    case "sending": return `Sending ${app} from the Mac to Apple…`;
-    case "processing": return `Apple has ${app} and is processing it (usually 5 to 15 minutes; no Mac needed).${view.waiting_for ? `\n  Waiting for: ${view.waiting_for}` : ""}\n  Stopping this wait does not stop it: follow it later with nomac testflight --id ${view.id}`;
+    case "sending": return minutes ? `Still sending ${app} to Apple (${minutes} min so far)…` : `Sending ${app} from the Mac to Apple… Stopping this wait does not stop it: follow it any time with nomac testflight --id ${view.id}`;
+    case "processing":
+      // Apple is done; a person must act before testers get it. NoMac continues by itself after.
+      if (view.needs_human) return `Apple has processed ${app}. Before testers get it, a person must act:\n  ${view.needs_human.message}\n  ${view.needs_human.url}\n  NoMac puts it on TestFlight by itself once that is done; check with nomac testflight --id ${view.id}`;
+      if (view.apple_processed) return `Apple has processed ${app}; NoMac is putting it on TestFlight.${view.waiting_for ? `\n  Waiting for: ${view.waiting_for}` : ""}\n  Stopping this wait does not stop it: follow it later with nomac testflight --id ${view.id}`;
+      return `Apple has ${app} and is processing it (usually 5 to 15 minutes; no Mac needed).${view.waiting_for ? `\n  Waiting for: ${view.waiting_for}` : ""}\n  Stopping this wait does not stop it: follow it later with nomac testflight --id ${view.id}`;
     case "on_testflight": return `On TestFlight: ${app}. Internal testers can install it from the TestFlight app.\n  ${view.url}\n  ${view.app.platform === "IOS"
       ? `To submit it for App Review: nomac publish --project ${view.project_id} --build ${view.build_id}` : "Submit it for App Review in App Store Connect."}`;
     // With a build_id, Apple had the file and refused it while processing; without one, it never reached Apple.
@@ -63,15 +68,17 @@ export async function testflightCommand(args, { api = defaultApi, print = consol
     }
   }
   let last = "";
+  const began = Date.now();
   const show = (current) => {
     if (values.json) return;
-    const line = describe(current);
+    const line = describe(current, current.state === "sending" ? Math.floor((Date.now() - began) / 60_000) : 0);
     if (line !== last) print(line);
     last = line;
   };
   show(view);
   if (!values["no-wait"]) {
-    while (!DONE.has(view.state)) {
+    // A step only a person can take ends the wait: it is said, and NoMac goes on by itself after it.
+    while (!DONE.has(view.state) && !view.needs_human) {
       view = await api("GET", `/api/v1/testflight/${encodeURIComponent(view.id)}?wait_seconds=50`);
       show(view);
     }