@nomac/cli 0.11.5 → 0.11.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomac/cli",
-  "version": "0.11.5",
+  "version": "0.11.7",
   "description": "Cloud Mac sessions over SSH and HTTPS, plus iOS builds and publishing — built for agents.",
   "license": "UNLICENSED",
   "type": "module",
@@ -19,11 +19,11 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "https-proxy-agent": "^9.1.0",
     "ignore": "^7.0.0",
+    "proxy-from-env": "^2.1.0",
     "tar": "^7.4.0",
-    "ws": "^8.21.3",
-    "https-proxy-agent": "^9.1.0",
-    "proxy-from-env": "^2.1.0"
+    "ws": "^8.21.3"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",

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)
@@ -106,6 +108,7 @@ export async function main(argv) {
     case "exec":
     case "job":
     case "output":
+    case "cancel":
     case "sync":
     case "ssh":
     case "desktop":
@@ -150,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;
       }
@@ -181,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 ?? {};
@@ -207,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

@@ -1,15 +1,17 @@
 import { createHash, randomUUID } from "node:crypto";
 import { chmodSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { api, CliError } from "./api.mjs";
 import { sessionStore } from "./session-store.mjs";
-import { forwardingArg, isShellLine, runProcess, sshArgs, workspaceCommand } from "./session-ssh.mjs";
+import { forwardingArg, isShellLine, runProcess, shellQuote, sshArgs, validateWorkspace, workspaceCommand } from "./session-ssh.mjs";
 import { describePull, describeSync, pullProject, syncProject } from "./session-transfer.mjs";
 import { macRequest, sessionId, transportOptions } from "./mac-transport.mjs";
 import { copyToClipboard, desktop, DESKTOP_HELP, screenSharing } from "./desktop.mjs";
 import { screenshot, startRecording, stopRecording } from "./mac-screen.mjs";
 
+const WORKSPACE = "/Users/agent/workspace";
+
 const HELP = `Nomac cloud Mac sessions
   nomac start [--wait 300] [--max-duration 7200] [--idle-timeout 600] [--max-cost 5] [--json]
               [--prompts ask]
@@ -17,7 +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
+  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). 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
@@ -44,7 +51,10 @@ const HELP = `Nomac cloud Mac sessions
                                     (--request-key KEY makes a scripted retry safe)
   nomac job JOB_ID [--wait 600]     wait for a command that outlasted --wait
   nomac output JOB_ID [--cursor 0] [--stream stdout|stderr]
-  nomac pull ./output [--from PATH] retrieve files before stopping
+  nomac cancel JOB_ID               stop a running command and everything it started
+  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
@@ -54,20 +64,21 @@ const HELP = `Nomac cloud Mac sessions
   nomac status [--json]             state, cost so far and when it stops
   nomac attach [SESSION_ID]         use the account's running Mac from this folder, when your
                                     agent started it elsewhere (MCP, the dashboard); start does it too
-  nomac stop [--wait 60] [--json]   stop the Mac: deletes it and its files (not ~/drive)
+  nomac stop [--wait 60] [--json]   stop the Mac: deletes it and its files, not ~/drive
+                                    (your synced project stays there)
 
 Login once with nomac login. The CLI creates a local SSH key; it sends only the
 public key. Sessions use the port-443 gateway and verified guest host keys.
 Credit is used at $0.80 an hour, billed by the minute, while the VM is ready,
 including between commands. Sessions run 2 hours by default (--max-duration,
-up to 8 hours) and spend at most $5 (--max-cost). No credit? nomac credits buy. Stop removes the VM and its files; pull first.
+up to 8 hours) and spend at most $5 (--max-cost). No credit? nomac credits buy. Stop removes the VM and every file outside ~/drive.
 A wait timeout leaves the session attached: inspect status or run stop.
 Use nomac start --host user@mac to connect an existing Mac instead.`;
 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" },
@@ -171,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();
@@ -198,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.`;
+      : `${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  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;
   }
@@ -219,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;
 }
@@ -247,6 +266,12 @@ const uncertainOutcome = error => !Number.isInteger(error?.status) || error.stat
 const usd = microunits => `$${(Number(microunits ?? 0) / 1_000_000).toFixed(2)}`;
 const clockUtc = ms => new Date(ms).toISOString().slice(11, 16) + " UTC";
 /** One readable paragraph for nomac status. */
+/** "Project: ~/drive/src/app, on your drive: the next session continues from it." */
+export function projectLine({ path, on_drive }) {
+  const short = String(path).replace(/^\/Users\/agent(?=\/)/, "~");
+  return on_drive ? `Project: ${short}, on your drive: kept when the Mac stops, and the next session builds only what changed.`
+    : `Project: ${short}, deleted when the Mac stops: nomac pull what you need first.`;
+}
 export function statusSummary(session, image) {
   const lines = [`${session.id}: ${session.state}`];
   if (image?.macos) {
@@ -297,7 +322,7 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     const usage = billing?.mode === "weekly_included"
       ? `Included time used: ${billing.used_seconds} seconds. No extra charge.`
       : `Cost so far: $${(Number(result.session?.cost?.accrued_microunits ?? 0) / 1_000_000).toFixed(2)} ($0.80/hour, billed by the minute while the Mac is ready). Credit left: nomac credits`;
-    const next = result.session.state === "ready" ? "Next: nomac sync . → nomac ssh"
+    const next = result.session.state === "ready" ? `${result.project ? `${projectLine(result.project)}\n` : ""}Next: nomac sync . → nomac ssh`
       : result.session.failure_code === "capacity_unavailable" ? "No Mac was free within 5 minutes; nothing was charged. Run nomac start again in a few minutes."
       : result.session.state === "queued" ? "Waiting for a free Mac (waiting is free). Check again: nomac start"
       : ["stopped", "failed"].includes(result.session.state) ? `${result.session.drive ? "The drive saves in the background (nomac drive shows it). " : ""}Start another: nomac start`
@@ -319,10 +344,39 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     const access = await sessionAccess(local.id, request);
     if (local.generation && (local.generation !== access.generation || local.hostKey !== access.ssh.host_key)) throw new CliError("The guest identity changed. Stop this session and start a fresh one.", undefined, undefined, "host_key_changed");
     if (local.attached && !local.keyAdded) await addKey(local);
-    Object.assign(local, { generation: access.generation, hostKey: access.ssh.host_key, target: `agent@nomac-${local.id}`, workspace: "/Users/agent/workspace", knownHosts: join(store.directory, "known_hosts") });
+    // A session an older CLI began in ~/workspace stays there, so nothing moves mid-session.
+    if (local.workspace && !local.workspaceDecided) local.workspaceDecided = true;
+    if (!local.workspaceDecided) await placeWorkspace(local);
+    Object.assign(local, { generation: access.generation, hostKey: access.ssh.host_key, target: `agent@nomac-${local.id}`, workspace: local.workspace ?? WORKSPACE, knownHosts: join(store.directory, "known_hosts") });
     writeFileSync(local.knownHosts, `nomac-${local.id} ${access.ssh.host_key}\n`, { mode: 0o600 }); chmodSync(local.knownHosts, 0o600); store.save(local);
     return local;
   }
+  /**
+   * With the account's drive, this folder's project lives on it, at ~/drive/src/<folder name>,
+   * so the next session finds it and builds only what changed (~/workspace is emptied every
+   * session). A name another local folder took gets a suffix; the claims are kept in
+   * ~/drive/.nomac/projects. Without a drive, the workspace is ~/workspace as before.
+   */
+  async function placeWorkspace(local) {
+    if (local.snapshot?.drive?.state === "mounted") {
+      const name = (basename(store.project).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[.-]+/, "") || "project").slice(0, 64);
+      const origin = createHash("sha256").update(store.project).digest("hex").slice(0, 12);
+      const script = 'set -e; claims=~/drive/.nomac/projects; mkdir -p "$claims" ~/drive/src; d="$NAME"; '
+        // A folder another local folder claimed, or one made on the Mac some other way, is left alone.
+        + 'if { [ -e "$claims/$d" ] && [ "$(cat "$claims/$d")" != "$ORIGIN" ]; } || { [ ! -e "$claims/$d" ] && [ -n "$(ls -A ~/drive/src/"$d" 2>/dev/null)" ]; }; then d="$NAME-$ORIGIN"; fi; '
+        + 'printf %s "$ORIGIN" > "$claims/$d"; mkdir -p ~/drive/src/"$d"; cd ~/drive/src/"$d"; pwd';
+      const job = await request("POST", `/api/v1/mac/sessions/${sessionId(local.id)}/jobs?wait=30`, { idempotencyKey: `cli-place-${local.id.slice(4, 24)}-${origin}`,
+        body: { argv: ["/bin/bash", "-c", script], env: { NAME: name, ORIGIN: origin }, timeout_seconds: 30 } }).catch(() => null);
+      const path = String(job?.stdout ?? "").trim();
+      if (job?.exit_code === 0 && path.startsWith("/Users/agent/drive/src/") && !path.slice(23).includes("/")) {
+        // The same folder on the drive as last time: what was synced there then is still there.
+        if (local.previousDriveWorkspace?.path === path) store.saveBaseline(local.previousDriveWorkspace.baseline);
+        Object.assign(local, { workspace: validateWorkspace(path), workspaceOnDrive: true });
+      }
+    }
+    delete local.previousDriveWorkspace;
+    local.workspaceDecided = true; store.save(local);
+  }
   /**
    * A Mac started elsewhere (by an agent over MCP, the dashboard or another folder) took no key
    * from this folder: add this folder's own to its authorized keys with an ordinary command, so
@@ -335,6 +389,10 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     if (job.exit_code !== 0) throw new CliError("Could not add this folder's SSH key to the Mac.", `Adding the key ended with ${job.state === "exited" ? `exit code ${job.exit_code}` : `the command ${job.state}`}. Try again: nomac attach ${local.id}`);
     local.keyAdded = true; store.save(local);
   }
+  /** Where this folder's project is on the Mac, once a ready Mac has decided it. */
+  const project = local => local.state === "ready" && local.workspaceDecided ? { project: { path: local.workspace, on_drive: Boolean(local.workspaceOnDrive) } } : {};
+  /** The last session's folder on the drive and what was synced to it, for the next session to pick up. */
+  const previousDrive = old => old?.workspaceOnDrive ? { previousDriveWorkspace: { path: old.workspace, baseline: store.baseline() } } : {};
   /** The account's running Macs, newest first: queued, starting or ready. */
   async function liveSessions() {
     const answer = await request("GET", "/api/v1/mac/sessions");
@@ -345,7 +403,7 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     const identity = join(store.directory, `id_ed25519_${randomUUID()}`);
     await run("ssh-keygen", ["-q", "-t", "ed25519", "-N", "", "-C", "nomac-session", "-f", identity]);
     const local = { mode: "hosted", state: view.state, id: sessionId(view.id), identity, attached: true, outcomeUnknown: false, requestKey: `attach-${view.id}`,
-      request: { profile: "standard", limits: view.limits ?? {}, ...(view.access ? { access: view.access } : {}) } };
+      request: { profile: "standard", limits: view.limits ?? {}, ...(view.access ? { access: view.access } : {}) }, ...previousDrive(store.load()) };
     store.save(local); store.saveBaseline({});
     const deadline = now() + wait * 1000;
     for (;;) {
@@ -368,20 +426,36 @@ 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.
     const elsewhere = ["stopped", "failed"].includes(session.state) ? (await liveSessions().catch(() => [])).find(s => s.id !== session.id) : undefined;
-    if (values.json) { print(JSON.stringify({ session, ...(result.image ? { image: result.image } : {}), ...(elsewhere ? { running_elsewhere: elsewhere.id } : {}) }, null, 2)); return session; }
-    print(statusSummary(session, result.image) + (elsewhere ? `\nYour account's Mac ${elsewhere.id} is ${elsewhere.state}, started elsewhere: nomac attach` : ""));
+    if (values.json) { print(JSON.stringify({ session, ...(result.image ? { image: result.image } : {}), ...project(local), ...(elsewhere ? { running_elsewhere: elsewhere.id } : {}) }, null, 2)); return session; }
+    print(statusSummary(session, result.image) + (project(local).project ? `\n${projectLine(project(local).project)}` : "") + (elsewhere ? `\nYour account's Mac ${elsewhere.id} is ${elsewhere.state}, started elsewhere: nomac attach` : ""));
     return session;
   }
+  if (command === "cancel") {
+    if (positionals.length !== 1 || !/^job_[a-f0-9]{40}$/.test(positionals[0])) throw new CliError("Usage: nomac cancel JOB_ID");
+    const local = localSession(), job = await hostedRequest(local.id, "POST", `/api/v1/mac/sessions/${sessionId(local.id)}/jobs/${positionals[0]}/cancel`, {}, { request, transport });
+    if (values.json) { print(JSON.stringify(job, null, 2)); return job; }
+    const ended = job.exit_code === null || job.exit_code === undefined ? (job.signal ? `signal ${job.signal}` : job.state) : `exit code ${job.exit_code}`;
+    print(job.cancelled ? `Cancelled ${job.id}: it and everything it started were stopped (${ended}). Its output so far: nomac output ${job.id}`
+      : job.state === "exited" ? `${job.id} had already finished (${job.reason === "cancelled" ? "cancelled" : ended}).` : `${job.id} is ${job.state}.`);
+    return job;
+  }
   if (["exec", "job", "output"].includes(command)) {
     const local = localSession(), base = `/api/v1/mac/sessions/${sessionId(local.id)}`;
     let path, method = "GET", params = {};
     if (command === "exec") {
       if (!positionals.length || !argv.includes("--")) throw new CliError("Use nomac exec -- command args");
+      if (!local.workspaceDecided && !local.workspace) { await refresh(local); if (local.state === "ready") await placeWorkspace(local); }
       if (values["request-key"] !== undefined && !/^[A-Za-z0-9_.:-]{8,128}$/.test(values["request-key"])) throw new CliError("A request key is 8 to 128 letters, digits, underscores, periods, colons or hyphens.");
       // A person running a command once needs no key; scripts pass one so a lost response can be retried safely.
       // Without a key, a long wait implies a long command, so the command's own limit follows it unless set.
@@ -389,7 +463,10 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
       // A command may run an hour (the gateway's limit); waiting can cover all of it.
       const waitFor = integer(values.wait, 30, 0, 3600);
       const timeout = integer(values.timeout, values["request-key"] === undefined ? Math.max(300, waitFor) : 600, 1, 3600);
-      method = "POST"; path = `${base}/jobs`; params = { requestKey: values["request-key"] ?? `cli-${randomUUID()}`, body: { argv: isShellLine(positionals) ? ["/bin/bash", "-lc", positionals[0]] : positionals, timeout_seconds: timeout } };
+      const line = isShellLine(positionals), dir = local.workspaceOnDrive ? local.workspace : null;
+      const remote = dir ? (line ? ["/bin/bash", "-lc", `cd ${shellQuote(dir)} && ${positionals[0]}`] : ["/bin/bash", "-lc", `cd ${shellQuote(dir)} && exec "$@"`, "nomac", ...positionals])
+        : line ? ["/bin/bash", "-lc", positionals[0]] : positionals;
+      method = "POST"; path = `${base}/jobs`; params = { requestKey: values["request-key"] ?? `cli-${randomUUID()}`, body: { argv: remote, timeout_seconds: timeout } };
     } else {
       if (positionals.length !== 1 || !/^job_[a-f0-9]{40}$/.test(positionals[0])) throw new CliError("Supply the existing job ID.");
       path = `${base}/jobs/${positionals[0]}`;
@@ -410,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]");
@@ -511,12 +588,12 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
       if (current?.mode === "hosted" && current.id && (!wanted || current.id === wanted) && live.some(s => s.id === current.id)) {
         await refresh(current);
         if (current.state === "ready") await ready(current);
-        return output({ session: current.snapshot, attached: `This folder already uses ${current.id}.` });
+        return output({ session: current.snapshot, attached: `This folder already uses ${current.id}.`, ...project(current) });
       }
       const target = wanted ? live.find(s => s.id === wanted) : live.length === 1 ? live[0] : undefined;
       if (!target) throw new CliError(wanted ? `No running Mac ${wanted} in this account.` : live.length ? `This account has ${live.length} running Macs: name one, nomac attach ${live.map(s => s.id).join(" | ")}` : "This account has no running Mac. Start one: nomac start");
       const local = await attachTo(target);
-      return output({ session: local.snapshot, attached: `Attached to ${local.id}, started elsewhere: ssh, sync, pull and exec work from this folder.` });
+      return output({ session: local.snapshot, attached: `Attached to ${local.id}, started elsewhere: ssh, sync, pull and exec work from this folder.`, ...project(local) });
     }
     if (command === "start") {
       if (positionals.length) throw new CliError("Usage: nomac start [--wait SECONDS] [--json]");
@@ -540,7 +617,8 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
         const identity = join(store.directory, `id_ed25519_${randomUUID()}`);
         await run("ssh-keygen", ["-q", "-t", "ed25519", "-N", "", "-C", "nomac-session", "-f", identity]);
         local = { mode: "hosted", state: "requesting", outcomeUnknown: false, identity, requestKey: values["request-key"] ?? `cli-${randomUUID()}`,
-          request: { profile: "standard", public_key: readFileSync(`${identity}.pub`, "utf8").trim(), limits, ...(access ? { access } : {}) } };
+          request: { profile: "standard", public_key: readFileSync(`${identity}.pub`, "utf8").trim(), limits, ...(access ? { access } : {}) },
+          ...previousDrive(store.load()) };
         store.save(local); store.saveBaseline({});
       }
       if (!local.id) {
@@ -554,7 +632,7 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
             const [running] = await liveSessions();
             if (running) {
               local = await attachTo(running);
-              return output({ session: local.snapshot, attached: `Your account's Mac ${local.id} was already running (started elsewhere): this folder now uses it.` });
+              return output({ session: local.snapshot, attached: `Your account's Mac ${local.id} was already running (started elsewhere): this folder now uses it.`, ...project(local) });
             }
           }
           if (!previouslyUncertain && startRejections.has(error.code) && Number.isInteger(error.status) && error.status >= 400 && error.status <= 503) {
@@ -573,7 +651,7 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
         await sleep(2000);
       }
       if (local.state === "ready") await ready(local);
-      return output({ session: local.snapshot, request_key: local.requestKey, ...(local.warning ? { warning: local.warning } : {}) });
+      return output({ session: local.snapshot, request_key: local.requestKey, ...project(local), ...(local.warning ? { warning: local.warning } : {}) });
     }
     const local = localSession();
     if (command === "stop") {
@@ -586,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

@@ -28,7 +28,7 @@ export const MAC_TOOLS = [
   { name: "get_mac_drive", description: "Read the account's persistent drive: a disk kept between sessions and mounted at ~/drive on every Mac (50 GB). What is there stays for the next session: keep projects in ~/drive/src for incremental builds; package and build caches (DerivedData, Swift packages, CocoaPods, npm) are kept there already. NoMac saves it when a Mac stops, with nothing to call. Shows the space used, the newest saved version, a save still in progress, recent versions, and the date it is deleted after 90 days without a Mac.", inputSchema: schema({}), handler: async () => text(await api("GET", "/api/v1/mac/drive")) },
   { name: "reset_mac_drive", description: "Empty the account's persistent drive: the next Mac starts with a new, empty ~/drive, and everything on the old drive is deleted, with no way back. Stop any running session first (stop_mac). For a single Mac without the drive, start_mac with access drive none instead.", inputSchema: schema({}), handler: async () => text(await api("DELETE", "/api/v1/mac/drive")) },
   { name: "list_secrets", description: "List the account's secrets by name: variables (set in every shell and command on the Mac) and files (with their path on the Mac), whether every Mac receives them or only when asked, sizes, and secrets an agent asked for that the person has not entered yet. Values are never returned.", inputSchema: schema({}), handler: async () => text(await api("GET", "/api/v1/secrets")) },
-  { name: "request_secret", description: "Get a link where the person enters a secret in their browser, so its value never passes through this chat: an API token, a .env value, a .p12 certificate or a config file. kind variable is one line of text, set as an environment variable on the Mac; kind file is stored at destination (under the home folder, like ~/.netrc; default ~/.nomac/secrets/<name>). Give the person the url. Then list_secrets shows it, new Macs receive it, and install_secrets puts it on a running Mac. With a shell on this machine, the person can also run nomac secrets set NAME themselves. Never ask for a secret in the chat.", inputSchema: schema({ name: { type: "string", minLength: 1, maxLength: 128 }, kind: { type: "string", enum: ["variable", "file"] }, description: { type: "string", minLength: 1, maxLength: 500, description: "What the person should enter and why; shown to them" }, destination: { type: "string", maxLength: 256 }, delivery: { type: "string", enum: ["every_mac", "on_request"] } }, ["name", "kind", "description"]), handler: async body => text(await api("POST", "/api/v1/secrets/requests", { body })) },
+  { name: "request_secret", description: "Get a link where the person enters a secret in their browser, so its value never passes through this chat: an API token, a .env value, a .p12 certificate or a config file. kind variable is one line of text, set as an environment variable on the Mac; kind file is stored at destination (under the home folder, like ~/.netrc; default ~/.nomac/secrets/<name>). Give the url to the person who holds the value; they need no NoMac account, and it works once, for 24 hours. Then list_secrets shows it, new Macs receive it, and install_secrets puts it on a running Mac. With a shell on this machine, the person can also run nomac secrets set NAME themselves. Never ask for a secret in the chat.", inputSchema: schema({ name: { type: "string", minLength: 1, maxLength: 128 }, kind: { type: "string", enum: ["variable", "file"] }, description: { type: "string", minLength: 1, maxLength: 500, description: "What the person should enter and why; shown to them" }, destination: { type: "string", maxLength: 256 }, delivery: { type: "string", enum: ["every_mac", "on_request"] } }, ["name", "kind", "description"]), handler: async body => text(await api("POST", "/api/v1/secrets/requests", { body })) },
   { name: "set_up_signing", description: "Set up App Store signing for a project on the Mac, with the App Store Connect key kept on NoMac's server: reads the project at path (its scheme, app and every extension, with entitlements), registers missing bundle IDs, switches on the capabilities Apple's API can, makes the App Store profiles, and installs them with the account's certificate in a keychain on the Mac. The project never changes. Returns a build settings file (.xcconfig) and export options with the exact xcodebuild, Flutter and fastlane commands. Creates a distribution certificate at Apple only when the account has none. Expo and Capacitor apps need their ios folder first. A step only a person can take comes back as needs_human with its link.", inputSchema: schema({ session_id: session, path: { type: "string", minLength: 1, maxLength: 1024, description: "The project folder on the Mac, relative to the workspace" }, scheme: { type: "string", minLength: 1, maxLength: 256 }, container: { type: "string", minLength: 1, maxLength: 1024 }, issuer_id: { type: "string", maxLength: 64 } }, ["session_id"]), handler: async ({ session_id, ...body }) => text(await api("POST", `${base({ session_id })}/signing`, { body })) },
   { name: "send_to_testflight", description: "Send a signed .ipa on the Mac to TestFlight, with the App Store Connect key kept on NoMac's server: NoMac creates the upload at Apple and the Mac sends only the file. Apple then processes the build, usually for 5 to 15 minutes with no Mac needed, and NoMac sets the app's export-compliance answer and What to Test and puts it on TestFlight for the internal testers. Repeat the call with the returned request_key to follow it: sending, processing, on_testflight or failed. Once on_testflight, publish with the returned project_id and build_id submits it for App Review. Apple asks once per app whether it uses encryption beyond HTTPS and Apple's own: pass the person's answer as uses_non_exempt_encryption, never a guess. A build number Apple already has comes back with the next free one. A step only a person can take, such as creating the app in App Store Connect, comes back as needs_human with its link.", inputSchema: schema({ session_id: session, path: { type: "string", minLength: 1, maxLength: 1024, description: "The signed .ipa on the Mac, relative to the workspace or absolute" }, notes: { type: "string", minLength: 1, maxLength: 4000, description: "What to Test, shown to testers" }, uses_non_exempt_encryption: { type: "boolean", description: "The person's answer, asked once per app: does it use encryption beyond HTTPS and Apple's own?" }, issuer_id: { type: "string", maxLength: 64 }, request_key: { ...key, description: "Repeat with the request_key from the first answer to follow that send" }, wait_seconds: { type: "integer", minimum: 0, maximum: 50, description: "Wait up to this long for progress (50 while following)" } }, ["session_id", "path"]), handler: async ({ session_id, ...body }) => text(await api("POST", `${base({ session_id })}/testflight`, { body })) },
   { name: "notarize", description: "Notarize a Developer ID-signed Mac app, disk image or installer on the Mac (.app, .dmg, .pkg or .zip), with the App Store Connect key kept on NoMac's server: the Mac zips an .app and sends the file to Apple with temporary credentials for this one submission. Apple checks it, usually for a few minutes, then the Mac staples the ticket so it opens without a warning, even offline. Repeat the call with the returned request_key to follow it: preparing, uploading, in_progress, stapling, then accepted, invalid or rejected with Apple's issues. Sign first with the Developer ID Application certificate (the person uploads it at nomac.app/apple), the hardened runtime and a secure timestamp: codesign --force --options runtime --timestamp --sign \"Developer ID Application: …\". Keep the Mac running until it is stapled.", inputSchema: schema({ session_id: session, path: { type: "string", minLength: 1, maxLength: 1024, description: "The .app, .dmg, .pkg or .zip on the Mac, relative to the workspace or absolute" }, issuer_id: { type: "string", maxLength: 64 }, request_key: { ...key, description: "Repeat with the request_key from the first answer to follow that notarization" }, wait_seconds: { type: "integer", minimum: 0, maximum: 50, description: "Wait up to this long for progress (50 while following)" } }, ["session_id", "path"]), handler: async ({ session_id, ...body }) => text(await api("POST", `${base({ session_id })}/notarize`, { body })) },
@@ -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. timeout_seconds defaults to 300 and caps at 600; raise it for slow work such as a first simulator boot (about 90 seconds). 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 }, timeout_seconds: { type: "integer", minimum: 1, maximum: 600 }, 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." } });
@@ -115,5 +115,6 @@ export const MAC_TOOLS = [
     return text(save_to && view.state === "ready" ? { ...view, ...await saveFromLink(view, save_to) } : view);
   } },
   { name: "get_mac_job", description: "Inspect the existing command without rerunning it. Retain its job ID until completion and retrieve output before stopping the VM.", inputSchema: schema({ session_id: session, job_id: job }, ["session_id", "job_id"]), handler: async args => text(await api("GET", `${base(args)}/jobs/${encodeURIComponent(args.job_id)}`)) },
+  { name: "cancel_mac_job", description: "Stop a running command and everything it started (its whole process group): SIGTERM, a second to finish, then SIGKILL. It comes back exited with reason cancelled; its output so far stays readable. A command that already finished is returned unchanged (cancelled: false).", inputSchema: schema({ session_id: session, job_id: job }, ["session_id", "job_id"]), handler: async args => text(await api("POST", `${base(args)}/jobs/${encodeURIComponent(args.job_id)}/cancel`)) },
   { name: "read_mac_output", description: "Read stdout/stderr as base64 chunks; resume from next_cursor. If truncated, the final response includes tail_base64 and its absolute tail_offset. Retrieve promptly: only recent completed jobs retain output. output_expired preserves the job receipt and never means rerun. Retrieve before stopping the VM.", inputSchema: schema({ session_id: session, job_id: job, cursor: { type: "integer", minimum: 0 }, stream: { type: "string", enum: ["stdout", "stderr"] } }, ["session_id", "job_id"]), handler: async args => text(await api("GET", `${base(args)}/jobs/${encodeURIComponent(args.job_id)}/output?${new URLSearchParams({ cursor: String(args.cursor ?? 0), stream: args.stream ?? "stdout" })}`)) },
 ];

package/src/secrets.mjs

@@ -14,7 +14,8 @@ come back from NoMac, and are never taken as command-line arguments.
   nomac secrets rm NAME                  delete it
   nomac secrets install [NAME...]        put them on this folder's Mac now  [--session ses_…]
   nomac secrets request NAME --description TEXT [--kind file] [--destination ~/x]
-                                         a link where someone enters it in the browser
+                                         a link for whoever holds it to enter it once,
+                                         in the browser, with no NoMac account
 Add --json for JSON.`;
 
 /**
@@ -130,7 +131,7 @@ export async function secretsCommand(args, { api = defaultApi, print = console.l
     if (names.length !== 1 || !values.description || !["variable", "file"].includes(kind)) throw new CliError("request usage", "Usage: nomac secrets request NAME --description TEXT [--kind file] [--destination ~/x]");
     const result = await api("POST", "/api/v1/secrets/requests", { body: { name: names[0], kind, description: values.description,
       ...(values.destination ? { destination: values.destination } : {}), delivery } });
-    return out(result, `Open this link to enter ${result.name} (expires ${result.expires_at}):\n${result.url}`);
+    return out(result, `Send this link to whoever holds ${result.name}; they need no NoMac account. It works once, until ${result.expires_at.slice(0, 16).replace("T", " ")} UTC:\n${result.url}`);
   }
   throw new CliError("unknown secrets command", SECRETS_HELP);
 }

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,54 @@ 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. */
+function syncConflictError(paths, sent) {
+  const shown = paths.slice(0, 10).join(", ") + (paths.length > 10 ? ` and ${paths.length - 10} more` : "");
+  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: ${shown}. Keep the Mac's version: nomac pull ${paths[0]}. Replace it with yours: nomac sync . --overwrite`);
+  error.code = "transfer_conflict";
+  error.details = { paths, side: "Remote", sent };
+  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);
+  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 +306,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 +356,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 +397,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);
     }