@nomac/cli 0.5.1 → 0.5.3

package/package.json

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

package/src/api.mjs

@@ -1,4 +1,5 @@
 import { loadApiKey, loadApiUrl } from "./config.mjs";
+import { clientHeaders } from "./client-info.mjs";
 
 export class CliError extends Error {
   constructor(message, friendly, status, code, details) {
@@ -16,7 +17,7 @@ export async function apiPublic(method, path, body) {
   const url = `${loadApiUrl()}${path}`;
   const res = await fetch(url, {
     method,
-    headers: body !== undefined ? { "content-type": "application/json" } : {},
+    headers: { ...clientHeaders(), ...(body !== undefined ? { "content-type": "application/json" } : {}) },
     body: body !== undefined ? JSON.stringify(body) : undefined,
   });
   const text = await res.text();
@@ -41,6 +42,7 @@ export async function api(method, path, { body, raw, idempotencyKey } = {}) {
   const res = await fetch(url, {
     method,
     headers: {
+      ...clientHeaders(),
       authorization: `Bearer ${key}`,
       ...(raw
         ? { "content-type": "application/gzip" }

package/src/client-info.mjs

@@ -0,0 +1,33 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { readFileSync } from "node:fs";
+
+/**
+ * How requests identify this CLI to nomac.app for product analytics: version,
+ * OS and, under `nomac mcp`, the agent and tool making the call. No hostnames,
+ * paths or arguments.
+ */
+export const CLI_VERSION = (() => {
+  try { return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version; } catch { return "0.0.0"; }
+})();
+export const USER_AGENT = `nomac-cli/${CLI_VERSION} (${process.platform}; node ${process.versions.node})`;
+
+/** Set by the stdio MCP server: the connected agent (from initialize) and the running tool. */
+export const mcpContext = { client: undefined };
+export const toolScope = new AsyncLocalStorage();
+
+export function clientHeaders() {
+  const tool = toolScope.getStore()?.tool;
+  return {
+    "user-agent": USER_AGENT,
+    ...(mcpContext.client ? { "x-nomac-mcp-client": mcpContext.client } : {}),
+    ...(tool ? { "x-nomac-tool": tool } : {}),
+  };
+}
+
+/** "claude-code/2.1.4" from an MCP clientInfo, or undefined. */
+export function mcpClientName(info) {
+  const name = typeof info?.name === "string" ? info.name.toLowerCase().replace(/[^a-z0-9._+-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) : "";
+  if (!name) return undefined;
+  const version = typeof info?.version === "string" ? /^\d{1,4}(\.\d{1,6}){0,3}/.exec(info.version)?.[0] : undefined;
+  return version ? `${name}/${version}` : name;
+}

package/src/mac-transport.mjs

@@ -4,6 +4,7 @@ import { HttpsProxyAgent } from "https-proxy-agent";
 import { getProxyForUrl } from "proxy-from-env";
 import WebSocket, { createWebSocketStream } from "ws";
 import { CliError } from "./api.mjs";
+import { clientHeaders } from "./client-info.mjs";
 
 export function sessionId(value) {
   const id = String(value ?? "").replace(/^nomac-/, "");
@@ -25,8 +26,27 @@ export function transportOptions(options = {}) {
   return { url, token, agent: proxy ? new HttpsProxyAgent(proxy) : undefined, ca: options.ca };
 }
 
-/** Bounded requests deliberately do not require streaming responses or retry mutations. */
-export function macRequest(method, path, { body, raw, requestKey, ...options } = {}) {
+/** How long a busy guest is retried before guest_busy reaches the caller. */
+export const GUEST_BUSY_RETRY = { budgetMs: 75_000, pauseMs: 3_000 };
+
+/**
+ * A saturated guest (e.g. a first Simulator boot) answers slowly for a minute or
+ * two. Guest operations are idempotent by job ID, request key and blob offset, so
+ * only guest_busy is retried; every other failure is returned for reconciliation.
+ */
+export function macRequest(method, path, options = {}) {
+  const started = Date.now();
+  // The first attempt runs synchronously, so invalid input still throws immediately.
+  const attempt = () => macRequestOnce(method, path, options).catch(async error => {
+    if (error?.code !== "guest_busy" || Date.now() - started + GUEST_BUSY_RETRY.pauseMs + 15_000 > GUEST_BUSY_RETRY.budgetMs) throw error;
+    await new Promise(resolve => setTimeout(resolve, GUEST_BUSY_RETRY.pauseMs));
+    return attempt();
+  });
+  return attempt();
+}
+
+/** Bounded requests deliberately do not require streaming responses. */
+function macRequestOnce(method, path, { body, raw, requestKey, ...options } = {}) {
   const { url, token, agent, ca } = transportOptions(options);
   if (!path.startsWith("/api/v1/mac/") || path.includes("#")) throw new CliError("Invalid Mac API path.");
   const target = new URL(path, url);
@@ -41,6 +61,7 @@ export function macRequest(method, path, { body, raw, requestKey, ...options } =
     };
     const request = (target.protocol === "https:" ? https : http).request(target, {
       method, agent, ca, headers: {
+        ...clientHeaders(),
         authorization: `Bearer ${token}`,
         ...(payload ? { "content-type": raw ? "application/octet-stream" : "application/json", "content-length": payload.length } : {}),
         ...(requestKey ? { "idempotency-key": requestKey } : {}),
@@ -80,7 +101,7 @@ export function tunnel(value, { input = process.stdin, output = process.stdout,
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   return new Promise((resolve, reject) => {
     const ws = new WebSocket(url, {
-      agent, ca, headers: { authorization: `Bearer ${token}` },
+      agent, ca, headers: { ...clientHeaders(), authorization: `Bearer ${token}` },
       handshakeTimeout: 15_000, perMessageDeflate: false, maxPayload: 1024 * 1024,
       followRedirects: false,
     });

package/src/mcp.mjs

@@ -7,6 +7,7 @@ import { readFileSync } from "node:fs";
 const lifecycleSchemas = JSON.parse(readFileSync(new URL("./lifecycle-schemas.json", import.meta.url), "utf8"));
 import { createInterface } from "node:readline";
 import { api } from "./api.mjs";
+import { mcpClientName, mcpContext, toolScope } from "./client-info.mjs";
 import { loadProjectState, saveProjectState } from "./config.mjs";
 import { packTarball } from "./pack.mjs";
 import { uploadSourceSnapshot } from "./upload.mjs";
@@ -401,6 +402,7 @@ export async function runMcpServer() {
     try {
       switch (method) {
         case "initialize":
+          mcpContext.client = mcpClientName(params?.clientInfo);
           reply({
             protocolVersion: params?.protocolVersion ?? PROTOCOL_FALLBACK,
             capabilities: { tools: {} },
@@ -422,7 +424,7 @@ export async function runMcpServer() {
           const tool = TOOLS.find((t) => t.name === params?.name);
           if (!tool) return fail(-32602, `unknown tool: ${params?.name}`);
           try {
-            reply(await tool.handler(params?.arguments ?? {}));
+            reply(await toolScope.run({ tool: tool.name }, () => tool.handler(params?.arguments ?? {})));
           } catch (err) {
             reply({
               content: [{ type: "text", text: err?.details ? JSON.stringify({ error: { ...err.details, message: err.friendly ?? err.message } }, null, 2) : err?.friendly ?? err?.message ?? String(err) }],