@nomac/cli 0.11.8 → 0.11.10

package/package.json

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

package/skill/SKILL.md

@@ -26,8 +26,9 @@ commands and tools. Mac time is prepaid credit, separate from Builder.
    `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
+   Run commands with `nomac exec -- COMMAND`: it prints the output as it
+   arrives and exits with the command's code, waiting at most 30 s (or the
+   `--timeout` given, up to 600 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`. A command may run an hour (`--timeout
@@ -61,6 +62,7 @@ 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.
+`nomac sync . --watch` syncs again whenever files change, until Ctrl-C.
 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

package/src/hosted-sessions.mjs

@@ -1,11 +1,11 @@
 import { createHash, randomUUID } from "node:crypto";
-import { chmodSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
+import { chmodSync, readFileSync, watch as watchFolder, writeFileSync } from "node:fs";
+import { basename, join, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 import { api, CliError } from "./api.mjs";
 import { sessionStore } from "./session-store.mjs";
 import { forwardingArg, isShellLine, runProcess, shellQuote, sshArgs, validateWorkspace, workspaceCommand } from "./session-ssh.mjs";
-import { describePull, describeSync, pullProject, syncProject } from "./session-transfer.mjs";
+import { describePull, describeSync, inSkippedFolder, 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";
@@ -19,12 +19,13 @@ 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] [--delete]
+  nomac sync . [--dry-run] [--delete] [--watch]
                                     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
+                                    --delete also removes there what you deleted here;
+                                    --watch syncs again whenever files change, until Ctrl-C
   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
@@ -45,8 +46,10 @@ const HELP = `Nomac cloud Mac sessions
   nomac start --permit APP=PERMISSIONS
                                     grant permissions on this Mac at start
   nomac exec [--wait 30] -- command args
-                                    runs it, prints its output, exits with its code.
-                                    Waits up to 30 s; for builds and tests use --wait 600.
+                                    runs it, prints its output as it arrives,
+                                    exits with its code.
+                                    Waits up to 30 s, or with --timeout N up to N s
+                                    (at most 600); for builds and tests use --wait 600.
                                     Exit code 75 means still running: see nomac job.
                                     (--request-key KEY makes a scripted retry safe)
   nomac job JOB_ID [--wait 600]     wait for a command that outlasted --wait
@@ -78,7 +81,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" }, delete: { type: "boolean" },
+  overwrite: { type: "boolean" }, "dry-run": { type: "boolean" }, from: { type: "string" }, delete: { type: "boolean" }, watch: { 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" },
@@ -176,11 +179,11 @@ export const STILL_RUNNING = 75;
 const POLL_MS = [250, 500];
 const NOTICE_MS = 5000;
 /**
- * nomac exec waits like a local command: up to --wait seconds (default 30), then
- * prints stdout and stderr and exits with the command's own exit code. The wait
- * is a ceiling: a quick command returns as soon as it finishes. A command still
- * running keeps running on the Mac; the CLI says how to wait for it and exits
- * 75. --wait 0 only starts it.
+ * nomac exec waits like a local command: up to --wait seconds (default 30, or
+ * --timeout's up to 600), then prints stdout and stderr and exits with the
+ * command's own exit code. The wait is a ceiling: a quick command returns as soon
+ * as it finishes. A command still running keeps running on the Mac; the CLI
+ * says how to wait for it and exits 75. --wait 0 only starts it.
  */
 /** "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.` : "";
@@ -190,11 +193,33 @@ function endedBy(job, timeoutSeconds) {
   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 }) {
+/** How often a waiting command's new output is fetched and printed (each read is a round trip to the Mac). */
+const STREAM_MS = 2000;
+async function waitForCommand(id, base, started, waitSeconds, { request, transport, cache, print, stdout, stderr, exitWith, sleep, now, json, timeoutSeconds, cursors = null, keepCursors = () => {} }) {
   let job = started;
   const deadline = now() + waitSeconds * 1000;
   const begun = now();
-  let announced = false, busy = false, shownWaiting = "";
+  let announced = false, busy = false, shownWaiting = "", streamed = 0;
+  // Output is printed as it arrives, from where an earlier wait for this command stopped; --json
+  // answers once, with all of it.
+  const live = !json && waitSeconds > 0;
+  const cursor = { stdout: cursors?.stdout ?? 0, stderr: cursors?.stderr ?? 0 }, write = { stdout, stderr };
+  const drain = async (final) => {
+    for (const stream of ["stdout", "stderr"]) {
+      if (final && cursor[stream] === 0 && job.output_bytes?.[stream] === 0) continue;
+      for (let reads = 0; final || reads < 4; reads++) {
+        const part = await hostedRequest(id, "GET", `${base}/jobs/${job.id}/output?cursor=${cursor[stream]}&stream=${stream}`, {}, { request, transport, cache });
+        const data = Buffer.from(part.data_base64 ?? "", "base64"), next = Number.isSafeInteger(part.next_cursor) ? part.next_cursor : cursor[stream];
+        if (data.length) write[stream](data);
+        if (part.eof && part.tail_base64) for (const piece of tailAfter(part)) write[stream](piece);
+        const done = part.eof || next === cursor[stream];
+        cursor[stream] = next;
+        if (done) break;
+      }
+    }
+  };
+  // A busy Mac only delays what is printed; the command and its output are unaffected.
+  const stream = async () => { try { await drain(false); } catch (error) { if (error?.code !== "guest_busy") throw error; } };
   for (let polls = 0; waitSeconds && !["exited", "unknown"].includes(job.state) && now() < deadline; polls++) {
     // A slow command can outlive the shell waiting for it (agent shells time out); leave a way back.
     if (!json && !announced && now() - begun >= NOTICE_MS && deadline - now() > 1000) {
@@ -211,9 +236,12 @@ async function waitForCommand(id, base, started, waitSeconds, { request, transpo
       shownWaiting = `${waiting.kind}:${waiting.text}`;
       stderr(`nomac: ${job.id} is waiting on macOS: ${waiting.text}\n  ${waiting.fix}\n`);
     }
+    if (live && job.state === "running" && now() - streamed >= STREAM_MS) { streamed = now(); await stream(); }
   }
   if (job.state !== "exited") {
     if (!waitSeconds) { print(JSON.stringify(job, null, 2)); return job; }
+    // What it printed so far is shown, and the next wait for it goes on from there.
+    if (live) { await stream(); keepCursors(job.id, cursor); }
     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.`
@@ -224,6 +252,14 @@ async function waitForCommand(id, base, started, waitSeconds, { request, transpo
     exitWith(unknown ? 1 : STILL_RUNNING);
     return job;
   }
+  const ended = endedBy(job, timeoutSeconds);
+  if (live) {
+    await drain(true);
+    keepCursors(job.id, null);
+    if (ended) stderr(`nomac: ${ended}\n`);
+    exitWith(typeof job.exit_code === "number" ? job.exit_code : 1);
+    return job;
+  }
   // Each read is a round trip to the Mac: skip empty streams and read the others together.
   const read = async stream => {
     if (job.output_bytes?.[stream] === 0) return Buffer.alloc(0);
@@ -238,7 +274,7 @@ 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 }, ended = endedBy(job, timeoutSeconds);
+  const streams = { stdout: out, stderr: err };
   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);
@@ -307,7 +343,7 @@ export async function hostedRequest(id, method, path, params = {}, { request = a
   return transport(method, path, { ...params, gateway: access.gateway, token: access.token });
 }
 export async function hostedSessionCommand(command, argv, { store = sessionStore(), request = api, transport = macRequest, run = runProcess, print = console.log, sleep = ms => new Promise(r => setTimeout(r, ms)), now = Date.now,
-  stdout = data => process.stdout.write(data), stderr = data => process.stderr.write(data), exitWith = code => { process.exitCode = code; } } = {}) {
+  stdout = data => process.stdout.write(data), stderr = data => process.stderr.write(data), exitWith = code => { process.exitCode = code; } , watch = watchFolder, stopWatching = undefined, debounceMs = 600} = {}) {
   let parsed;
   try { parsed = parseArgs({ args: argv, options, allowPositionals: true }); }
   catch (error) { throw new CliError(error.message); }
@@ -452,7 +488,7 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
   }
   if (["exec", "job", "output"].includes(command)) {
     const local = localSession(), base = `/api/v1/mac/sessions/${sessionId(local.id)}`;
-    let path, method = "GET", params = {};
+    let path, method = "GET", params = {}, waitSeconds = integer(values.wait, 30, 0, 3600);
     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); }
@@ -461,8 +497,11 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
       // Without a key, a long wait implies a long command, so the command's own limit follows it unless set.
       // With a key the limit must not depend on --wait: a retry with another --wait is the same command.
       // 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);
+      // A command given a long --timeout and no --wait is waited for too, up to 10 minutes (what an
+      // agent's shell usually allows); the line printed after 5 s says how to go on if interrupted.
+      const given = values.timeout === undefined ? null : integer(values.timeout, 0, 1, 3600);
+      const waitFor = waitSeconds = integer(values.wait, given === null ? 30 : Math.min(given, 600), 0, 3600);
+      const timeout = given ?? (values["request-key"] === undefined ? Math.max(300, waitFor) : 600);
       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;
@@ -487,7 +526,14 @@ 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), timeoutSeconds: params.body?.timeout_seconds });
+    // Where printing a command's output stopped, so a later nomac job --wait goes on from there.
+    const kept = store.jobCursors(), keepCursors = (job, at) => {
+      const next = Object.fromEntries(Object.entries(store.jobCursors()).filter(([id]) => id !== job).slice(-19));
+      if (at) next[job] = { stdout: at.stdout, stderr: at.stderr };
+      store.saveJobCursors(next);
+    };
+    return waitForCommand(local.id, base, result, waitSeconds, { request, transport, cache, print, stdout, stderr, exitWith, sleep, now, json: Boolean(values.json), timeoutSeconds: params.body?.timeout_seconds,
+      cursors: command === "job" ? kept[result.id] ?? null : null, keepCursors });
   }
   if (command === "screenshot") {
     if (positionals.length) throw new CliError("Usage: nomac screenshot [--simulator] [-o FILE]");
@@ -580,6 +626,58 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     const local = await ready(localSession());
     return run("ssh", [...sshArgs(local, { batch: false }), ...(!positionals.length && process.stdin.isTTY ? ["-t"] : []), ...(values.forward ?? []).flatMap(v => ["-L", forwardingArg(v)]), "-o", "ExitOnForwardFailure=yes", local.target, workspaceCommand(local, positionals)], { inherit: true });
   }
+  if (command === "sync" && values.watch) {
+    if (values["dry-run"] || values.json) throw new CliError("nomac sync --watch keeps sending changes: use it without --dry-run and --json.");
+    if (positionals.length > 1 || (positionals[0] && resolve(positionals[0]) !== store.project)) throw new CliError("Run nomac sync . --watch from the attached project.");
+    return watchSync();
+  }
+  /**
+   * nomac sync . --watch: sync now, then again a moment after files change, until Ctrl-C. Each
+   * sync takes the folder's lock only while it runs, so pull, exec and stop work alongside;
+   * changes in skipped folders (node_modules, build output, .git) start none.
+   */
+  async function watchSync() {
+    const clock = () => new Date().toISOString().slice(11, 19);
+    let skipped = [], running = false, again = false, timer, finish;
+    const syncOnce = async (first) => {
+      if (running) { again = true; return; }
+      running = true;
+      try {
+        do {
+          again = false;
+          try {
+            const result = await store.locked(async () => syncProject(await ready(localSession()), store, { overwrite: values.overwrite, deleteMissing: values.delete, run }), "nomac sync --watch");
+            skipped = result.skipped;
+            if (first) print(`${describeSync(result)}\nWatching ${store.project} for changes; Ctrl-C stops.`);
+            else if (result.changed.length || result.deleted?.length || result.kept_on_mac?.length) print(`${clock()} ${describeSync({ ...result, skipped: [] })}`);
+          } catch (error) {
+            // A stopped Mac ends the watch; a conflict, a busy folder or a lost connection is said, and it goes on.
+            if (error?.code === "session_not_ready") throw error;
+            print(`${clock()} ${error.friendly || error.message}`);
+          }
+          first = false;
+        } while (again);
+      } finally { running = false; }
+    };
+    await syncOnce(true);
+    const ignored = name => {
+      if (!name) return false;
+      const path = String(name).split(sep).join("/");
+      if (/(^|\/)(\.DS_Store|\.nomac-download-[^/]*)$/.test(path) || inSkippedFolder(path)) return true;
+      return skipped.some(item => item.path.endsWith("/") ? path === item.path.slice(0, -1) || path.startsWith(item.path) : path === item.path);
+    };
+    const watcher = watch(store.project, { recursive: true }, (_event, name) => {
+      if (ignored(name)) return;
+      clearTimeout(timer);
+      timer = setTimeout(() => { syncOnce(false).catch(error => finish(error)); }, debounceMs);
+    });
+    await new Promise((done, fail) => {
+      finish = error => { clearTimeout(timer); watcher.close(); if (error) fail(error); else done(); };
+      watcher.on?.("error", error => finish(new CliError("watch failed", `Watching ${store.project} stopped: ${error.message}`)));
+      if (stopWatching) stopWatching.then(() => finish());
+      else process.once("SIGINT", () => finish());
+    });
+  }
   return store.locked(async () => {
     if (command === "attach") {
       if (positionals.length > 1) throw new CliError("Usage: nomac attach [SESSION_ID] [--wait SECONDS] [--json]");
@@ -669,11 +767,13 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
       return output(result);
     }
     if (command === "pull") {
+      // Like cp, the Mac's path first: say the command that does it.
+      if (positionals.length === 2 && values.from === undefined) throw new CliError("pull usage", `nomac pull takes one path, where the files go here; the Mac's path goes in --from: nomac pull ${shellWords([positionals[1]])} --from ${shellWords([positionals[0]])}`);
       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);
     }
     throw new CliError("Unknown cloud session command.");
-  });
+  }, `nomac ${command}`);
 }

package/src/lifecycle-schemas.json

@@ -627,5 +627,137 @@
       "action"
     ],
     "additionalProperties": false
+  },
+  "set_subscription_prices": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "subscription": {
+        "minItems": 1,
+        "maxItems": 8,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "relationship": {
+              "type": "string",
+              "maxLength": 100,
+              "pattern": "^[A-Za-z][A-Za-z0-9]*$"
+            },
+            "id": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 512
+            },
+            "query": {
+              "type": "object",
+              "propertyNames": {
+                "type": "string",
+                "maxLength": 120
+              },
+              "additionalProperties": {
+                "anyOf": [
+                  {
+                    "type": "string",
+                    "maxLength": 4096
+                  },
+                  {
+                    "type": "number"
+                  },
+                  {
+                    "type": "boolean"
+                  },
+                  {
+                    "maxItems": 200,
+                    "type": "array",
+                    "items": {
+                      "type": "string",
+                      "maxLength": 1024
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          "required": [
+            "relationship",
+            "id"
+          ],
+          "additionalProperties": false
+        },
+        "description": "The subscription, as the scope read_store returned for it"
+      },
+      "base_price_point": {
+        "minItems": 1,
+        "maxItems": 8,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "relationship": {
+              "type": "string",
+              "maxLength": 100,
+              "pattern": "^[A-Za-z][A-Za-z0-9]*$"
+            },
+            "id": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 512
+            },
+            "query": {
+              "type": "object",
+              "propertyNames": {
+                "type": "string",
+                "maxLength": 120
+              },
+              "additionalProperties": {
+                "anyOf": [
+                  {
+                    "type": "string",
+                    "maxLength": 4096
+                  },
+                  {
+                    "type": "number"
+                  },
+                  {
+                    "type": "boolean"
+                  },
+                  {
+                    "maxItems": 200,
+                    "type": "array",
+                    "items": {
+                      "type": "string",
+                      "maxLength": 1024
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          "required": [
+            "relationship",
+            "id"
+          ],
+          "additionalProperties": false
+        },
+        "description": "The price point to start from (for example the USA one), as the scope read_store returned for it"
+      },
+      "plan_type": {
+        "description": "The prices' plan type, when the subscription's prices have one (read_store shows each price's planType)",
+        "type": "string",
+        "enum": [
+          "MONTHLY",
+          "UPFRONT"
+        ]
+      },
+      "confirm": {
+        "type": "boolean"
+      }
+    },
+    "required": [
+      "subscription",
+      "base_price_point"
+    ],
+    "additionalProperties": false
   }
 }

package/src/mcp.mjs

@@ -71,13 +71,14 @@ export const TOOLS = [
   },
   ...[
     ["read_store", "read", "Read a discovered Apple GET operation. Start with an apps_* relationship and scope:[]; reuse the returned resource scopes. Paginate with next_cursor and unchanged query. Raw IDs are accepted only for global lookups. Reads live Apple state, file upload operations and analytics report URLs."],
+    ["set_subscription_prices", "subscription-prices", "Sets a subscription's price in every territory from one base price point, using Apple's equalized prices (what App Store Connect's all-territories pricing does): territories already at that price are skipped, the others are set one by one, about 40 per call within 35 seconds. Call again (a new request_key, or none) until remaining is 0; a repeat changes nothing. Apple's refusal for a territory is listed in failed (UNSUPPORTED_TERRITORY: set the subscription's availability there first). Without confirm it returns a preview with the counts. Prices come from the human."],
     ["update_store", "write", "Execute a discovered Apple write using its exact JSON:API body. Copy scope and relationship references from read_store. Preview by default; confirm:true changes real Apple resources. Use owner-authorized prices and attestations. On pending, retry identical arguments with request_key; get_store_operation recovers lost keys. Use publish/update_review/manage_testflight for their dedicated lifecycle actions."],
   ].map(([name, route, description]) => ({
     name, description,
-    inputSchema: { ...lifecycleSchemas[name], properties: { project_id: { type: "string" }, ...lifecycleSchemas[name].properties, ...(route === "write" ? { request_key: { type: "string" } } : {}) } },
+    inputSchema: { ...lifecycleSchemas[name], properties: { project_id: { type: "string" }, ...lifecycleSchemas[name].properties, ...(route !== "read" ? { request_key: { type: "string" } } : {}) } },
     handler: async args => {
       const { project_id: _project, request_key, ...body } = args;
-      return text(await api("POST", `/api/v1/projects/${encodeURIComponent(await resolveProjectId(args))}/store/${route}`, { body, ...(route === "write" ? { idempotencyKey: request_key ?? `mcp-store-${randomUUID()}` } : {}) }));
+      return text(await api("POST", `/api/v1/projects/${encodeURIComponent(await resolveProjectId(args))}/store/${route}`, { body, ...(route !== "read" ? { idempotencyKey: request_key ?? `mcp-store-${randomUUID()}` } : {}) }));
     },
   })),
   {
@@ -340,7 +341,7 @@ export const TOOLS = [
   })),
   ...[
     ["update_review", "reviews", "Resolve a fixed rejected item, remove an item, cancel review, resubmit ready items or release an approved version. Use exact IDs from get_review. Preview without confirm; confirm:true performs the action. Removal cannot be undone in that submission. Fix actual issues before resolving. On pending, repeat unchanged arguments with request_key; get_store_operation recovers it."],
-    ["manage_testflight", "testflight", "Set beta metadata/contact/demo credentials, create/update external groups/public links, invite/remove an explicit tester, distribute a specific Apple build to explicit groups and Beta App Review, notify after approval, expire testing, or relay a human-provided encryption answer. Preview without confirm; confirm:true applies. auto_notify defaults false. Never guess attestations. On pending, repeat unchanged arguments with request_key."],
+    ["manage_testflight", "testflight", "Set beta metadata/contact/demo credentials, create/update external groups/public links, invite/remove an explicit tester (internal groups take App Store Connect team members), distribute a specific Apple build to explicit groups (external ones go through Beta App Review, the internal group needs none), notify after approval, expire testing, or relay a human-provided encryption answer. Preview without confirm; confirm:true applies. auto_notify defaults false. Never guess attestations. On pending, repeat unchanged arguments with request_key."],
     ["prepare_review_reply", "reviews/reply", "Prepare YOUR authored reply with an App Store Connect handoff. Always returns sent:false: Apple's public API cannot read or send reviewer messages. The human must paste and send it. This does not change reviewer notes or public customer reviews."],
   ].map(([name, path, description]) => ({
     name, description,

package/src/session-store.mjs

@@ -4,6 +4,20 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { CliError } from "./api.mjs";
 
+/** Who holds a folder's lock, or null for a lock without a readable record (an older nomac's). */
+function lockOwner(file) {
+  try {
+    const owner = JSON.parse(readFileSync(file, "utf8"));
+    return Number.isSafeInteger(owner?.pid) && owner.pid > 0 ? { pid: owner.pid, command: String(owner.command ?? "a nomac command"), started_at: String(owner.started_at ?? "") } : null;
+  } catch { return null; }
+}
+
+/** Whether a process with this ID exists (one of another user's counts). */
+function running(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (error) { return error.code === "EPERM"; }
+}
+
 /** Session metadata stays outside the project: a checkout cannot choose an SSH target. */
 export function sessionStore(projectDir = process.cwd(), stateDir = join(homedir(), ".nomac", "sessions")) {
   const project = realpathSync(projectDir);
@@ -15,6 +29,8 @@ export function sessionStore(projectDir = process.cwd(), stateDir = join(homedir
   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");
+  // How much of each recent command's output was printed while waiting for it.
+  const cursorsFile = join(directory, "job-cursors.json");
   const read = (file) => {
     if (!existsSync(file)) return null;
     try { return JSON.parse(readFileSync(file, "utf8")); }
@@ -35,12 +51,32 @@ export function sessionStore(projectDir = process.cwd(), stateDir = join(homedir
     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 }); }
+    jobCursors: () => read(cursorsFile) ?? {},
+    saveJobCursors: (value) => write(cursorsFile, value),
+    /** Runs operation (nomac sync, pull, start…) alone for this folder; `what` names it to a second one. */
+    async locked(operation, what = "a nomac command") {
+      const lock = join(directory, "operation.lock"), ownerFile = join(lock, "owner.json");
+      const take = () => {
+        mkdirSync(lock, { mode: 0o700 });
+        writeFileSync(ownerFile, JSON.stringify({ pid: process.pid, command: what, started_at: new Date().toISOString() }) + "\n", { mode: 0o600 });
+      };
+      try { take(); }
       catch (error) {
         if (error.code !== "EEXIST") throw error;
-        throw new CliError("session busy", `Another session operation is running. If it was interrupted, verify it has ended before removing ${lock}.`);
+        const owner = lockOwner(ownerFile);
+        if (!owner) throw new CliError("session busy", `Another nomac command is using this folder (an older nomac's lock, which does not say which). If no other nomac command is running, remove it: rm -r '${lock}'`);
+        if (running(owner.pid)) throw new CliError("session busy", `Another nomac command is using this folder: ${owner.command} (pid ${owner.pid}, since ${owner.started_at}). Wait for it to finish, or stop it: kill ${owner.pid}. If pid ${owner.pid} is not nomac, remove the lock: rm -r '${lock}'`);
+        // Its process has ended (killed, or its terminal closed): move that lock aside, the same one
+        // only (another command may have just replaced it), and take it.
+        const aside = `${lock}.${randomUUID()}.ended`;
+        try { renameSync(lock, aside); } catch (moved) { if (moved.code !== "ENOENT") throw moved; }
+        if (existsSync(aside) && JSON.stringify(lockOwner(join(aside, "owner.json"))) !== JSON.stringify(owner)) {
+          try { renameSync(aside, lock); } catch { /* its command's own cleanup removes it */ }
+          throw new CliError("session busy", "Another nomac command is using this folder. Wait for it to finish.");
+        }
+        rmSync(aside, { recursive: true, force: true });
+        try { take(); }
+        catch (again) { if (again.code === "EEXIST") throw new CliError("session busy", "Another nomac command is using this folder. Wait for it to finish."); throw again; }
       }
       try { return await operation(); }
       finally { rmSync(lock, { recursive: true, force: true }); }

package/src/session-transfer.mjs

@@ -31,6 +31,8 @@ const BUILT_IN = [
 // 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.
 const builtInRules = BUILT_IN.map(({ pattern, reason }) => ({ rules: ignoreFactory().add(pattern), reason }));
+/** Whether a path is inside a folder sync always leaves out (node_modules, build output, .git…). */
+export const inSkippedFolder = path => String(path).split(/[\\/]/).slice(0, -1).some(name => builtInRules.some(rule => rule.rules.ignores(`${name}/`)));
 
 /** Code-unit order, the same as Array.prototype.sort on the file lists. */
 const byPath = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
@@ -282,17 +284,25 @@ export async function syncProject(session, store, { overwrite = false, dryRun =
   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) {
+  // Only what differs travels; a file already the same on the Mac is recorded as such.
+  for (const path of send) if (previous[path] === local[path]) baseline[path] = local[path];
+  if (changed.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;
+    output = (await run("rsync", [...transferArgs(), "--links", "--from0", "--files-from=-", `${store.project}/`, `${session.target}:./`], { input: Buffer.from(changed.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 after = changed.length ? await remoteFingerprints(session, changed, { run }) : {};
+  const changedDuringTransfer = changed.filter(path => after[path] !== local[path]);
+  for (const path of changed) 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.");
+  if (changedDuringTransfer.length) {
+    const one = changedDuringTransfer.length === 1;
+    const error = new CliError("transfer changed during verification", `Changed here while being sent: ${listed(changedDuringTransfer)}. The Mac may not have ${one ? "its" : "their"} latest version; once edits stop, run nomac sync again to send ${one ? "it" : "them"}.${conflicts.length
+      ? ` Not sent, because changed on the Mac since this folder last synced: ${listed(conflicts)}. Keep the Mac's version: nomac pull ${conflicts[0]}. Replace it with yours: nomac sync . --overwrite` : " Everything else was sent."}`);
+    error.details = { changed_during_transfer: changedDuringTransfer, ...(conflicts.length ? { conflicts } : {}) };
+    throw error;
+  }
   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 };
 }

package/src/sessions.mjs

@@ -140,5 +140,5 @@ export async function sessionCommand(command, argv, { store: suppliedStore, run
       return output(result, describePull(result));
     }
     throw new CliError("unknown session command");
-  });
+  }, `nomac ${command}`);
 }