patchrome 0.1.0

package/dist/pipe.js

@@ -0,0 +1,73 @@
+import { createInterface } from "node:readline";
+import { z } from "zod";
+import { CommandError } from "./protocol.js";
+import { parseJsonInput } from "./validate.js";
+// `patchrome pipe` reads one request per line and writes one JSON response per line, for any language that
+// can start a process. A request is the command's words as a JSON array, or {"id", "argv"} to pick the id
+// the response carries; without an id it is the line number. Words of one session run in order, different
+// sessions at once, and streamed events arrive as {"id", "stream"} lines before their response.
+const requestSchema = z.union([
+    z.array(z.string()).min(1),
+    z.strictObject({
+        id: z.union([z.string(), z.number()]).optional(),
+        argv: z.array(z.string()).min(1),
+        // `session history --format jsonl` writes notes next to a step; they are for people and do not run.
+        notes: z.array(z.string()).optional(),
+    }),
+]);
+const requestHint = `send ["open", "https://example.com"] or {"id": 1, "argv": ["text", "--inline"]}`;
+export async function runPipe({ input, output, runner, isBail }) {
+    const queues = new Map();
+    const inFlight = new Set();
+    let hasFailed = false;
+    let lineNumber = 0;
+    const write = (message) => output.write(`${JSON.stringify(message)}\n`);
+    const lines = createInterface({ input, crlfDelay: Infinity });
+    for await (const line of lines) {
+        lineNumber++;
+        if (isBail && hasFailed)
+            break;
+        if (line.trim() === "")
+            continue;
+        let id = lineNumber;
+        let argv;
+        try {
+            const request = parseJsonInput(requestSchema, line, `line ${lineNumber}`, requestHint);
+            if (Array.isArray(request)) {
+                argv = request;
+            }
+            else {
+                argv = request.argv;
+                id = request.id ?? lineNumber;
+            }
+        }
+        catch (err) {
+            hasFailed = true;
+            write({
+                id,
+                ok: false,
+                error: (err instanceof CommandError ? err : new CommandError("bad_args", String(err))).toBody(),
+            });
+            continue;
+        }
+        const key = runner.queueKey(argv);
+        const isStreaming = runner.isStreaming(argv);
+        const previous = queues.get(key) ?? Promise.resolve();
+        const running = previous.then(async () => {
+            if (isBail && hasFailed)
+                return;
+            const result = await runner.run(argv, { onStream: (stream) => write({ id, stream: stream.fields }) });
+            if (!result.ok)
+                hasFailed = true;
+            write({ id, ...result });
+        });
+        // A stream holds its place only until it starts, so a `watch` does not block the session behind it.
+        const settled = isStreaming ? previous : running;
+        queues.set(key, settled);
+        inFlight.add(running);
+        void running.finally(() => inFlight.delete(running));
+    }
+    await Promise.all(inFlight);
+    runner.close();
+    return hasFailed ? 1 : 0;
+}

package/dist/profile-mode.d.ts

@@ -0,0 +1,10 @@
+import type { ProfilePaths } from "./paths.ts";
+export declare const profileModes: readonly ["stealth", "debug"];
+export type ProfileMode = (typeof profileModes)[number];
+export declare function isProfileMode(value: string): value is ProfileMode;
+export declare function defaultModeFor(profile: string): ProfileMode;
+export declare function readProfileMode(paths: ProfilePaths): Promise<ProfileMode | undefined>;
+export declare function fixProfileMode(paths: ProfilePaths, profile: string, requested: ProfileMode | undefined): Promise<{
+    mode: ProfileMode;
+    isNew: boolean;
+}>;

package/dist/profile-mode.js

@@ -0,0 +1,42 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { z } from "zod";
+import { CommandError } from "./protocol.js";
+import { parseJsonInput } from "./validate.js";
+export const profileModes = ["stealth", "debug"];
+export function isProfileMode(value) {
+    return profileModes.includes(value);
+}
+// A profile nobody created explicitly takes its mode from its name, so `--profile debug` just works.
+export function defaultModeFor(profile) {
+    return profile === "debug" ? "debug" : "stealth";
+}
+export async function readProfileMode(paths) {
+    let raw;
+    try {
+        raw = await readFile(paths.profileConfigPath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+    const { mode } = parseConfig(raw, paths.profileConfigPath);
+    return mode;
+}
+function parseConfig(raw, path) {
+    return parseJsonInput(z.object({ mode: z.enum(profileModes) }), raw, path, `mode must be one of ${profileModes.join(", ")}`);
+}
+// Mode is fixed once written: a stealth profile's cookies must never end up behind an open debugging port.
+export async function fixProfileMode(paths, profile, requested) {
+    const existing = await readProfileMode(paths);
+    if (existing !== undefined) {
+        if (requested !== undefined && requested !== existing) {
+            throw new CommandError("bad_args", `profile ${profile} is already a ${existing} profile`, `a profile's mode is fixed; create another profile for ${requested}`);
+        }
+        return { mode: existing, isNew: false };
+    }
+    const mode = requested ?? defaultModeFor(profile);
+    await mkdir(paths.profileDir, { recursive: true });
+    await writeFile(paths.profileConfigPath, `${JSON.stringify({ mode }, null, 2)}\n`);
+    return { mode, isNew: true };
+}

package/dist/protocol-help.d.ts

@@ -0,0 +1,34 @@
+interface ProtocolProperty {
+    name: string;
+    type?: string;
+    $ref?: string;
+    items?: {
+        type?: string;
+        $ref?: string;
+    };
+    optional?: boolean;
+    description?: string;
+    enum?: string[];
+}
+interface ProtocolMember {
+    name: string;
+    description?: string;
+    experimental?: boolean;
+    deprecated?: boolean;
+    parameters?: ProtocolProperty[];
+    returns?: ProtocolProperty[];
+}
+interface ProtocolDomain {
+    domain: string;
+    description?: string;
+    experimental?: boolean;
+    deprecated?: boolean;
+    commands?: ProtocolMember[];
+    events?: ProtocolMember[];
+}
+export interface ProtocolSchema {
+    domains: ProtocolDomain[];
+}
+export declare function parseProtocolSchema(raw: string): ProtocolSchema;
+export declare function protocolHelp(schema: ProtocolSchema, topic: string | undefined): string[];
+export {};

package/dist/protocol-help.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { CommandError } from "./protocol.js";
+import { parseJsonInput } from "./validate.js";
+export function parseProtocolSchema(raw) {
+    // Only the list is checked: the members' shape is Chrome's, and help prints whatever fields it finds.
+    const { domains } = parseJsonInput(z.object({ domains: z.array(z.looseObject({ domain: z.string() })) }), raw, "the browser's /json/protocol");
+    return { domains };
+}
+// No topic lists domains, `Page` lists its commands and events, `Page.navigate` describes one of them.
+export function protocolHelp(schema, topic) {
+    if (topic === undefined) {
+        return schema.domains.map((domain) => `${domain.domain}${flags(domain)}  ${domain.commands?.length ?? 0} commands, ${domain.events?.length ?? 0} events`);
+    }
+    const [domainName, memberName, ...extra] = topic.split(".");
+    const domain = schema.domains.find((candidate) => candidate.domain.toLowerCase() === domainName?.toLowerCase());
+    if (domain === undefined || extra.length > 0) {
+        throw new CommandError("bad_args", `this Chrome has no CDP domain ${domainName}`, "run `patchrome --profile debug cdp help` to list domains");
+    }
+    if (memberName === undefined) {
+        return [
+            `${domain.domain}${flags(domain)}`,
+            ...(domain.description === undefined ? [] : [firstLine(domain.description)]),
+            "",
+            "commands",
+            ...(domain.commands ?? []).map((command) => `  ${domain.domain}.${command.name}${flags(command)}${command.description === undefined ? "" : `  ${firstLine(command.description)}`}`),
+            "",
+            "events",
+            ...(domain.events ?? []).map((event) => `  ${domain.domain}.${event.name}${flags(event)}${event.description === undefined ? "" : `  ${firstLine(event.description)}`}`),
+        ];
+    }
+    const command = domain.commands?.find((candidate) => candidate.name === memberName);
+    const event = domain.events?.find((candidate) => candidate.name === memberName);
+    const member = command ?? event;
+    if (member === undefined) {
+        throw new CommandError("bad_args", `${domain.domain} has no command or event ${memberName}`, `run \`patchrome --profile debug cdp help ${domain.domain}\``);
+    }
+    const heading = `${command === undefined ? "event" : "command"} ${domain.domain}.${member.name}${flags(member)}`;
+    return [
+        heading,
+        ...(member.description === undefined ? [] : [member.description]),
+        ...propertyBlock(command === undefined ? "fields" : "params", member.parameters),
+        ...propertyBlock("returns", member.returns),
+    ];
+}
+function propertyBlock(title, properties) {
+    if (properties === undefined || properties.length === 0)
+        return [];
+    return [
+        "",
+        title,
+        ...properties.map((property) => {
+            const kind = property.$ref ??
+                (property.type === "array"
+                    ? `${property.items?.$ref ?? property.items?.type ?? "unknown"}[]`
+                    : (property.type ?? "unknown"));
+            const choices = property.enum === undefined ? "" : ` (${property.enum.join("|")})`;
+            return `  ${property.name}${property.optional === true ? "?" : ""}: ${kind}${choices}${property.description === undefined ? "" : `  ${firstLine(property.description)}`}`;
+        }),
+    ];
+}
+function flags(item) {
+    return `${item.experimental === true ? " [experimental]" : ""}${item.deprecated === true ? " [deprecated]" : ""}`;
+}
+function firstLine(text) {
+    return text.split("\n")[0] ?? text;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,49 @@
+import type { ReplayHint } from "./history.ts";
+export declare const errorCodes: readonly ["tab_gone", "ref_stale", "timeout", "navigation_failed", "unsupported_in_stealth", "daemon_unreachable", "daemon_outdated", "bad_args", "copy_denied"];
+export type ErrorCode = (typeof errorCodes)[number];
+export declare const commandNames: readonly ["open", "tabs", "switch", "close", "goto", "snapshot", "click", "fill", "press", "type", "challenge", "screenshot", "text", "eval", "extract", "wait", "watch", "network-list", "network-get", "network-har-start", "network-har-stop", "route-block", "route-mock", "route-list", "route-clear", "login", "cookies", "state-save", "state-load", "state-import", "console", "errors", "trace-start", "trace-stop", "cdp", "cdp-help", "devtools-url", "session", "sessions", "session-close", "session-label", "daemon-status", "daemon-stop"];
+export type CommandName = (typeof commandNames)[number];
+export declare function isCommandName(value: string): value is CommandName;
+export type CommandArgs = Record<string, string | number | boolean | undefined>;
+export interface DaemonRequest {
+    id: number;
+    session: string;
+    command: CommandName;
+    args: CommandArgs;
+    timeoutMs: number;
+    argv?: string[];
+    buildId: string;
+}
+export interface ErrorBody {
+    code: ErrorCode;
+    message: string;
+    hint?: string;
+}
+export type DaemonResponse = {
+    id: number;
+    ok: true;
+    data: CommandData;
+} | {
+    id: number;
+    ok: false;
+    error: ErrorBody;
+};
+export interface DaemonStreamLine {
+    id: number;
+    stream: {
+        line: string;
+        fields: Record<string, unknown>;
+    };
+}
+export interface CommandData {
+    lines: string[];
+    fields: Record<string, unknown>;
+    replay?: ReplayHint;
+}
+export declare class CommandError extends Error {
+    readonly code: ErrorCode;
+    readonly hint: string | undefined;
+    constructor(code: ErrorCode, message: string, hint?: string);
+    toBody(): ErrorBody;
+}
+export declare function exitCodeFor(code: ErrorCode): number;

package/dist/protocol.js

@@ -0,0 +1,89 @@
+// Wire format between the CLI and the daemon: one JSON object per line over a unix socket.
+export const errorCodes = [
+    "tab_gone",
+    "ref_stale",
+    "timeout",
+    "navigation_failed",
+    "unsupported_in_stealth",
+    "daemon_unreachable",
+    "daemon_outdated",
+    "bad_args",
+    "copy_denied",
+];
+export const commandNames = [
+    "open",
+    "tabs",
+    "switch",
+    "close",
+    "goto",
+    "snapshot",
+    "click",
+    "fill",
+    "press",
+    "type",
+    "challenge",
+    "screenshot",
+    "text",
+    "eval",
+    "extract",
+    "wait",
+    "watch",
+    "network-list",
+    "network-get",
+    "network-har-start",
+    "network-har-stop",
+    "route-block",
+    "route-mock",
+    "route-list",
+    "route-clear",
+    "login",
+    "cookies",
+    "state-save",
+    "state-load",
+    "state-import",
+    "console",
+    "errors",
+    "trace-start",
+    "trace-stop",
+    "cdp",
+    "cdp-help",
+    "devtools-url",
+    "session",
+    "sessions",
+    "session-close",
+    "session-label",
+    "daemon-status",
+    "daemon-stop",
+];
+export function isCommandName(value) {
+    return commandNames.includes(value);
+}
+export class CommandError extends Error {
+    code;
+    hint;
+    constructor(code, message, hint) {
+        super(message);
+        this.code = code;
+        this.hint = hint;
+    }
+    toBody() {
+        return this.hint === undefined
+            ? { code: this.code, message: this.message }
+            : { code: this.code, message: this.message, hint: this.hint };
+    }
+}
+export function exitCodeFor(code) {
+    switch (code) {
+        case "bad_args":
+            return 2;
+        case "tab_gone":
+        case "ref_stale":
+        case "timeout":
+        case "navigation_failed":
+        case "unsupported_in_stealth":
+        case "daemon_unreachable":
+        case "daemon_outdated":
+        case "copy_denied":
+            return 1;
+    }
+}

package/dist/refs.d.ts

@@ -0,0 +1,9 @@
+export declare function parseRef(input: string): string;
+export declare function refsIn(snapshotText: string): Set<string>;
+export declare class SnapshotGenerations {
+    #private;
+    recordNavigation(): void;
+    recordSnapshot(snapshot: string): void;
+    get latestSnapshot(): string;
+    assertRefCurrent(ref: string): void;
+}

package/dist/refs.js

@@ -0,0 +1,46 @@
+import { CommandError } from "./protocol.js";
+// A ref is `@e12`, or `@f1e12` when Playwright prefixes the frame, resolved against the tab's latest snapshot. Staleness is tracked per tab, not per ref,
+// because a stale aria-ref locator does not fail on its own: it waits out the whole timeout.
+export function parseRef(input) {
+    const match = input.match(/^@?((?:f\d+)?e\d+)$/);
+    if (!match?.[1]) {
+        throw new CommandError("bad_args", `not a ref: ${input}`, "refs look like @e12 or @f1e12, taken from the latest snapshot");
+    }
+    return match[1];
+}
+export function refsIn(snapshotText) {
+    return new Set([...snapshotText.matchAll(/\[ref=((?:f\d+)?e\d+)\]/g)].map((match) => match[1] ?? ""));
+}
+export class SnapshotGenerations {
+    #navigationCount = 0;
+    #snapshotAtNavigation;
+    #latestRefs = new Set();
+    #latestSnapshot = "";
+    recordNavigation() {
+        this.#navigationCount++;
+    }
+    recordSnapshot(snapshot) {
+        this.#snapshotAtNavigation = this.#navigationCount;
+        this.#latestRefs = refsIn(snapshot);
+        this.#latestSnapshot = snapshot;
+    }
+    get latestSnapshot() {
+        return this.#latestSnapshot;
+    }
+    // Playwright renumbers frames on every snapshot, so a ref copied from an older snapshot of another
+    // page can survive the navigation check and then fail inside Playwright as "Invalid frame".
+    assertRefCurrent(ref) {
+        this.#assertNoNavigation();
+        if (!this.#latestRefs.has(ref)) {
+            throw new CommandError("ref_stale", `@${ref} is not in the latest snapshot of this tab`, "run `patchrome snapshot` and copy a ref from it");
+        }
+    }
+    #assertNoNavigation() {
+        if (this.#snapshotAtNavigation === undefined) {
+            throw new CommandError("ref_stale", "no snapshot taken on this tab", "run `patchrome snapshot` first");
+        }
+        if (this.#snapshotAtNavigation !== this.#navigationCount) {
+            throw new CommandError("ref_stale", "the page navigated since the last snapshot", "run `patchrome snapshot` again");
+        }
+    }
+}

package/dist/routes.d.ts

@@ -0,0 +1,20 @@
+import type { Tab } from "./sessions.ts";
+export type RouteRule = {
+    kind: "block";
+    glob: string;
+} | {
+    kind: "mock";
+    glob: string;
+    file: string;
+    body: Buffer;
+    contentType: string;
+};
+export declare class RouteTable {
+    #private;
+    track(tab: Tab): void;
+    block(session: string, glob: string): Promise<RouteRule>;
+    mock(session: string, glob: string, file: string): Promise<RouteRule>;
+    rulesOf(session: string): RouteRule[];
+    clear(session: string): Promise<number>;
+    forget(session: string): Promise<void>;
+}

package/dist/routes.js

@@ -0,0 +1,106 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { urlGlobMatches } from "./glob.js";
+import { CommandError } from "./protocol.js";
+const contentTypes = {
+    ".json": "application/json",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".js": "text/javascript",
+    ".css": "text/css",
+    ".txt": "text/plain",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+};
+// Rules belong to a session and apply to every tab it owns, including popups opened later. A tab only
+// intercepts requests while its session has rules, since interception turns off Chrome's cache.
+export class RouteTable {
+    #rules = new Map();
+    #installed = new Map();
+    #tabsBySession = new Map();
+    track(tab) {
+        let tabs = this.#tabsBySession.get(tab.session);
+        if (!tabs) {
+            tabs = new Set();
+            this.#tabsBySession.set(tab.session, tabs);
+        }
+        tabs.add(tab);
+        tab.page.on("close", () => {
+            tabs.delete(tab);
+            this.#installed.delete(tab.page);
+        });
+        if (this.rulesOf(tab.session).length > 0)
+            void this.#install(tab);
+    }
+    async block(session, glob) {
+        return this.#add(session, { kind: "block", glob });
+    }
+    async mock(session, glob, file) {
+        let body;
+        try {
+            body = await readFile(file);
+        }
+        catch (err) {
+            throw new CommandError("bad_args", `cannot read mock file ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return this.#add(session, {
+            kind: "mock",
+            glob,
+            file,
+            body,
+            contentType: contentTypes[extname(file).toLowerCase()] ?? "application/octet-stream",
+        });
+    }
+    rulesOf(session) {
+        return this.#rules.get(session) ?? [];
+    }
+    async clear(session) {
+        const count = this.rulesOf(session).length;
+        this.#rules.delete(session);
+        await Promise.all([...(this.#tabsBySession.get(session) ?? [])].map(async (tab) => {
+            const matcher = this.#installed.get(tab.page);
+            if (!matcher)
+                return;
+            this.#installed.delete(tab.page);
+            await tab.page.unroute(matcher).catch(() => { });
+        }));
+        return count;
+    }
+    async forget(session) {
+        await this.clear(session);
+        this.#tabsBySession.delete(session);
+    }
+    async #add(session, rule) {
+        this.#rules.set(session, [...this.rulesOf(session), rule]);
+        await Promise.all([...(this.#tabsBySession.get(session) ?? [])].map((tab) => this.#install(tab)));
+        return rule;
+    }
+    async #install(tab) {
+        if (this.#installed.has(tab.page))
+            return;
+        const matcher = (url) => this.#ruleFor(tab.session, url.href) !== undefined;
+        this.#installed.set(tab.page, matcher);
+        await tab.page
+            .route(matcher, (route) => this.#handle(tab.session, route))
+            .catch(() => {
+            this.#installed.delete(tab.page);
+        });
+    }
+    // The newest matching rule wins, so an agent can narrow an earlier broad block with a mock.
+    #ruleFor(session, url) {
+        return this.rulesOf(session).findLast((rule) => urlGlobMatches(rule.glob, url));
+    }
+    async #handle(session, route) {
+        const rule = this.#ruleFor(session, route.request().url());
+        if (!rule)
+            return route.fallback();
+        switch (rule.kind) {
+            case "block":
+                return route.abort("blockedbyclient");
+            case "mock":
+                return route.fulfill({ status: 200, contentType: rule.contentType, body: rule.body });
+        }
+    }
+}

package/dist/runner.d.ts

@@ -0,0 +1,20 @@
+import { CommandError, type DaemonStreamLine, type ErrorBody } from "./protocol.ts";
+export type RunResult = {
+    ok: true;
+    data: Record<string, unknown>;
+} | {
+    ok: false;
+    error: ErrorBody;
+};
+export interface RunOptions {
+    onStream?: (stream: DaemonStreamLine["stream"]) => void;
+}
+export declare class CommandRunner {
+    #private;
+    constructor(env: NodeJS.ProcessEnv, sessionFallback: () => string);
+    queueKey(argv: string[]): string;
+    isStreaming(argv: string[]): boolean;
+    run(argv: string[], options?: RunOptions): Promise<RunResult>;
+    close(): void;
+}
+export declare function toCommandError(err: unknown): CommandError;

package/dist/runner.js

@@ -0,0 +1,81 @@
+import { localActionData, parseCli } from "./cli.js";
+import { DaemonConnection } from "./client.js";
+import { CommandError } from "./protocol.js";
+// Runs CLI words the way the `patchrome` command does, over one kept-open connection per profile. `pipe`
+// and the library sit on this, so a script's words mean exactly what they mean on the command line.
+export class CommandRunner {
+    #env;
+    #sessionFallback;
+    #connections = new Map();
+    constructor(env, sessionFallback) {
+        this.#env = env;
+        this.#sessionFallback = sessionFallback;
+    }
+    // Which queue the words run in: commands of one session in one profile run in order.
+    queueKey(argv) {
+        try {
+            const parsed = parseCli(argv, this.#env, this.#sessionFallback);
+            if ("kind" in parsed)
+                return "local";
+            return `${parsed.profile}\n${parsed.session}`;
+        }
+        catch {
+            return "local";
+        }
+    }
+    // Streaming commands run outside their session's queue, so the next words need not wait for them.
+    isStreaming(argv) {
+        try {
+            const parsed = parseCli(argv, this.#env, this.#sessionFallback);
+            return (!("kind" in parsed) &&
+                (parsed.command === "watch" || (parsed.command === "console" && parsed.args.follow === true)));
+        }
+        catch {
+            return false;
+        }
+    }
+    async run(argv, options = {}) {
+        try {
+            const parsed = parseCli(argv, this.#env, this.#sessionFallback);
+            if ("kind" in parsed) {
+                switch (parsed.kind) {
+                    case "completions":
+                    case "pipe":
+                        throw new CommandError("bad_args", `${parsed.kind} runs only as its own command`, `run \`patchrome ${parsed.kind === "pipe" ? "pipe" : "completions zsh"}\` from a shell`);
+                    case "logs":
+                    case "audit":
+                    case "create-profile":
+                    case "history":
+                        return { ok: true, data: (await localActionData(parsed)).fields };
+                }
+            }
+            const response = await this.#connectionFor(parsed.profile).request({
+                ...parsed,
+                argv,
+                onStream: options.onStream,
+            });
+            return response.ok ? { ok: true, data: response.data.fields } : { ok: false, error: response.error };
+        }
+        catch (err) {
+            return { ok: false, error: toCommandError(err).toBody() };
+        }
+    }
+    close() {
+        for (const connection of this.#connections.values())
+            connection.close();
+        this.#connections.clear();
+    }
+    #connectionFor(profile) {
+        let connection = this.#connections.get(profile);
+        if (connection === undefined) {
+            connection = new DaemonConnection(profile, this.#env);
+            this.#connections.set(profile, connection);
+        }
+        return connection;
+    }
+}
+export function toCommandError(err) {
+    return err instanceof CommandError
+        ? err
+        : new CommandError("bad_args", err instanceof Error ? err.message : String(err));
+}

package/dist/session-name.d.ts

@@ -0,0 +1,9 @@
+export interface ProcessInfo {
+    pid: number;
+    ppid: number;
+    command: string;
+    tty: string;
+}
+export type ProcessLookup = (pid: number) => ProcessInfo | undefined;
+export declare function resolveSessionName(env: NodeJS.ProcessEnv, startPid: number, lookup: ProcessLookup): string;
+export declare function lookupProcess(pid: number): ProcessInfo | undefined;