simulator-use 0.10.1 → 0.11.0

package/dist/state-archive.js

@@ -0,0 +1,196 @@
+import { spawn } from "node:child_process";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdtemp, rename, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGunzip, createGzip } from "node:zlib";
+/**
+ * A saved phone state as NoMac keeps it in its storage (October 25, 2026), so any phone of the same model and iOS
+ * restores it, on any host: its folder as a tar, gzipped, in AES-256-GCM frames of up to 4 MiB under the state's own
+ * key (NoMac's, given for one transfer). Each frame is authenticated with its index and whether it is the last, so an
+ * archive cut short, reordered or changed is refused before anything of it is kept.
+ */
+const MAGIC = Buffer.from("NMS1");
+const FRAME = 4 * 1024 * 1024;
+const NONCE = 12;
+const TAG = 16;
+/** The longest a frame may claim: a corrupt length never makes the reader hold gigabytes. */
+const MOST = FRAME + 64 * 1024;
+const aad = (index, last) => {
+    const b = Buffer.alloc(MAGIC.length + 9);
+    MAGIC.copy(b);
+    b.writeBigUInt64BE(BigInt(index), MAGIC.length);
+    b[MAGIC.length + 8] = last ? 1 : 0;
+    return b;
+};
+export function stateKey(key) {
+    const raw = Buffer.from(key, "base64url");
+    if (raw.length !== 32 || raw.toString("base64url") !== key)
+        throw new Error("invalid_state_key");
+    return raw;
+}
+/** Plain bytes in, sealed frames out. The last frame is sealed as last at the end, empty if need be. */
+export function sealer(key) {
+    let pending = Buffer.alloc(0), index = 0, started = false;
+    const frame = (t, plain, last) => {
+        const nonce = randomBytes(NONCE);
+        const cipher = createCipheriv("aes-256-gcm", key, nonce);
+        cipher.setAAD(aad(index++, last));
+        const body = Buffer.concat([cipher.update(plain), cipher.final()]);
+        const length = Buffer.alloc(4);
+        length.writeUInt32BE(plain.length);
+        t.push(Buffer.concat([length, nonce, body, cipher.getAuthTag()]));
+    };
+    return new Transform({
+        transform(chunk, _enc, done) {
+            if (!started) {
+                this.push(MAGIC);
+                started = true;
+            }
+            pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+            // A full frame goes out only once more data follows it, so the one at the end is the one sealed as last.
+            while (pending.length > FRAME) {
+                frame(this, pending.subarray(0, FRAME), false);
+                pending = pending.subarray(FRAME);
+            }
+            done();
+        },
+        flush(done) {
+            if (!started)
+                this.push(MAGIC);
+            frame(this, pending, true);
+            done();
+        },
+    });
+}
+/** Sealed frames in, plain bytes out: refused at the first frame that does not open, or an end with no last frame. */
+export function opener(key) {
+    let buffered = Buffer.alloc(0), index = 0, header = false, ended = false;
+    return new Transform({
+        transform(chunk, _enc, done) {
+            buffered = buffered.length ? Buffer.concat([buffered, chunk]) : chunk;
+            try {
+                if (!header) {
+                    if (buffered.length < MAGIC.length)
+                        return done();
+                    if (!buffered.subarray(0, MAGIC.length).equals(MAGIC))
+                        throw new Error("not a NoMac phone state");
+                    buffered = buffered.subarray(MAGIC.length);
+                    header = true;
+                }
+                for (;;) {
+                    if (buffered.length < 4)
+                        break;
+                    const length = buffered.readUInt32BE(0);
+                    if (length > MOST)
+                        throw new Error("a frame claims too much");
+                    const whole = 4 + NONCE + length + TAG;
+                    if (buffered.length < whole)
+                        break;
+                    if (ended)
+                        throw new Error("data after the last frame");
+                    const nonce = buffered.subarray(4, 4 + NONCE), body = buffered.subarray(4 + NONCE, 4 + NONCE + length), tag = buffered.subarray(4 + NONCE + length, whole);
+                    // A frame opens as the last or as not: which, its sealing says.
+                    let plain;
+                    for (const last of [false, true]) {
+                        try {
+                            const decipher = createDecipheriv("aes-256-gcm", key, nonce);
+                            decipher.setAAD(aad(index, last));
+                            decipher.setAuthTag(tag);
+                            plain = Buffer.concat([decipher.update(body), decipher.final()]);
+                            ended = last;
+                            break;
+                        }
+                        catch { /* the other way, or neither */ }
+                    }
+                    if (!plain)
+                        throw new Error("the state does not open with its key (changed, or another state's)");
+                    index++;
+                    buffered = buffered.subarray(whole);
+                    if (plain.length)
+                        this.push(plain);
+                }
+                done();
+            }
+            catch (error) {
+                done(error);
+            }
+        },
+        flush(done) {
+            done(!header || !ended || buffered.length ? new Error("the state is cut short") : undefined);
+        },
+    });
+}
+/** tar as a stream, its errors and exit status kept: a tar that fails mid-way fails the pipeline. */
+function tar(args, cwd) {
+    const child = spawn("/usr/bin/tar", args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (d) => { stderr = (stderr + d).slice(-2000); });
+    const exited = new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`tar exited ${code}: ${stderr.trim().split("\n").pop() ?? ""}`))));
+    });
+    return { child, exited };
+}
+/**
+ * The state named name, in statesDir, sealed under key and PUT to url (a link NoMac signed). It is sealed into a file
+ * in tmp first, since the storage takes a PUT of a known length. Answers the bytes sent.
+ */
+export async function uploadState(statesDir, name, url, key, tmp) {
+    const dir = await mkdtemp(join(tmp, "state-")), sealed = join(dir, `${name}.nms`);
+    try {
+        const packing = tar(["-cf", "-", name], statesDir);
+        packing.child.stdin.end();
+        try {
+            await pipeline(packing.child.stdout, createGzip({ level: 1 }), sealer(stateKey(key)), createWriteStream(sealed, { mode: 0o600 }));
+        }
+        catch (error) {
+            packing.child.kill();
+            await packing.exited.catch(() => { });
+            throw error;
+        }
+        await packing.exited;
+        const { size } = await stat(sealed);
+        const body = Readable.toWeb(createReadStream(sealed));
+        const response = await fetch(url, { method: "PUT", body, headers: { "content-length": String(size) }, duplex: "half" });
+        await response.body?.cancel();
+        if (!response.ok)
+            throw new Error(`the state's upload failed: storage answered ${response.status}`);
+        return size;
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+/**
+ * The state at url (sealed under key) unpacked into statesDir as name, replacing a copy there only once all of it
+ * opened: it is unpacked beside it first, then moved into place.
+ */
+export async function fetchState(statesDir, name, url, key) {
+    const response = await fetch(url);
+    if (!response.ok || !response.body)
+        throw new Error(`the state's download failed: storage answered ${response.status}`);
+    const into = await mkdtemp(join(statesDir, `.${name}.fetching-`));
+    try {
+        // bsdtar keeps entries inside into: no absolute paths, no .., no writes through a symlink.
+        const unpacking = tar(["-xf", "-"], into);
+        try {
+            await pipeline(Readable.fromWeb(response.body), opener(stateKey(key)), createGunzip(), unpacking.child.stdin);
+        }
+        catch (error) {
+            // Stopped and gone before its folder is removed, so nothing is written into it after.
+            unpacking.child.kill();
+            await unpacking.exited.catch(() => { });
+            throw error;
+        }
+        await unpacking.exited;
+        await stat(join(into, name, "state.json"));
+        await rm(join(statesDir, name), { recursive: true, force: true });
+        await rename(join(into, name), join(statesDir, name));
+    }
+    finally {
+        await rm(into, { recursive: true, force: true }).catch(() => { });
+    }
+}

package/dist/tools/app-control.js

@@ -2,12 +2,26 @@ import { existsSync } from "node:fs";
 import { resolve as resolvePath } from "node:path";
 import { appInfo, BUNDLE_ID, bundleIdOf, install, pushPayload, simctlAction, stopLogStream } from "../engine/apps.js";
 import { listDevices, pickDevice } from "../engine/simctl.js";
+import { engineCall } from "../engine/native.js";
 import { currentApp, heldDevice, setCurrentApp, setDeviceTimeZone } from "../engine/state.js";
 import { ToolError } from "../errors.js";
+import { setting } from "../settings.js";
 import { readScreen } from "../look/read.js";
 import { render } from "../look/snapshot.js";
 import { grantAll, openInPrompt, setPermissionMode } from "../engine/prompts.js";
 import { launchAndLook, tapPrompt } from "./launch-app.js";
+/**
+ * A link opens through the engine, which reads it from its input: simctl openurl takes it as an argument, which every
+ * user of a Mac can read, so a shared host (SIMULATOR_USE_HOSTED) never falls back to it.
+ */
+export async function openUrl(udid, url) {
+    const answer = await engineCall(udid, { op: "open_url", url }, 20_000);
+    if (answer?.ok)
+        return;
+    if (setting("HOSTED"))
+        throw new ToolError(`Could not open the link${answer?.error ? `: ${answer.error}` : ""}.`, "Check it is a full link with its scheme (https://, or the app's own), then try again.");
+    await simctlAction(["openurl", udid, url], "open the link");
+}
 const ACTIONS = ["launch", "install", "terminate", "uninstall", "open_url", "grant", "revoke", "reset_permissions", "location", "push", "appearance", "locale", "timezone", "text_size", "status_bar"];
 /** simctl ui content_size's sizes. */
 const TEXT_SIZES = ["extra-small", "small", "medium", "large", "extra-large", "extra-extra-large", "extra-extra-extra-large",
@@ -99,7 +113,7 @@ export const appControl = {
             if (!path || !existsSync(path))
                 throw new ToolError("install needs app: the path to a .app built for the Simulator.", "Build with xcodebuild -sdk iphonesimulator; the .app is under Build/Products/Debug-iphonesimulator.");
             const bundleId = await bundleIdOf(path);
-            await install(device.udid, path);
+            await install(device.udid, path, device.runtime);
             const info = await appInfo(device.udid, bundleId);
             await setCurrentApp(device.udid, { bundleId, executable: info?.executable });
             const refused = await grantAll(device.udid, bundleId);
@@ -128,13 +142,13 @@ export const appControl = {
                 await simctlAction(["uninstall", device.udid, bundleId], `remove ${bundleId}`);
                 return { text: `Removed ${bundleId} and its data from ${label}.` };
             case "open_url": {
-                await simctlAction(["openurl", device.udid, value], `open ${value}`);
+                await openUrl(device.udid, value);
                 let snap = (await readScreen(device.udid)).snap;
                 // A link that opens another app makes iOS ask "Open in “App”?": the agent asked for exactly that.
                 const asked = openInPrompt(snap);
                 if (asked)
                     snap = await tapPrompt(device, "Open");
-                return { text: `Opened ${value}.${asked ? ` iOS asked "${asked}": answered Open.` : ""}\n${render(snap, { device: label })}` };
+                return { text: `Opened the link.${asked ? ` iOS asked "${asked}": answered Open.` : ""}\n${render(snap, { device: label })}` };
             }
             case "grant":
             case "revoke":

package/dist/tools/app-logs.js

@@ -64,9 +64,9 @@ export const appLogs = {
             // Swift's own message ("App.swift:64: Fatal error: ...") goes to stderr, not into the report: show both.
             const last = await readFile(await consoleFile(device.udid, bundleId), "utf8").then((t) => cleanConsole(t).slice(-5).map(clip), () => []);
             const output = last.length ? `\nThe app's last output:\n${last.join("\n")}` : "";
-            const crashes = await crashReports(executable, Date.now() - Math.max(seconds, 3_600) * 1000);
+            const crashes = await crashReports(executable, Date.now() - Math.max(seconds, 3_600) * 1000, { bundleId, udid: device.udid });
             if (!crashes.length) {
-                return { text: `No crash report for ${executable} in the last hour. macOS writes one up to a minute after a crash (44 s measured).${output}\nNext: if the app just crashed, call app_logs {crashes: true} again in 30 s.` };
+                return { text: `No crash report for ${bundleId} on ${device.name} in the last hour. macOS writes one up to a minute after a crash (44 s measured).${output}\nNext: if the app just crashed, call app_logs {crashes: true} again in 30 s.` };
             }
             return { text: crashes.map((c) => [`crash at ${c.time} (${c.file})`, ...c.summary].join("\n")).join("\n\n") + output };
         }

package/dist/tools/app-run.js

@@ -2,7 +2,7 @@ import { bundleIdOf, install } from "../engine/apps.js";
 import { answer, claimProject, currentJob, startJob } from "../engine/jobs.js";
 import { bootDevice, findDevice, listDevices, pickDevice } from "../engine/simctl.js";
 import { heldDevice, holdDevice, setDeviceEnv } from "../engine/state.js";
-import { build, builtApp, formatIssue, knownFix, noDestination, projectFor, remember } from "../engine/xcode.js";
+import { build, builtApp, formatIssue, knownFix, noDestination, projectFor, remember, targetTooNew } from "../engine/xcode.js";
 import { pickXcode } from "../engine/xcodes.js";
 import { grantAll, setPermissionMode } from "../engine/prompts.js";
 import { ToolError } from "../errors.js";
@@ -74,7 +74,7 @@ export const appRun = {
         // Finding the project (xcodebuild -list) and booting count toward the 40 s answer too: all of it is the job.
         const job = startJob("Build and run", async (progress) => {
             progress.step("finding the project");
-            const { project, scheme, dir, note, xcode: kept } = await projectFor(args.path, args.scheme);
+            const { project, scheme, dir, note, xcode: kept } = await projectFor(args.path, args.scheme, progress);
             const asked = args.xcode ?? kept;
             const xcode = await pickXcode(asked);
             const other = xcode && !xcode.default ? xcode : undefined;
@@ -99,6 +99,13 @@ export const appRun = {
                 onCancel: (cancel) => progress.setCancel(cancel),
             };
             let result = await build(project, scheme, device.udid, options);
+            // A deployment target later than the phone's iOS leaves no destination either, and no build would install.
+            const tooNew = !result.ok && noDestination(result) ? await targetTooNew(project, scheme, device, "app_run again", other) : undefined;
+            if (tooNew) {
+                progress.setCancel(undefined);
+                progress.setLog(result.log);
+                return { text: `${note}Build of ${scheme} failed: ${tooNew}`, isError: true };
+            }
             // An Xcode older than the phone's iOS cannot name it: it builds for any Simulator, and the app installs all the same.
             let anySimulator = false;
             if (!result.ok && other && noDestination(result)) {
@@ -125,7 +132,7 @@ export const appRun = {
             if (!app)
                 return { text: `Built ${scheme} in ${seconds} s, but found no .app for the Simulator. Full log: ${result.log}`, isError: true };
             const bundleId = await bundleIdOf(app);
-            await install(device.udid, app);
+            await install(device.udid, app, device.runtime);
             const keep = asked && xcode && !xcode.default ? asked : undefined;
             await remember(dir, { project: project.path, scheme, bundleId, ...(keep ? { xcode: keep } : {}) });
             // Granted by default, so no prompt stops the agent; "ask" leaves iOS's prompts for a test of them.