@nomac/cli 0.11.1 → 0.11.2

package/package.json

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

package/src/cli.mjs

@@ -10,6 +10,7 @@ Start:
   nomac login                  connect this device (approve in the browser)
   nomac credits                credit left; nomac credits buy --packs N adds more
   nomac start                  start a Mac, or reconnect to yours
+  nomac attach                 use from this folder the Mac your agent started elsewhere (MCP, dashboard)
   nomac stop                   stop the Mac: deletes it and its files (not ~/drive), billing ends
 
 Use it:
@@ -101,6 +102,7 @@ export async function main(argv) {
       }
     // falls through: everyone else sees their Mac
     case "start":
+    case "attach":
     case "exec":
     case "job":
     case "output":

package/src/hosted-sessions.mjs

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { chmodSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { parseArgs } from "node:util";
@@ -52,6 +52,8 @@ const HELP = `Nomac cloud Mac sessions
                                     start a screen video; nomac record stop saves it
                                     as nomac-recording.mp4 (or -o) with a share link
   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)
 
 Login once with nomac login. The CLI creates a local SSH key; it sends only the
@@ -196,10 +198,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 10 minutes: nomac ssh -- command. 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.`;
     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 10 minutes:        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.\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`);
     exitWith(unknown ? 1 : STILL_RUNNING);
     return job;
   }
@@ -286,11 +288,11 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
   catch (error) { throw new CliError(error.message); }
   const { values, positionals } = parsed;
   if (values.help) return print(command === "desktop" ? DESKTOP_HELP : HELP);
-  const wait = ["start", "stop"].includes(command) ? integer(values.wait, command === "start" ? 300 : 60, 0, command === "start" ? 600 : 300) : 0;
+  const wait = ["start", "attach", "stop"].includes(command) ? integer(values.wait, command === "stop" ? 60 : 300, 0, command === "stop" ? 300 : 600) : 0;
   if (command === "start" && values["request-key"] !== undefined && !validRequestKey(values["request-key"])) throw new CliError("Use a request key of 8–128 letters, digits, underscores, periods, colons or hyphens.");
   const output = result => {
     // Sync, pull and the other commands answer with their own result, which has no session.
-    if (values.json || !["start", "stop"].includes(command)) { print(JSON.stringify(result, null, 2)); return result; }
+    if (values.json || !["start", "attach", "stop"].includes(command)) { print(JSON.stringify(result, null, 2)); return result; }
     const billing = result.session?.billing;
     const usage = billing?.mode === "weekly_included"
       ? `Included time used: ${billing.used_seconds} seconds. No extra charge.`
@@ -298,7 +300,7 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     const next = result.session.state === "ready" ? "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" : "Check: nomac session status --json";
-    print(`${result.session.id}: ${result.session.state}\n${next}\n${usage}${result.warning ? `\n${result.warning}` : ""}`);
+    print(`${result.attached ? `${result.attached}\n` : ""}${result.session.id}: ${result.session.state}\n${next}\n${usage}${result.warning ? `\n${result.warning}` : ""}`);
     return result;
   };
   const saveView = (local, view) => {
@@ -313,10 +315,44 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     if (local.state !== "ready") throw new CliError("Mac is not ready.", `Session ${local.id} is ${local.state}. Run nomac session status --json.`, undefined, "session_not_ready");
     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") });
     writeFileSync(local.knownHosts, `nomac-${local.id} ${access.ssh.host_key}\n`, { mode: 0o600 }); chmodSync(local.knownHosts, 0o600); store.save(local);
     return 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
+   * ssh, sync and pull work here too.
+   */
+  async function addKey(local) {
+    const key = readFileSync(`${local.identity}.pub`, "utf8").trim();
+    const job = await request("POST", `/api/v1/mac/sessions/${sessionId(local.id)}/jobs?wait=30`, { idempotencyKey: `cli-key-${createHash("sha256").update(key).digest("hex").slice(0, 32)}`,
+      body: { argv: ["/bin/bash", "-c", 'umask 077; mkdir -p ~/.ssh && grep -qxF "$NOMAC_KEY" ~/.ssh/authorized_keys 2>/dev/null || printf "%s\n" "$NOMAC_KEY" >> ~/.ssh/authorized_keys'], env: { NOMAC_KEY: key }, timeout_seconds: 30 } });
+    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);
+  }
+  /** The account's running Macs, newest first: queued, starting or ready. */
+  async function liveSessions() {
+    const answer = await request("GET", "/api/v1/mac/sessions");
+    return (Array.isArray(answer?.sessions) ? answer.sessions : []).filter(s => ["queued", "provisioning", "ready"].includes(s.state));
+  }
+  /** This folder now uses that Mac: a fresh key of its own, then ready() adds it once the Mac is ready. */
+  async function attachTo(view) {
+    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 } : {}) } };
+    store.save(local); store.saveBaseline({});
+    const deadline = now() + wait * 1000;
+    for (;;) {
+      await refresh(local);
+      if (!["queued", "provisioning"].includes(local.state) || now() >= deadline) break;
+      await sleep(2000);
+    }
+    if (local.state === "ready") await ready(local);
+    return local;
+  }
   const localSession = () => {
     const local = store.load();
     if (local?.mode !== "hosted" || !local.id) throw new CliError("No attached cloud session.", "Run nomac start to allocate or reconcile your Mac.");
@@ -332,8 +368,10 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     if (!loaded) { print(values.json ? JSON.stringify({ session: null }) : "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);
-    if (values.json) { print(JSON.stringify({ session, ...(result.image ? { image: result.image } : {}) }, null, 2)); return session; }
-    print(statusSummary(session, result.image));
+    // 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` : ""));
     return session;
   }
   if (["exec", "job", "output"].includes(command)) {
@@ -345,8 +383,9 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
       // 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.
       // With a key the limit must not depend on --wait: a retry with another --wait is the same command.
-      const waitFor = integer(values.wait, 30, 0, 600);
-      const timeout = integer(values.timeout, values["request-key"] === undefined ? Math.max(300, waitFor) : 600, 1, 600);
+      // 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: positionals, timeout_seconds: timeout } };
     } else {
       if (positionals.length !== 1 || !/^job_[a-f0-9]{40}$/.test(positionals[0])) throw new CliError("Supply the existing job ID.");
@@ -368,7 +407,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, 600), { 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) });
   }
   if (command === "screenshot") {
     if (positionals.length) throw new CliError("Usage: nomac screenshot [--simulator] [-o FILE]");
@@ -462,6 +501,20 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
     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 });
   }
   return store.locked(async () => {
+    if (command === "attach") {
+      if (positionals.length > 1) throw new CliError("Usage: nomac attach [SESSION_ID] [--wait SECONDS] [--json]");
+      const live = await liveSessions(), wanted = positionals[0] && sessionId(positionals[0]);
+      const current = store.load();
+      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}.` });
+      }
+      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.` });
+    }
     if (command === "start") {
       if (positionals.length) throw new CliError("Usage: nomac start [--wait SECONDS] [--json]");
       let local = store.load();
@@ -493,6 +546,14 @@ export async function hostedSessionCommand(command, argv, { store = sessionStore
         let result;
         try { result = await request("POST", "/api/v1/mac/sessions", { idempotencyKey: local.requestKey, body: local.request }); }
         catch (error) {
+          // One Mac runs per account: when it was started elsewhere (an agent over MCP, the dashboard), use it from here.
+          if (error.code === "session_limit_reached" && values["request-key"] === undefined) {
+            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.` });
+            }
+          }
           if (!previouslyUncertain && startRejections.has(error.code) && Number.isInteger(error.status) && error.status >= 400 && error.status <= 503) {
             local.state = "failed"; local.rejection = error.code; store.save(local);
           }

package/src/transport-command.mjs

@@ -44,7 +44,7 @@ export async function transportCommand(args, { request = macRequest, print = con
     const options = parsed(rest.slice(0, separator), ["--request-key", "--timeout"]);
     if (!/^[A-Za-z0-9_.:-]{8,128}$/.test(options["--request-key"] ?? "")) throw new CliError("Supply a stable --request-key of 8 to 128 safe characters.");
     const timeout = Number(options["--timeout"] ?? 300);
-    if (!Number.isInteger(timeout) || timeout < 1 || timeout > 600) throw new CliError("--timeout must be 1 to 600 seconds.");
+    if (!Number.isInteger(timeout) || timeout < 1 || timeout > 3600) throw new CliError("--timeout must be 1 to 3600 seconds.");
     result = await request("POST", `${base}/jobs`, { requestKey: options["--request-key"], body: { argv: rest.slice(separator + 1), timeout_seconds: timeout } });
   } else if (command === "job" || command === "output") {
     const [job, ...flags] = rest;