patchrome 0.1.0

package/dist/har.d.ts

@@ -0,0 +1,105 @@
+import type { NetworkEntry, RequestTiming } from "./network.ts";
+export interface HarBody {
+    text: string;
+    encoding: "base64" | undefined;
+}
+interface HarHeader {
+    name: string;
+    value: string;
+}
+export declare function buildHar(entries: NetworkEntry[], bodies: Map<string, HarBody>, creatorVersion: string): {
+    log: {
+        version: string;
+        creator: {
+            name: string;
+            version: string;
+        };
+        pages: {
+            startedDateTime: string;
+            id: string;
+            title: string;
+            pageTimings: {};
+        }[];
+        entries: {
+            pageref: string;
+            startedDateTime: string;
+            time: number;
+            request: {
+                method: string;
+                url: string;
+                httpVersion: string;
+                cookies: never[];
+                headers: HarHeader[];
+                queryString: {
+                    name: string;
+                    value: string;
+                }[];
+                postData?: {
+                    mimeType: string;
+                    text: string;
+                } | undefined;
+                headersSize: number;
+                bodySize: number;
+            };
+            response: {
+                status: number;
+                statusText: string;
+                httpVersion: string;
+                cookies: never[];
+                headers: HarHeader[];
+                content: {
+                    size: number;
+                    mimeType: string;
+                    text?: string | undefined;
+                    encoding?: "base64" | undefined;
+                };
+                redirectURL: string;
+                headersSize: number;
+                bodySize: number;
+            };
+            cache: {};
+            timings: {
+                blocked: number;
+                dns: number;
+                connect: number;
+                ssl: number;
+                send: number;
+                wait: number;
+                receive: number;
+            } | {
+                blocked: number;
+                dns: number;
+                connect: number;
+                ssl: number;
+                send: number;
+                wait: number;
+                receive: number;
+            };
+            _resourceType: string;
+        }[];
+    };
+};
+export declare function harTimings(timing: RequestTiming | undefined): {
+    phases: {
+        blocked: number;
+        dns: number;
+        connect: number;
+        ssl: number;
+        send: number;
+        wait: number;
+        receive: number;
+    };
+    total: undefined;
+} | {
+    phases: {
+        blocked: number;
+        dns: number;
+        connect: number;
+        ssl: number;
+        send: number;
+        wait: number;
+        receive: number;
+    };
+    total: number;
+};
+export {};

package/dist/har.js

@@ -0,0 +1,88 @@
+// HAR 1.2, the subset Chrome DevTools and har-analyzer tools read. Pending requests are left out:
+// a HAR entry needs a response.
+export function buildHar(entries, bodies, creatorVersion) {
+    const pages = [...new Map(entries.map((entry) => [entry.tabId, entry])).values()].map((first) => ({
+        startedDateTime: new Date(first.startedAtMs).toISOString(),
+        id: first.tabId,
+        title: first.tabId,
+        pageTimings: {},
+    }));
+    return {
+        log: {
+            version: "1.2",
+            creator: { name: "patchrome", version: creatorVersion },
+            pages,
+            entries: entries
+                .filter((entry) => entry.state !== "pending")
+                .map((entry) => {
+                const timings = harTimings(entry.timing);
+                const body = bodies.get(entry.id);
+                const url = new URL(entry.url);
+                return {
+                    pageref: entry.tabId,
+                    startedDateTime: new Date(entry.startedAtMs).toISOString(),
+                    time: timings.total ?? entry.durationMs ?? 0,
+                    request: {
+                        method: entry.method,
+                        url: entry.url,
+                        httpVersion: "",
+                        cookies: [],
+                        headers: toHeaders(entry.requestHeaders),
+                        queryString: [...url.searchParams].map(([name, value]) => ({ name, value })),
+                        ...(entry.postData === undefined
+                            ? {}
+                            : { postData: { mimeType: entry.requestHeaders["content-type"] ?? "", text: entry.postData } }),
+                        headersSize: -1,
+                        bodySize: entry.postData === undefined ? 0 : Buffer.byteLength(entry.postData),
+                    },
+                    response: {
+                        status: entry.status ?? 0,
+                        statusText: entry.failure ?? entry.statusText,
+                        httpVersion: "",
+                        cookies: [],
+                        headers: toHeaders(entry.responseHeaders),
+                        content: {
+                            size: body === undefined
+                                ? -1
+                                : body.encoding === "base64"
+                                    ? Buffer.from(body.text, "base64").byteLength
+                                    : Buffer.byteLength(body.text),
+                            mimeType: entry.responseHeaders["content-type"] ?? "",
+                            ...(body === undefined ? {} : { text: body.text }),
+                            ...(body?.encoding === undefined ? {} : { encoding: body.encoding }),
+                        },
+                        redirectURL: entry.responseHeaders.location ?? "",
+                        headersSize: -1,
+                        bodySize: -1,
+                    },
+                    cache: {},
+                    timings: timings.phases,
+                    _resourceType: entry.resourceType,
+                };
+            }),
+        },
+    };
+}
+function toHeaders(headers) {
+    return Object.entries(headers).map(([name, value]) => ({ name, value }));
+}
+// Playwright reports phase boundaries in ms relative to startTime, with -1 for phases that did not happen.
+export function harTimings(timing) {
+    const span = (start, end) => (start >= 0 && end >= start ? end - start : -1);
+    if (!timing)
+        return { phases: { blocked: -1, dns: -1, connect: -1, ssl: -1, send: 0, wait: 0, receive: 0 }, total: undefined };
+    const phases = {
+        blocked: -1,
+        dns: span(timing.domainLookupStart, timing.domainLookupEnd),
+        connect: span(timing.connectStart, timing.connectEnd),
+        ssl: span(timing.secureConnectionStart, timing.connectEnd),
+        send: 0,
+        wait: Math.max(0, span(timing.requestStart, timing.responseStart)),
+        receive: Math.max(0, span(timing.responseStart, timing.responseEnd)),
+    };
+    // HAR counts ssl inside connect, so it is not added twice.
+    const total = [phases.dns, phases.connect, phases.send, phases.wait, phases.receive]
+        .filter((ms) => ms > 0)
+        .reduce((sum, ms) => sum + ms, 0);
+    return { phases, total };
+}

package/dist/history.d.ts

@@ -0,0 +1,35 @@
+import { type CommandName } from "./protocol.ts";
+export declare const historyFormats: readonly ["sh", "jsonl"];
+export type HistoryFormat = (typeof historyFormats)[number];
+export declare function isHistoryFormat(value: string): value is HistoryFormat;
+export interface HistoryStep {
+    atMs: number;
+    argv: string[];
+    notes: string[];
+}
+export interface ReplayHint {
+    refLocator?: {
+        flags: string[];
+        notes: string[];
+    };
+    requestUrlGlob?: string;
+    isSecretText?: boolean;
+}
+export declare const secretPlaceholder = "<secret>";
+export declare const historyFileName = "history.jsonl";
+export declare function isReplayable(command: CommandName, args: Record<string, unknown>): boolean;
+export declare function stepArgv(argv: string[]): string[];
+export declare function replayStep(command: CommandName, argv: string[], hint: ReplayHint | undefined, atMs: number): HistoryStep;
+export declare function requestUrlGlob(url: string): string;
+export declare function locatorForRef(snapshot: string, ref: string): {
+    flags: string[];
+    notes: string[];
+} | undefined;
+export declare function appendHistoryStep(path: string, step: HistoryStep): Promise<void>;
+export declare function readHistory(path: string): Promise<HistoryStep[]>;
+export declare function clearHistory(path: string): Promise<void>;
+export declare function formatHistory(steps: HistoryStep[], format: HistoryFormat, { session, profile }: {
+    session: string;
+    profile: string;
+}): string;
+export declare function shellWord(word: string): string;

package/dist/history.js

@@ -0,0 +1,277 @@
+import { appendFile, mkdir, readFile, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+import { parseArgs } from "node:util";
+import { z } from "zod";
+import { cliOptions } from "./cli-options.js";
+import { CommandError } from "./protocol.js";
+// A session's history is the commands that worked, as a person would type them again. An agent explores a
+// site with refs, which die with the page; the daemon rewrites each ref into a locator taken from the
+// snapshot the ref came from, so the exported script finds the same element on the next run.
+export const historyFormats = ["sh", "jsonl"];
+export function isHistoryFormat(value) {
+    return historyFormats.includes(value);
+}
+export const secretPlaceholder = "<secret>";
+// Lives in the session folder, next to its snapshots.
+export const historyFileName = "history.jsonl";
+// Commands worth replaying. Reading the page layout (snapshot, tabs) and managing sessions or the daemon
+// is exploration, not part of the flow.
+export function isReplayable(command, args) {
+    switch (command) {
+        case "open":
+        case "goto":
+        case "switch":
+        case "close":
+        case "click":
+        case "fill":
+        case "type":
+        case "press":
+        case "wait":
+        case "text":
+        case "eval":
+        case "extract":
+        case "screenshot":
+        case "network-list":
+        case "network-get":
+        case "network-har-start":
+        case "network-har-stop":
+        case "route-block":
+        case "route-mock":
+        case "route-clear":
+        case "login":
+        case "cookies":
+        case "state-save":
+        case "state-load":
+        case "state-import":
+            return true;
+        case "challenge":
+            return args.handoff === true;
+        case "tabs":
+        case "snapshot":
+        case "watch":
+        case "route-list":
+        case "console":
+        case "errors":
+        case "trace-start":
+        case "trace-stop":
+        case "cdp":
+        case "cdp-help":
+        case "devtools-url":
+        case "session":
+        case "sessions":
+        case "session-close":
+        case "session-label":
+        case "daemon-status":
+        case "daemon-stop":
+            return false;
+    }
+}
+// Flags that belong to the caller, not to the step: the session and profile come from the replay's own
+// environment, and --json from how the replay reads output.
+const callerFlags = new Set(["json", "session", "profile"]);
+export function stepArgv(argv) {
+    const { tokens } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        strict: false,
+        tokens: true,
+        options: cliOptions,
+    });
+    const dropped = new Set();
+    for (const token of tokens) {
+        if (token.kind !== "option" || !callerFlags.has(token.name))
+            continue;
+        dropped.add(token.index);
+        if (token.value !== undefined && !token.inlineValue)
+            dropped.add(token.index + 1);
+    }
+    return argv.filter((_, index) => !dropped.has(index));
+}
+// Replaces the ref, request id and secret text in a step's words with what replays.
+export function replayStep(command, argv, hint, atMs) {
+    const words = stepArgv(argv);
+    const notes = [];
+    const { tokens } = parseArgs({
+        args: words,
+        allowPositionals: true,
+        strict: false,
+        tokens: true,
+        options: cliOptions,
+    });
+    const positionals = tokens.filter((token) => token.kind === "positional");
+    const valueOf = (name) => tokens.find((token) => token.kind === "option" && token.name === name);
+    const replacements = new Map();
+    if (hint?.refLocator !== undefined) {
+        const refOption = valueOf("ref");
+        const refPositional = positionals.find((token) => /^@?(?:f\d+)?e\d+$/.test(token.value));
+        if (refOption !== undefined && refOption.kind === "option" && refOption.value !== undefined) {
+            replacements.set(refOption.index, hint.refLocator.flags);
+            if (!refOption.inlineValue)
+                replacements.set(refOption.index + 1, []);
+        }
+        else if (refPositional !== undefined) {
+            replacements.set(refPositional.index, hint.refLocator.flags);
+        }
+        notes.push(...hint.refLocator.notes);
+    }
+    if (hint?.requestUrlGlob !== undefined) {
+        // `network get <id>`: the id is the positional after `get`.
+        const id = positionals.find((token) => /^n\d+$/.test(token.value));
+        if (id !== undefined)
+            replacements.set(id.index, ["--url", hint.requestUrlGlob]);
+    }
+    if (hint?.isSecretText === true) {
+        const text = positionals.at(-1);
+        if (text !== undefined)
+            replacements.set(text.index, [secretPlaceholder]);
+        notes.push(`the text went into a password field and was not recorded: the sh script reads $PATCHROME_SECRET, jsonl carries ${secretPlaceholder} to replace`);
+    }
+    switch (command) {
+        case "switch":
+        case "close":
+            if (positionals.some((token) => /^t\d+$/.test(token.value)))
+                notes.push("tab ids from the recording can differ on replay");
+            break;
+        case "login":
+            notes.push("waits for a person to sign in");
+            break;
+        case "challenge":
+            notes.push("waits for a person to solve a CAPTCHA");
+            break;
+        case "state-import":
+        case "state-load":
+            notes.push("waits for the person to approve a login copy");
+            break;
+        default:
+            break;
+    }
+    return { atMs, argv: words.flatMap((word, index) => replacements.get(index) ?? [word]), notes };
+}
+// Glob for a recorded request: its URL without the query, since ids, timestamps and cursors change per run.
+// `*` and `?` in the URL itself become `?`, the one-character wildcard, as the glob has no escape.
+export function requestUrlGlob(url) {
+    let base = url;
+    try {
+        const parsed = new URL(url);
+        base = `${parsed.origin}${parsed.pathname}`;
+    }
+    catch {
+        // A URL Chrome reported but Node cannot parse is used as is.
+    }
+    return `${base.replace(/[*?]/g, "?")}*`;
+}
+const snapshotLinePattern = /^\s*- ([a-z]+)(?: "((?:[^"\\]|\\.)*)")?/;
+// Finds the snapshot line that carries the ref and turns its role and name into locator flags. Refs inside
+// an iframe have no page-level locator, and nameless or repeated nodes need a position; both get a note.
+export function locatorForRef(snapshot, ref) {
+    const nodes = snapshot.split("\n").flatMap((line) => {
+        const refs = [...line.matchAll(/\[ref=((?:f\d+)?e\d+)\]/g)].map((match) => match[1] ?? "");
+        const match = line.match(snapshotLinePattern);
+        if (refs.length === 0 || !match?.[1])
+            return [];
+        return [
+            {
+                ref: refs[0] ?? "",
+                frame: frameOfRef(refs[0] ?? ""),
+                role: match[1],
+                name: match[2] === undefined ? undefined : unescapeName(match[2]),
+            },
+        ];
+    });
+    const node = nodes.find((candidate) => candidate.ref === ref);
+    if (node === undefined)
+        return undefined;
+    const sameFrame = nodes.filter((candidate) => candidate.frame === node.frame);
+    const notes = [];
+    const flags = ["--role", node.role];
+    // Without a name, getByRole matches every node of the role, named or not.
+    const peers = node.name === undefined
+        ? sameFrame.filter((candidate) => candidate.role === node.role)
+        : sameFrame.filter((candidate) => candidate.role === node.role && candidate.name === node.name);
+    if (node.name !== undefined)
+        flags.push("--name", node.name, "--exact");
+    if (peers.length > 1) {
+        const nth = peers.findIndex((candidate) => candidate.ref === ref);
+        flags.push("--nth", String(nth));
+        notes.push(`${peers.length} elements matched ${node.role}${node.name === undefined ? "" : ` "${node.name}"`}; --nth ${nth} is its position in the recorded page`);
+    }
+    else if (node.name === undefined) {
+        notes.push(`${node.role} has no accessible name; the locator matches the only ${node.role} on the recorded page`);
+    }
+    // The snapshot starts at the main frame's root, so its frame prefix, often f1 and sometimes none, marks the
+    // page itself; any other prefix is an iframe.
+    if (node.frame !== nodes[0]?.frame)
+        notes.push("the element is inside an iframe; add --frame <iframe-css>");
+    return { flags, notes };
+}
+function frameOfRef(ref) {
+    return ref.match(/^(f\d+)e\d+$/)?.[1] ?? "";
+}
+function unescapeName(raw) {
+    try {
+        return JSON.parse(`"${raw}"`);
+    }
+    catch {
+        return raw.replace(/\\(.)/g, "$1");
+    }
+}
+const stepSchema = z.object({ atMs: z.number(), argv: z.array(z.string()), notes: z.array(z.string()) });
+export async function appendHistoryStep(path, step) {
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, `${JSON.stringify(step)}\n`, { mode: 0o600 });
+}
+// A line that does not parse is skipped, so one torn write cannot hide the rest of the flow.
+export async function readHistory(path) {
+    const text = await readFile(path, "utf8").catch((err) => {
+        if (err.code === "ENOENT")
+            return "";
+        throw new CommandError("bad_args", `cannot read history ${path}: ${err.message}`);
+    });
+    return text.split("\n").flatMap((line) => {
+        if (line.trim() === "")
+            return [];
+        try {
+            const parsed = stepSchema.safeParse(JSON.parse(line));
+            return parsed.success ? [parsed.data] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export async function clearHistory(path) {
+    await rm(path, { force: true });
+}
+export function formatHistory(steps, format, { session, profile }) {
+    switch (format) {
+        case "jsonl":
+            return steps
+                .map((step) => JSON.stringify(step.notes.length === 0 ? { argv: step.argv } : { argv: step.argv, notes: step.notes }))
+                .join("\n");
+        case "sh": {
+            const first = steps[0];
+            const last = steps.at(-1);
+            const header = [
+                "#!/bin/sh",
+                first === undefined || last === undefined
+                    ? `# patchrome session ${session}: no steps recorded`
+                    : `# patchrome session ${session}: ${steps.length} steps, ${new Date(first.atMs).toISOString()} to ${new Date(last.atMs).toISOString()}`,
+                "# Lines starting with `# check:` need a look before this runs unattended.",
+                "set -eu",
+                `export PATCHROME_SESSION="\${PATCHROME_SESSION:-replay-$$}"`,
+                ...(profile === "stealth" ? [] : [`export PATCHROME_PROFILE="\${PATCHROME_PROFILE:-${profile}}"`]),
+                "",
+            ];
+            const body = steps.flatMap((step) => [
+                ...step.notes.map((note) => `# check: ${note}`),
+                ["patchrome", ...step.argv].map(shellWord).join(" "),
+            ]);
+            return [...header, ...body, "patchrome session close"].join("\n");
+        }
+    }
+}
+export function shellWord(word) {
+    if (word === secretPlaceholder)
+        return `"$PATCHROME_SECRET"`;
+    return /^[A-Za-z0-9@%+=:,./_-]+$/.test(word) ? word : `'${word.replace(/'/g, `'\\''`)}'`;
+}

package/dist/host-platform.d.ts

@@ -0,0 +1,5 @@
+export declare const hostPlatforms: readonly ["macos", "wsl", "linux", "unsupported"];
+export type HostPlatform = (typeof hostPlatforms)[number];
+export declare function detectHostPlatform(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv, procVersion?: typeof readProcVersion): HostPlatform;
+declare function readProcVersion(): string;
+export {};

package/dist/host-platform.js

@@ -0,0 +1,19 @@
+import { readFileSync } from "node:fs";
+// The desktop a person sits at decides how patchrome asks them anything. WSL runs Linux, but its person
+// sits at Windows, so prompts and notifications go through powershell.exe.
+export const hostPlatforms = ["macos", "wsl", "linux", "unsupported"];
+export function detectHostPlatform(platform = process.platform, env = process.env, procVersion = readProcVersion) {
+    if (platform === "darwin")
+        return "macos";
+    if (platform !== "linux")
+        return "unsupported";
+    return env.WSL_DISTRO_NAME !== undefined || /microsoft/i.test(procVersion()) ? "wsl" : "linux";
+}
+function readProcVersion() {
+    try {
+        return readFileSync("/proc/version", "utf8");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/host-prompts-macos.d.ts

@@ -0,0 +1,2 @@
+import { type HostPrompts } from "./copy-guard.ts";
+export declare function macosPrompts(bundlesDir: string, log: (message: string) => void): HostPrompts;

package/dist/host-prompts-macos.js

@@ -0,0 +1,102 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { copyFile, mkdir, mkdtemp, rename, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { helperFailure, parseApprovalAnswer } from "./copy-guard.js";
+const run = promisify(execFile);
+const systemOsascript = "/usr/bin/osascript";
+// JXA reaches LocalAuthentication through the ObjC bridge. Policy 2 is LAPolicyDeviceOwnerAuthentication: Touch ID,
+// or the account password on a Mac without it. A script cannot answer that dialog, where it could click an
+// ordinary `display dialog` through System Events. The bridge hands error codes over as strings, hence Number().
+const approvalScript = `
+ObjC.import("LocalAuthentication");
+ObjC.import("Foundation");
+function spin(untilDate, isDone) {
+  while (!isDone() && $.NSDate.date.compare(untilDate) < 0) {
+    $.NSRunLoop.currentRunLoop.runModeBeforeDate($.NSDefaultRunLoopMode, $.NSDate.dateWithTimeIntervalSinceNow(0.2));
+  }
+}
+function run(argv) {
+  const policy = 2;
+  const context = $.LAContext.alloc.init;
+  const error = Ref();
+  if (!context.canEvaluatePolicyError(policy, error)) return "unavailable " + (error[0] ? error[0].localizedDescription.js : "no Touch ID or password");
+  let answer;
+  context.evaluatePolicyLocalizedReasonReply(policy, argv[0], (isApproved, failure) => {
+    const code = isApproved ? 0 : Number(failure.code);
+    if (isApproved) answer = "approved";
+    else if (code === -9) answer = "timed_out";
+    else if (code === -1 || code === -2 || code === -4) answer = "denied";
+    else answer = "unavailable " + failure.localizedDescription.js;
+  });
+  spin($.NSDate.dateWithTimeIntervalSinceNow(Number(argv[1])), () => answer !== undefined);
+  if (answer === undefined) {
+    context.invalidate;
+    spin($.NSDate.dateWithTimeIntervalSinceNow(2), () => answer !== undefined);
+  }
+  return answer === undefined ? "timed_out" : answer;
+}`;
+const notifyScript = `on run argv
+  display notification (item 2 of argv) with title (item 1 of argv)
+end run`;
+const infoPlist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>CFBundleExecutable</key><string>patchrome</string>
+<key>CFBundleIdentifier</key><string>io.patchrome.copy-approval</string>
+<key>CFBundleName</key><string>patchrome</string>
+<key>CFBundlePackageType</key><string>APPL</string>
+</dict></plist>
+`;
+// macOS names the asking app in the dialog, so plain osascript reads "osascript is trying to ...". A copy of
+// osascript inside a patchrome.app bundle reads "patchrome is trying to ...". An osacompile applet would
+// be simpler, but its runtime aborts when LocalAuthentication replies on a background thread. The folder name
+// hashes the plist and the system osascript's size and mtime, so an OS update builds a fresh bundle.
+async function renamedOsascript(bundlesDir) {
+    const system = await stat(systemOsascript);
+    const hash = createHash("sha256").update(`${infoPlist}${system.size}:${system.mtimeMs}`).digest("hex").slice(0, 12);
+    const executable = join(bundlesDir, hash, "patchrome.app", "Contents", "MacOS", "patchrome");
+    if (await stat(executable).then(() => true, () => false))
+        return executable;
+    await mkdir(bundlesDir, { recursive: true });
+    const building = await mkdtemp(join(bundlesDir, "building-"));
+    try {
+        const app = join(building, "patchrome.app");
+        await mkdir(join(app, "Contents", "MacOS"), { recursive: true });
+        await writeFile(join(app, "Contents", "Info.plist"), infoPlist);
+        await copyFile(systemOsascript, join(app, "Contents", "MacOS", "patchrome"));
+        // The copy loses Apple's signature for the bundle; an ad-hoc signature lets it run as patchrome.app.
+        await run("codesign", ["--force", "--sign", "-", app], { timeout: 30_000 });
+        // Two daemons may build at once; the first rename wins and the other bundle is dropped.
+        await rename(building, join(bundlesDir, hash)).catch((err) => {
+            if (!["EEXIST", "ENOTEMPTY"].includes(err.code ?? ""))
+                throw err;
+        });
+    }
+    finally {
+        await rm(building, { recursive: true, force: true });
+    }
+    return executable;
+}
+export function macosPrompts(bundlesDir, log) {
+    return {
+        async askApproval(reason, timeoutMs) {
+            // A failed build still asks, under the name osascript, rather than refusing every copy.
+            const osascript = await renamedOsascript(bundlesDir).catch((err) => {
+                log(`building patchrome.app failed, asking through osascript: ${String(err).split("\n")[0]}`);
+                return systemOsascript;
+            });
+            try {
+                const { stdout } = await run(osascript, ["-l", "JavaScript", "-e", approvalScript, reason, String(Math.ceil(timeoutMs / 1000))], { timeout: timeoutMs + 10_000 });
+                return parseApprovalAnswer(stdout);
+            }
+            catch (err) {
+                return { answer: "unavailable", detail: helperFailure("osascript", err) };
+            }
+        },
+        async notify(title, body) {
+            await run(systemOsascript, ["-e", notifyScript, title, body], { timeout: 10_000 });
+        },
+    };
+}

package/dist/host-prompts-wsl.d.ts

@@ -0,0 +1,6 @@
+import { type HostPrompts } from "./copy-guard.ts";
+export declare function encodedPowerShell(script: string): string;
+export declare function powerShellString(text: string): string;
+export declare function approvalScript(reason: string, timeoutMs: number): string;
+export declare function notifyScript(title: string, body: string): string;
+export declare const wslPrompts: HostPrompts;