patchrome 0.1.0

package/dist/host-prompts-wsl.js

@@ -0,0 +1,64 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { helperFailure, parseApprovalAnswer } from "./copy-guard.js";
+const run = promisify(execFile);
+// WSL interop runs Windows' powershell.exe from Linux. Scripts go in -EncodedCommand, and every string from
+// patchrome goes in as base64, so a session name or file path can never become PowerShell code.
+export function encodedPowerShell(script) {
+    return Buffer.from(script, "utf16le").toString("base64");
+}
+export function powerShellString(text) {
+    return `([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${Buffer.from(text, "utf8").toString("base64")}')))`;
+}
+// Windows Hello is the prompt a script cannot answer. Without Hello set up there is no such prompt, and the
+// copy is refused rather than falling back to a clickable message box.
+export function approvalScript(reason, timeoutMs) {
+    return `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Runtime.WindowsRuntime
+$asTask = [System.WindowsRuntimeSystemExtensions].GetMethods() | Where-Object { $_.Name -eq 'AsTask' -and $_.GetParameters().Count -eq 1 -and $_.GetParameters()[0].ParameterType.Name -eq 'IAsyncOperation\`1' } | Select-Object -First 1
+function Wait-WinRt($operation, [Type]$resultType, [int]$timeoutMs) {
+  $task = $asTask.MakeGenericMethod($resultType).Invoke($null, @($operation))
+  if (-not $task.Wait($timeoutMs)) { return $null }
+  return $task.Result
+}
+$verifier = [Windows.Security.Credentials.UI.UserConsentVerifier, Windows.Security.Credentials.UI, ContentType = WindowsRuntime]
+$availability = Wait-WinRt ($verifier::CheckAvailabilityAsync()) ([Windows.Security.Credentials.UI.UserConsentVerifierAvailability]) 10000
+if ("$availability" -ne 'Available') { "unavailable Windows Hello is $availability"; return }
+$result = Wait-WinRt ($verifier::RequestVerificationAsync(${powerShellString(reason)})) ([Windows.Security.Credentials.UI.UserConsentVerificationResult]) ${timeoutMs}
+if ($null -eq $result) { 'timed_out' }
+elseif ("$result" -eq 'Verified') { 'approved' }
+elseif ("$result" -eq 'Canceled' -or "$result" -eq 'RetriesExhausted') { 'denied' }
+else { "unavailable Windows Hello answered $result" }
+`;
+}
+export function notifyScript(title, body) {
+    return `
+$ErrorActionPreference = 'Stop'
+$manager = [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime]
+$null = [Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime]
+$toast = $manager::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
+$texts = $toast.GetElementsByTagName('text')
+$null = $texts.Item(0).AppendChild($toast.CreateTextNode(${powerShellString(title)}))
+$null = $texts.Item(1).AppendChild($toast.CreateTextNode(${powerShellString(body)}))
+# Toasts need a registered app id; Windows PowerShell's own is present on every Windows install.
+$manager::CreateToastNotifier('{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe').Show([Windows.UI.Notifications.ToastNotification]::new($toast))
+`;
+}
+function powerShell(script, timeoutMs) {
+    return run("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encodedPowerShell(script)], { timeout: timeoutMs });
+}
+export const wslPrompts = {
+    async askApproval(reason, timeoutMs) {
+        try {
+            const { stdout } = await powerShell(approvalScript(reason, timeoutMs), timeoutMs + 20_000);
+            return parseApprovalAnswer(stdout);
+        }
+        catch (err) {
+            return { answer: "unavailable", detail: helperFailure("powershell.exe", err) };
+        }
+    },
+    async notify(title, body) {
+        await powerShell(notifyScript(title, body), 20_000);
+    },
+};

package/dist/host-prompts.d.ts

@@ -0,0 +1,3 @@
+import type { HostPrompts } from "./copy-guard.ts";
+import type { HostPlatform } from "./host-platform.ts";
+export declare function hostPromptsFor(platform: HostPlatform, log: (message: string) => void, macosBundlesDir: string): HostPrompts;

package/dist/host-prompts.js

@@ -0,0 +1,25 @@
+import { macosPrompts } from "./host-prompts-macos.js";
+import { wslPrompts } from "./host-prompts-wsl.js";
+// A desktop Linux has no prompt a script cannot click, so copies there are refused and only logged.
+const noPrompts = (platform, log) => ({
+    async askApproval() {
+        return {
+            answer: "unavailable",
+            detail: `no approval prompt on ${platform}; patchrome asks through Touch ID on macOS and Windows Hello on WSL`,
+        };
+    },
+    async notify(title, body) {
+        log(`${title}: ${body}`);
+    },
+});
+export function hostPromptsFor(platform, log, macosBundlesDir) {
+    switch (platform) {
+        case "macos":
+            return macosPrompts(macosBundlesDir, log);
+        case "wsl":
+            return wslPrompts;
+        case "linux":
+        case "unsupported":
+            return noPrompts(platform, log);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { CommandError, errorCodes, type ErrorCode } from "./protocol.ts";
+export { CommandError, errorCodes, type ErrorCode };
+export interface ConnectOptions {
+    session?: string;
+    profile?: string;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+export type CommandFields = Record<string, unknown>;
+export declare class Patchrome {
+    #private;
+    constructor(options?: ConnectOptions);
+    run(...words: string[]): Promise<CommandFields>;
+    stream(words: string[], onEvent: (fields: CommandFields) => void): Promise<CommandFields>;
+    close(): void;
+}
+export declare function connect(options?: ConnectOptions): Patchrome;

package/dist/index.js

@@ -0,0 +1,47 @@
+import { CommandError, errorCodes } from "./protocol.js";
+import { CommandRunner } from "./runner.js";
+import { lookupProcess, resolveSessionName } from "./session-name.js";
+export { CommandError, errorCodes };
+// The patchrome CLI as a Node library. Each call takes the words you would type after `patchrome` and
+// returns what `--json` puts under `data`; a failed command throws a CommandError with its code.
+//
+//   const browser = connect({ session: "prices" });
+//   await browser.run("open", "https://shop.example");
+//   const { rows } = await browser.run("extract", schema, "--inline");
+export class Patchrome {
+    #runner;
+    #timeoutMs;
+    constructor(options = {}) {
+        const env = {
+            ...(options.env ?? process.env),
+            ...(options.profile === undefined ? {} : { PATCHROME_PROFILE: options.profile }),
+        };
+        let session = options.session;
+        this.#runner = new CommandRunner(env, () => {
+            session ??= resolveSessionName(env, process.ppid, lookupProcess);
+            return session;
+        });
+        this.#timeoutMs = options.timeoutMs;
+    }
+    async run(...words) {
+        return this.stream(words, () => { });
+    }
+    // For `watch` and `console --follow`: onEvent gets each event's fields, and the promise resolves when the
+    // stream stops.
+    async stream(words, onEvent) {
+        const argv = this.#timeoutMs === undefined || words.includes("--timeout-ms")
+            ? words
+            : ["--timeout-ms", String(this.#timeoutMs), ...words];
+        const result = await this.#runner.run(argv, { onStream: (stream) => onEvent(stream.fields) });
+        if (!result.ok)
+            throw new CommandError(result.error.code, result.error.message, result.error.hint);
+        return result.data;
+    }
+    // Idle connections never keep the process alive, so close is only needed to drop them early.
+    close() {
+        this.#runner.close();
+    }
+}
+export function connect(options = {}) {
+    return new Patchrome(options);
+}

package/dist/network.d.ts

@@ -0,0 +1,54 @@
+import type { Tab } from "./sessions.ts";
+export declare const resourceTypes: readonly ["document", "stylesheet", "image", "media", "font", "script", "texttrack", "xhr", "fetch", "eventsource", "websocket", "manifest", "other"];
+export type ResourceType = (typeof resourceTypes)[number];
+export interface RequestTiming {
+    startTime: number;
+    domainLookupStart: number;
+    domainLookupEnd: number;
+    connectStart: number;
+    secureConnectionStart: number;
+    connectEnd: number;
+    requestStart: number;
+    responseStart: number;
+    responseEnd: number;
+}
+export interface NetworkEntry {
+    id: string;
+    tabId: string;
+    session: string;
+    method: string;
+    url: string;
+    resourceType: string;
+    startedAtMs: number;
+    requestHeaders: Record<string, string>;
+    postData: string | undefined;
+    state: "pending" | "finished" | "failed";
+    status: number | undefined;
+    statusText: string;
+    responseHeaders: Record<string, string>;
+    durationMs: number | undefined;
+    timing: RequestTiming | undefined;
+    failure: string | undefined;
+}
+export interface NetworkFilter {
+    urlGlob: string | undefined;
+    types: string | undefined;
+    status: string | undefined;
+}
+export declare class NetworkLog {
+    #private;
+    constructor(onSettled?: (entry: NetworkEntry) => void);
+    record(tab: Tab): void;
+    list(session: string, filter: NetworkFilter): NetworkEntry[];
+    droppedCount(session: string): number;
+    entry(session: string, id: string): NetworkEntry;
+    body(entry: NetworkEntry): Promise<Buffer>;
+    startHar(session: string): void;
+    stopHar(session: string): {
+        entries: NetworkEntry[];
+        droppedCount: number;
+    };
+    forget(session: string): void;
+}
+export declare function isTextual(headers: Record<string, string>): boolean;
+export declare function bodyExtension(headers: Record<string, string>): string;

package/dist/network.js

@@ -0,0 +1,204 @@
+import { parseStatusFilter, urlGlobMatches } from "./glob.js";
+import { CommandError } from "./protocol.js";
+export const resourceTypes = [
+    "document",
+    "stylesheet",
+    "image",
+    "media",
+    "font",
+    "script",
+    "texttrack",
+    "xhr",
+    "fetch",
+    "eventsource",
+    "websocket",
+    "manifest",
+    "other",
+];
+// Enough for an agent to find the API call behind a page without holding a busy session's whole history.
+const bufferLimitPerSession = 1000;
+const harLimitPerSession = 10_000;
+const postDataLimitBytes = 64 * 1024;
+export class NetworkLog {
+    #sessions = new Map();
+    #responses = new Map();
+    #nextId = 1;
+    #onSettled;
+    // onSettled fires once per request, when it finishes or fails.
+    constructor(onSettled = () => { }) {
+        this.#onSettled = onSettled;
+    }
+    record(tab) {
+        const pending = new WeakMap();
+        const page = tab.page;
+        page.on("request", (request) => {
+            const postData = request.postData() ?? undefined;
+            const entry = {
+                id: `n${this.#nextId++}`,
+                tabId: tab.id,
+                session: tab.session,
+                method: request.method(),
+                url: request.url(),
+                resourceType: request.resourceType(),
+                startedAtMs: Date.now(),
+                requestHeaders: request.headers(),
+                postData: postData !== undefined && Buffer.byteLength(postData) > postDataLimitBytes ? undefined : postData,
+                state: "pending",
+                status: undefined,
+                statusText: "",
+                responseHeaders: {},
+                durationMs: undefined,
+                timing: undefined,
+                failure: undefined,
+            };
+            pending.set(request, entry);
+            this.#append(tab.session, entry);
+        });
+        page.on("response", (response) => {
+            const entry = pending.get(response.request());
+            if (!entry)
+                return;
+            entry.status = response.status();
+            entry.statusText = response.statusText();
+            entry.responseHeaders = response.headers();
+            this.#responses.set(entry.id, response);
+        });
+        page.on("requestfinished", (request) => {
+            const entry = pending.get(request);
+            if (!entry)
+                return;
+            entry.state = "finished";
+            entry.durationMs = Date.now() - entry.startedAtMs;
+            entry.timing = request.timing();
+            this.#onSettled(entry);
+        });
+        page.on("requestfailed", (request) => {
+            const entry = pending.get(request);
+            if (!entry)
+                return;
+            entry.state = "failed";
+            entry.durationMs = Date.now() - entry.startedAtMs;
+            entry.failure = request.failure()?.errorText ?? "failed";
+            this.#onSettled(entry);
+        });
+    }
+    list(session, filter) {
+        const matchesStatus = filter.status === undefined ? () => true : parseStatusFilter(filter.status);
+        const types = filter.types === undefined ? undefined : parseTypes(filter.types);
+        return (this.#sessions.get(session)?.entries ?? []).filter((entry) => (filter.urlGlob === undefined || urlGlobMatches(filter.urlGlob, entry.url)) &&
+            (types === undefined || types.has(entry.resourceType)) &&
+            matchesStatus(entry.status));
+    }
+    droppedCount(session) {
+        return this.#sessions.get(session)?.droppedCount ?? 0;
+    }
+    entry(session, id) {
+        const found = this.#sessions.get(session)?.entries.find((entry) => entry.id === id) ??
+            this.#sessions.get(session)?.har?.find((entry) => entry.id === id);
+        if (!found) {
+            throw new CommandError("bad_args", `no request ${id} in this session`, "run `patchrome network list`; old requests leave the buffer after 1000");
+        }
+        return found;
+    }
+    // Chrome keeps a body only while the page that loaded it is alive, so bodies are read on demand.
+    async body(entry) {
+        const response = this.#responses.get(entry.id);
+        if (!response)
+            throw new CommandError("bad_args", `request ${entry.id} has no response`, entry.failure === undefined ? "the request is still pending" : `it failed: ${entry.failure}`);
+        try {
+            return await response.body();
+        }
+        catch (err) {
+            const message = err instanceof Error ? (err.message.split("\n")[0] ?? err.message) : String(err);
+            throw new CommandError("tab_gone", `body of ${entry.id} is no longer available: ${message}`, "Chrome drops bodies when the tab closes or navigates away; reload and fetch it sooner");
+        }
+    }
+    startHar(session) {
+        const network = this.#sessionFor(session);
+        if (network.har)
+            throw new CommandError("bad_args", "a HAR recording is already running for this session", "run `patchrome network har stop` first");
+        network.har = [];
+        network.harDroppedCount = 0;
+    }
+    stopHar(session) {
+        const network = this.#sessions.get(session);
+        if (!network?.har)
+            throw new CommandError("bad_args", "no HAR recording is running for this session", "run `patchrome network har start`");
+        const result = { entries: network.har, droppedCount: network.harDroppedCount };
+        network.har = undefined;
+        this.#releaseResponses(result.entries.filter((entry) => !network.entries.includes(entry)));
+        return result;
+    }
+    forget(session) {
+        const network = this.#sessions.get(session);
+        if (!network)
+            return;
+        this.#releaseResponses([...network.entries, ...(network.har ?? [])]);
+        this.#sessions.delete(session);
+    }
+    #append(session, entry) {
+        const network = this.#sessionFor(session);
+        network.entries.push(entry);
+        if (network.entries.length > bufferLimitPerSession) {
+            const evicted = network.entries.shift();
+            network.droppedCount++;
+            if (evicted && !network.har?.includes(evicted))
+                this.#releaseResponses([evicted]);
+        }
+        if (network.har) {
+            if (network.har.length < harLimitPerSession)
+                network.har.push(entry);
+            else
+                network.harDroppedCount++;
+        }
+    }
+    #releaseResponses(entries) {
+        for (const entry of entries)
+            this.#responses.delete(entry.id);
+    }
+    #sessionFor(session) {
+        let network = this.#sessions.get(session);
+        if (!network) {
+            network = { entries: [], droppedCount: 0, har: undefined, harDroppedCount: 0 };
+            this.#sessions.set(session, network);
+        }
+        return network;
+    }
+}
+function parseTypes(raw) {
+    const types = raw.split(",").map((part) => part.trim());
+    for (const type of types) {
+        if (!resourceTypes.includes(type)) {
+            throw new CommandError("bad_args", `--type ${type} is not a resource type`, `use any of ${resourceTypes.join(", ")}`);
+        }
+    }
+    return new Set(types);
+}
+export function isTextual(headers) {
+    const contentType = headers["content-type"] ?? "";
+    return /^text\/|json|javascript|xml|html|svg|x-www-form-urlencoded|graphql/i.test(contentType);
+}
+export function bodyExtension(headers) {
+    const contentType = headers["content-type"] ?? "";
+    if (/json/i.test(contentType))
+        return "json";
+    if (/html/i.test(contentType))
+        return "html";
+    if (/javascript/i.test(contentType))
+        return "js";
+    if (/css/i.test(contentType))
+        return "css";
+    if (/svg/i.test(contentType))
+        return "svg";
+    if (/xml/i.test(contentType))
+        return "xml";
+    if (/png/i.test(contentType))
+        return "png";
+    if (/jpe?g/i.test(contentType))
+        return "jpg";
+    if (/webp/i.test(contentType))
+        return "webp";
+    if (/^text\//i.test(contentType))
+        return "txt";
+    return "bin";
+}

package/dist/origin-storage.d.ts

@@ -0,0 +1,31 @@
+export interface IndexedDbIndex {
+    name: string;
+    keyPath: string | string[];
+    unique: boolean;
+    multiEntry: boolean;
+}
+export interface IndexedDbStore {
+    name: string;
+    keyPath: string | string[] | null;
+    autoIncrement: boolean;
+    indexes: IndexedDbIndex[];
+    records: Array<{
+        key: unknown;
+        value: unknown;
+    }>;
+}
+export interface IndexedDbDatabase {
+    name: string;
+    version: number;
+    stores: IndexedDbStore[];
+}
+export interface OriginStorage {
+    origin: string;
+    localStorage: Array<{
+        name: string;
+        value: string;
+    }>;
+    indexedDB: IndexedDbDatabase[];
+}
+export declare function readOriginStorageInPage(): Promise<Omit<OriginStorage, "origin">>;
+export declare function writeOriginStorageInPage(storage: Omit<OriginStorage, "origin">): Promise<void>;

package/dist/origin-storage.js

@@ -0,0 +1,82 @@
+// localStorage and IndexedDB for one origin, in a shape Playwright's evaluate carries both ways. Dates,
+// typed arrays, ArrayBuffers and BigInts survive the trip; Blobs, Maps and Sets do not.
+// Runs in the page, so it may only use what the page has.
+export async function readOriginStorageInPage() {
+    const settle = (request) => new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+    const databases = [];
+    for (const info of await indexedDB.databases()) {
+        if (info.name === undefined)
+            continue;
+        const db = await settle(indexedDB.open(info.name));
+        try {
+            const stores = [];
+            for (const storeName of db.objectStoreNames) {
+                const store = db.transaction(storeName, "readonly").objectStore(storeName);
+                const [keys, values] = await Promise.all([settle(store.getAllKeys()), settle(store.getAll())]);
+                stores.push({
+                    name: storeName,
+                    keyPath: store.keyPath,
+                    autoIncrement: store.autoIncrement,
+                    indexes: [...store.indexNames].map((indexName) => {
+                        const index = store.index(indexName);
+                        return { name: indexName, keyPath: index.keyPath, unique: index.unique, multiEntry: index.multiEntry };
+                    }),
+                    records: keys.map((key, position) => ({ key, value: values[position] })),
+                });
+            }
+            databases.push({ name: info.name, version: db.version, stores });
+        }
+        finally {
+            db.close();
+        }
+    }
+    return { localStorage: Object.entries(localStorage).map(([name, value]) => ({ name, value })), indexedDB: databases };
+}
+// localStorage items are added next to what the origin has. Each IndexedDB database is replaced whole:
+// merging records into a schema of another version would leave the site's data half upgraded.
+export async function writeOriginStorageInPage(storage) {
+    const settle = (request) => new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+    for (const { name, value } of storage.localStorage)
+        localStorage.setItem(name, value);
+    for (const database of storage.indexedDB) {
+        await settle(indexedDB.deleteDatabase(database.name));
+        const opening = indexedDB.open(database.name, database.version);
+        opening.onupgradeneeded = () => {
+            for (const store of database.stores) {
+                const created = opening.result.createObjectStore(store.name, {
+                    keyPath: store.keyPath,
+                    autoIncrement: store.autoIncrement,
+                });
+                for (const index of store.indexes)
+                    created.createIndex(index.name, index.keyPath, { unique: index.unique, multiEntry: index.multiEntry });
+            }
+        };
+        const db = await settle(opening);
+        try {
+            for (const store of database.stores) {
+                const transaction = db.transaction(store.name, "readwrite");
+                const objectStore = transaction.objectStore(store.name);
+                for (const { key, value } of store.records) {
+                    if (store.keyPath === null)
+                        objectStore.put(value, key);
+                    else
+                        objectStore.put(value);
+                }
+                await new Promise((resolve, reject) => {
+                    transaction.oncomplete = () => resolve();
+                    transaction.onerror = () => reject(transaction.error);
+                    transaction.onabort = () => reject(transaction.error);
+                });
+            }
+        }
+        finally {
+            db.close();
+        }
+    }
+}

package/dist/paths.d.ts

@@ -0,0 +1,17 @@
+export declare function isValidName(name: string): boolean;
+export declare function cacheRoot(env?: NodeJS.ProcessEnv): string;
+export declare function auditLogPathFrom(env?: NodeJS.ProcessEnv): string;
+export declare function approvalBundlesDirFrom(env?: NodeJS.ProcessEnv): string;
+export interface ProfilePaths {
+    profileDir: string;
+    profileConfigPath: string;
+    chromeProfileDir: string;
+    socketPath: string;
+    lockDir: string;
+    logPath: string;
+    sessionsDir: string;
+    savedSessionsPath: string;
+}
+export declare function profilePaths(profile: string, env?: NodeJS.ProcessEnv): ProfilePaths;
+export declare function sessionFolderName(session: string): string;
+export declare function idleMsFrom(env: NodeJS.ProcessEnv): number;

package/dist/paths.js

@@ -0,0 +1,52 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CommandError } from "./protocol.js";
+const namePattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+// macOS caps a unix socket path at 104 bytes including the terminating NUL.
+const maxSocketPathBytes = 103;
+const defaultIdleMs = 30 * 60 * 1000;
+export function isValidName(name) {
+    return namePattern.test(name);
+}
+export function cacheRoot(env = process.env) {
+    return env.PATCHROME_HOME ?? join(homedir(), ".cache", "patchrome");
+}
+// One log for every profile, so a copy from one profile into another shows up in one place.
+export function auditLogPathFrom(env = process.env) {
+    return join(cacheRoot(env), "copy-audit.jsonl");
+}
+// macOS names the app asking for Touch ID, so the approval prompt runs from a patchrome.app built here.
+export function approvalBundlesDirFrom(env = process.env) {
+    return join(cacheRoot(env), "approval-app");
+}
+export function profilePaths(profile, env = process.env) {
+    const profileDir = join(cacheRoot(env), profile);
+    const socketPath = join(profileDir, "daemon.sock");
+    if (Buffer.byteLength(socketPath) > maxSocketPathBytes) {
+        throw new CommandError("bad_args", `socket path ${socketPath} is over ${maxSocketPathBytes} bytes`, "use a shorter --profile name or PATCHROME_HOME");
+    }
+    return {
+        profileDir,
+        profileConfigPath: join(profileDir, "profile.json"),
+        chromeProfileDir: join(profileDir, "chrome-profile"),
+        socketPath,
+        lockDir: join(profileDir, "daemon.lock"),
+        logPath: join(profileDir, "daemon.log"),
+        sessionsDir: join(profileDir, "sessions"),
+        savedSessionsPath: join(profileDir, "sessions.json"),
+    };
+}
+// Session names come from agent ids and ttys. Escaping is reversible, so `a/b` and `a_b` get different folders.
+export function sessionFolderName(session) {
+    return session.replace(/[^A-Za-z0-9.-]/g, (char) => `_${char.codePointAt(0)?.toString(16)}_`);
+}
+export function idleMsFrom(env) {
+    const raw = env.PATCHROME_IDLE_MS;
+    if (raw === undefined)
+        return defaultIdleMs;
+    const idleMs = Number(raw);
+    if (!Number.isInteger(idleMs) || idleMs <= 0) {
+        throw new CommandError("bad_args", `PATCHROME_IDLE_MS must be a positive integer, got ${raw}`);
+    }
+    return idleMs;
+}

package/dist/pipe.d.ts

@@ -0,0 +1,9 @@
+import type { Readable, Writable } from "node:stream";
+import type { CommandRunner } from "./runner.ts";
+export interface PipeOptions {
+    input: Readable;
+    output: Writable;
+    runner: CommandRunner;
+    isBail: boolean;
+}
+export declare function runPipe({ input, output, runner, isBail }: PipeOptions): Promise<number>;