@zenbu-labs/pixel 0.0.0 → 0.0.13

package/dist/sandbox.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandboxRefusal = sandboxRefusal;
+exports.deniedRefusal = deniedRefusal;
+exports.linuxSandboxError = linuxSandboxError;
+exports.apparmorSetup = apparmorSetup;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const REFUSAL = `[placeholder copy: the codex sandbox blocks commands pixel needs to run to determine the terminal pane it is running in.]
+Re-run this command with escalated permissions.`;
+function inCodex() {
+    return Boolean(process.env.CODEX_THREAD_ID ?? process.env.CODEX_PERMISSION_PROFILE);
+}
+function sandboxRefusal() {
+    return process.env.CODEX_SANDBOX ? REFUSAL : null;
+}
+function deniedRefusal() {
+    return inCodex() ? REFUSAL : null;
+}
+/**
+ * The reason we need to write this file is chromium
+ * uses a linux feature (unprivelged user namespaces)
+ * that ubuntu will not let a process use without a specific
+ * "grant" (userns) that can be given to a process by making
+ * this special file that creates an apparmor profile
+ */
+const APPARMOR_SCRIPT = node_path_1.default.resolve(__dirname, "..", "scripts", "apparmor.sh");
+function kernelSetting(file) {
+    if (!node_fs_1.default.existsSync(file))
+        return null;
+    return node_fs_1.default.readFileSync(file, "utf8").trim();
+}
+function setuidSandbox(electronBinary) {
+    const helper = node_path_1.default.join(node_path_1.default.dirname(electronBinary), "chrome-sandbox");
+    const stat = node_fs_1.default.statSync(helper, { throwIfNoEntry: false });
+    return stat !== undefined && stat.uid === 0 && (stat.mode & 0o4000) !== 0;
+}
+function apparmorProfile(electronBinary) {
+    try {
+        const resolved = node_fs_1.default.realpathSync(electronBinary);
+        const slug = node_crypto_1.default.createHash("sha256").update(resolved).digest("hex").slice(0, 12);
+        return node_fs_1.default.readFileSync(`/etc/apparmor.d/pixel-${slug}`, "utf8").includes(resolved);
+    }
+    catch {
+        return false;
+    }
+}
+function linuxSandboxError(electronBinary) {
+    if (process.getuid?.() === 0) {
+        return "Linux sandbox cannot run as root. Run pixel as a non-root user.]";
+    }
+    // look into all these cases some are new 
+    if (setuidSandbox(electronBinary))
+        return null;
+    if (apparmorProfile(electronBinary))
+        return null;
+    if (kernelSetting("/proc/sys/user/max_user_namespaces") === "0") {
+        return "This machine sets user.max_user_namespaces to 0, so nothing can create the user namespaces the chromium sandbox needs. Raise it with: sudo sysctl -w user.max_user_namespaces=15000 (write it to /etc/sysctl.d/ to keep it across reboots), or install a root-owned setuid chrome-sandbox helper.]";
+    }
+    if (kernelSetting("/proc/sys/kernel/apparmor_restrict_unprivileged_userns") === "1") {
+        return "AppArmor blocks unprivileged user namespaces, which the chromium sandbox needs. Run: sudo bash node_modules/@zenbu-labs/pixel/scripts/apparmor.sh <electron binary>]";
+    }
+    if (kernelSetting("/proc/sys/kernel/unprivileged_userns_clone") === "0") {
+        return "Linux disables unprivileged user namespaces. Enable them or install a root-owned setuid chrome-sandbox helper.";
+    }
+    return null;
+}
+function apparmorSetup(electronBinary) {
+    if (process.platform !== "linux")
+        return 0;
+    try {
+        (0, node_child_process_1.execFileSync)("bash", [APPARMOR_SCRIPT, electronBinary], { stdio: "inherit" });
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(`could not install the AppArmor profile: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+}

package/dist/scale.d.ts

@@ -0,0 +1,7 @@
+import type { EngineInfo } from "./react";
+import type { Terminal } from "./terminal";
+export declare function hostDisplayScale(terminal: Terminal | null, env: NodeJS.ProcessEnv): number;
+export declare class CellZoomFollower {
+    private last;
+    ratio(info: EngineInfo): number | null;
+}

package/dist/scale.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CellZoomFollower = void 0;
+exports.hostDisplayScale = hostDisplayScale;
+const electron_1 = require("electron");
+function hostDisplayScale(terminal, env) {
+    const explicit = Number(env.PIXEL_DISPLAY_SCALE);
+    if (Number.isFinite(explicit) && explicit > 0)
+        return explicit;
+    if (terminal?.reportsCssPixels)
+        return 1;
+    return electron_1.screen.getDisplayNearestPoint(electron_1.screen.getCursorScreenPoint()).scaleFactor;
+}
+class CellZoomFollower {
+    last = null;
+    ratio(info) {
+        const { height, basePx } = info;
+        const prev = this.last;
+        this.last = { height, basePx };
+        if (!prev || !prev.basePx || !prev.height)
+            return null;
+        const ratio = basePx / prev.basePx;
+        if (!Number.isFinite(ratio) || ratio <= 0 || Math.abs(ratio - 1) < 0.01)
+            return null;
+        const paneRatio = height / prev.height;
+        if (Math.abs(paneRatio - ratio) < 0.04 * ratio)
+            return null;
+        return ratio;
+    }
+}
+exports.CellZoomFollower = CellZoomFollower;

package/dist/ssh/index.d.ts

@@ -0,0 +1,58 @@
+export interface SshTunnel {
+    destination: string;
+    socksPort: number;
+    controlPath: string;
+    stop(): void;
+}
+export interface RemoteBundle {
+    url: string;
+    stop(): void;
+}
+export type StatusLine = (line: string) => void;
+export interface SshOptions {
+    /** [placeholder copy: Whether ssh may use this process's terminal for password and host key prompts. Off when called from inside a running app, where the terminal is already taken; ssh then fails instead of prompting.] */
+    terminal?: boolean;
+}
+export declare function parseSshTarget(target: string): {
+    destination: string;
+    sshPort: string | null;
+};
+interface ResolvedTarget {
+    destination: string;
+    hostArgs: string[];
+    aliasCommand: string | null;
+}
+export declare function resolveSshTarget(target: string): ResolvedTarget;
+export declare function validateSshTarget(target: string): void;
+export declare function openSshTunnel(target: string, status: StatusLine, options?: SshOptions): Promise<SshTunnel>;
+export interface SshSessionOptions extends SshOptions {
+    /** [placeholder copy: Where to connect, as you would type it after ssh: user@host, host:port, a full ssh command with flags, or a shell alias.] */
+    target: string;
+    /** [placeholder copy: A directory to install and start on the host. It must hold an executable start that prints READY <url>; setup and stop are optional.] */
+    bundle?: string | null;
+    /** [placeholder copy: Directory on the host that bundles are installed under.] */
+    remoteBase?: string | null;
+    status?: StatusLine;
+}
+export interface SshSession {
+    destination: string;
+    socksPort: number;
+    /** [placeholder copy: The url the bundle's start script announced, when a bundle was given.] */
+    url: string | undefined;
+    /** [placeholder copy: Props for the WebView that should browse through this host: spread them onto it.] */
+    view: {
+        proxy: string;
+        partition: string;
+    };
+    stop(): void;
+}
+export declare function connectSsh(options: SshSessionOptions): Promise<SshSession>;
+export declare function socksProxyRules(tunnel: SshTunnel): string;
+export declare function validateBundleDir(dir: string): void;
+export declare const REMOTE_BUNDLES_DIR = "${XDG_DATA_HOME:-$HOME/.local/share}/pixel/bundles";
+export interface BundleOptions extends SshOptions {
+    status: StatusLine;
+    remoteBase?: string;
+}
+export declare function startBundle(tunnel: SshTunnel, dir: string, options: BundleOptions): Promise<RemoteBundle>;
+export {};

package/dist/ssh/index.js

@@ -0,0 +1,445 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOTE_BUNDLES_DIR = void 0;
+exports.parseSshTarget = parseSshTarget;
+exports.resolveSshTarget = resolveSshTarget;
+exports.validateSshTarget = validateSshTarget;
+exports.openSshTunnel = openSshTunnel;
+exports.connectSsh = connectSsh;
+exports.socksProxyRules = socksProxyRules;
+exports.validateBundleDir = validateBundleDir;
+exports.startBundle = startBundle;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_net_1 = __importDefault(require("node:net"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+function parseSshTarget(target) {
+    const match = /^([A-Za-z0-9._-]+@)?([A-Za-z0-9._-]+)(:(\d+))?$/.exec(target);
+    if (!match) {
+        throw new Error(`[placeholder copy: invalid ssh target ${target} (user@host, host, user@host:port, or a shell alias for ssh)]`);
+    }
+    return { destination: `${match[1] ?? ""}${match[2]}`, sshPort: match[4] ?? null };
+}
+function resolveSshTarget(target) {
+    const words = target.trim().split(/\s+/).filter(Boolean);
+    if (words.length > 1) {
+        return { ...parseSshWords(words, target), aliasCommand: null };
+    }
+    const single = words[0] ?? "";
+    if (!single.includes("@") && !single.includes(":")) {
+        const alias = shellAlias(single);
+        if (alias) {
+            const parsed = parseSshCommand(alias);
+            if (parsed)
+                return { ...parsed, aliasCommand: alias.join(" ") };
+        }
+    }
+    const { destination, sshPort } = parseSshTarget(single);
+    return { destination, hostArgs: sshPort ? ["-p", sshPort] : [], aliasCommand: null };
+}
+function validateSshTarget(target) {
+    const words = target.trim().split(/\s+/).filter(Boolean);
+    if (words.length > 1)
+        parseSshWords(words, target);
+    else
+        parseSshTarget(words[0] ?? "");
+}
+function parseSshWords(words, target) {
+    const tokens = words[0] === "ssh" ? words.slice(1) : words;
+    const hostArgs = [];
+    let found = null;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.startsWith("-")) {
+            hostArgs.push(token);
+            if (SSH_VALUE_FLAGS.has(token) && i + 1 < tokens.length)
+                hostArgs.push(tokens[++i]);
+            continue;
+        }
+        if (found) {
+            throw new Error(`[placeholder copy: invalid ssh target ${target} (both ${found} and ${token} look like destinations)]`);
+        }
+        found = token;
+    }
+    if (!found)
+        throw new Error(`[placeholder copy: invalid ssh target ${target} (no destination)]`);
+    const { destination, sshPort } = parseSshTarget(found);
+    return { destination, hostArgs: [...hostArgs, ...(sshPort ? ["-p", sshPort] : [])] };
+}
+function shellAlias(name) {
+    if (!/^[A-Za-z0-9._-]+$/.test(name))
+        return null;
+    const shell = process.env.SHELL ?? "/bin/sh";
+    const result = (0, node_child_process_1.spawnSync)(shell, ["-ic", `alias ${name}`], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5000,
+    });
+    if (result.status !== 0 || !result.stdout)
+        return null;
+    const line = result.stdout.trim().split("\n").pop() ?? "";
+    const eq = line.indexOf("=");
+    if (eq < 0)
+        return null;
+    const tokens = unquote(line.slice(eq + 1).trim())
+        .split(/\s+/)
+        .filter(Boolean);
+    if (!/(^|\/)ssh$/.test(tokens[0] ?? ""))
+        return null;
+    return tokens.slice(1);
+}
+function unquote(value) {
+    if (value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1).replaceAll(`'\\''`, "'");
+    }
+    if (value.startsWith('"') && value.endsWith('"'))
+        return value.slice(1, -1);
+    return value.replaceAll("\\ ", " ");
+}
+const SSH_VALUE_FLAGS = new Set("-B -b -c -D -E -e -F -I -i -J -L -l -m -O -o -P -p -R -S -W -w".split(" "));
+function parseSshCommand(tokens) {
+    const hostArgs = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.startsWith("-")) {
+            hostArgs.push(token);
+            if (SSH_VALUE_FLAGS.has(token) && i + 1 < tokens.length)
+                hostArgs.push(tokens[++i]);
+            continue;
+        }
+        return { destination: token, hostArgs };
+    }
+    return null;
+}
+async function openSshTunnel(target, status, options = {}) {
+    const terminal = options.terminal ?? true;
+    const { destination, hostArgs, aliasCommand } = resolveSshTarget(target);
+    if (aliasCommand)
+        status(`${target} is an alias for ssh ${aliasCommand}`);
+    const controlPath = freshControlPath();
+    const socksPort = await freePort();
+    const args = [
+        ...(terminal ? [] : ["-o", "BatchMode=yes"]),
+        "-f",
+        "-N",
+        "-M",
+        "-S",
+        controlPath,
+        "-D",
+        `127.0.0.1:${socksPort}`,
+        "-o",
+        "ExitOnForwardFailure=yes",
+        "-o",
+        "ServerAliveInterval=15",
+        "-o",
+        "ServerAliveCountMax=3",
+        ...hostArgs,
+        destination,
+    ];
+    status(`connecting to ${destination}`);
+    const stderr = [];
+    const code = await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)("ssh", args, { stdio: terminal ? "inherit" : ["ignore", "ignore", "pipe"] });
+        child.stderr?.on("data", (chunk) => stderr.push(chunk.toString("utf8").trim()));
+        child.once("error", reject);
+        child.once("exit", (exitCode) => resolve(exitCode ?? 1));
+    });
+    if (code !== 0) {
+        const detail = stderr.filter(Boolean).join("\n");
+        throw new Error(`[placeholder copy: ssh to ${destination} failed${detail ? `: ${detail}` : ""}]`);
+    }
+    await waitForSocks(socksPort, destination);
+    status(`connected ${destination}`);
+    return {
+        destination,
+        socksPort,
+        controlPath,
+        stop: () => {
+            try {
+                (0, node_child_process_1.spawnSync)("ssh", ["-S", controlPath, "-O", "exit", destination], {
+                    stdio: "ignore",
+                    timeout: 5000,
+                });
+            }
+            catch { }
+        },
+    };
+}
+// The whole ssh mode in one step: tunnel, then bundle, then the props a page
+// needs to browse through the host. Stopping runs in reverse and also happens
+// when the process exits.
+async function connectSsh(options) {
+    const status = options.status ?? (() => { });
+    const terminal = options.terminal ?? true;
+    if (options.bundle)
+        validateBundleDir(options.bundle);
+    const tunnel = await openSshTunnel(options.target, status, { terminal });
+    let bundle = null;
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        bundle?.stop();
+        tunnel.stop();
+    };
+    process.on("exit", stop);
+    if (options.bundle) {
+        try {
+            bundle = await startBundle(tunnel, node_path_1.default.resolve(options.bundle), {
+                status,
+                remoteBase: options.remoteBase ?? undefined,
+                terminal,
+            });
+        }
+        catch (error) {
+            stop();
+            throw error;
+        }
+    }
+    return {
+        destination: tunnel.destination,
+        socksPort: tunnel.socksPort,
+        url: bundle?.url,
+        view: {
+            proxy: socksProxyRules(tunnel),
+            partition: `ssh-${tunnel.destination.replace(/[^A-Za-z0-9@._-]/g, "-")}`,
+        },
+        stop,
+    };
+}
+function socksProxyRules(tunnel) {
+    return `socks5://127.0.0.1:${tunnel.socksPort}`;
+}
+function validateBundleDir(dir) {
+    let stat;
+    try {
+        stat = node_fs_1.default.statSync(dir);
+    }
+    catch {
+        throw new Error(`[placeholder copy: bundle ${dir} does not exist]`);
+    }
+    if (!stat.isDirectory())
+        throw new Error(`[placeholder copy: bundle ${dir} is not a directory]`);
+    let start;
+    try {
+        start = node_fs_1.default.statSync(node_path_1.default.join(dir, "start"));
+    }
+    catch {
+        throw new Error(`[placeholder copy: bundle ${dir} has no start script]`);
+    }
+    if (!start.isFile() || !(start.mode & 0o111)) {
+        throw new Error(`[placeholder copy: bundle ${dir}/start is not executable]`);
+    }
+}
+const READY_TIMEOUT_MS = 120_000;
+exports.REMOTE_BUNDLES_DIR = '${XDG_DATA_HOME:-$HOME/.local/share}/pixel/bundles';
+async function startBundle(tunnel, dir, options) {
+    const { status, remoteBase = exports.REMOTE_BUNDLES_DIR, terminal = true } = options;
+    validateBundleDir(dir);
+    const name = bundleName(dir);
+    const remoteDir = `${remoteBase}/${name}-${bundleHash(dir).slice(0, 12)}`;
+    if (!installed(tunnel, remoteDir)) {
+        status(`installing ${name} on ${tunnel.destination}`);
+        upload(tunnel, dir, remoteDir);
+        setup(tunnel, remoteDir, terminal, status);
+    }
+    status(`starting ${name}`);
+    return launch(tunnel, name, remoteDir, status);
+}
+function bundleName(dir) {
+    let name = node_path_1.default.basename(dir);
+    try {
+        const manifest = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, "manifest.json"), "utf8"));
+        if (typeof manifest.name === "string" && manifest.name)
+            name = manifest.name;
+    }
+    catch { }
+    return name.replace(/[^A-Za-z0-9._-]/g, "-");
+}
+function bundleHash(dir) {
+    const hash = node_crypto_1.default.createHash("sha256");
+    const walk = (rel) => {
+        const entries = node_fs_1.default
+            .readdirSync(node_path_1.default.join(dir, rel), { withFileTypes: true })
+            .sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            const childRel = node_path_1.default.join(rel, entry.name);
+            if (entry.isDirectory()) {
+                walk(childRel);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const stat = node_fs_1.default.statSync(node_path_1.default.join(dir, childRel));
+            hash.update(`${childRel}\0${stat.mode & 0o777}\0`);
+            hash.update(node_fs_1.default.readFileSync(node_path_1.default.join(dir, childRel)));
+            hash.update("\0");
+        }
+    };
+    walk("");
+    return hash.digest("hex");
+}
+function run(tunnel, command, options = {}) {
+    return (0, node_child_process_1.spawnSync)("ssh", ["-S", tunnel.controlPath, tunnel.destination, command], {
+        input: options.input,
+        stdio: options.input ? undefined : options.stdio ?? "ignore",
+        timeout: options.timeout,
+        maxBuffer: 256 * 1024 * 1024,
+        encoding: "utf8",
+    });
+}
+function installed(tunnel, remoteDir) {
+    return run(tunnel, `test -f "${remoteDir}/.ready"`).status === 0;
+}
+function upload(tunnel, dir, remoteDir) {
+    const tar = (0, node_child_process_1.spawnSync)("tar", ["-cz", "-C", dir, "."], {
+        env: { ...process.env, COPYFILE_DISABLE: "1" },
+        maxBuffer: 256 * 1024 * 1024,
+    });
+    if (tar.status !== 0 || !tar.stdout)
+        throw new Error(`[placeholder copy: could not pack ${dir}]`);
+    const result = run(tunnel, `mkdir -p "${remoteDir}" && tar -xz -C "${remoteDir}"`, {
+        input: tar.stdout,
+    });
+    if (result.status !== 0) {
+        throw new Error(`[placeholder copy: could not upload the bundle to ${tunnel.destination}]`);
+    }
+}
+function setup(tunnel, remoteDir, terminal, status) {
+    const result = run(tunnel, `cd "${remoteDir}" && { [ ! -x ./setup ] || ./setup; } && touch .ready`, { stdio: terminal ? "inherit" : "pipe" });
+    if (!terminal) {
+        for (const line of `${result.stdout ?? ""}${result.stderr ?? ""}`.split("\n"))
+            if (line.trim())
+                status(line);
+    }
+    if (result.status !== 0) {
+        throw new Error(`[placeholder copy: the bundle's setup script failed on ${tunnel.destination}]`);
+    }
+}
+function launch(tunnel, name, remoteDir, status) {
+    const tail = [];
+    const child = (0, node_child_process_1.spawn)("ssh", [
+        "-tt",
+        "-S",
+        tunnel.controlPath,
+        tunnel.destination,
+        `cd "${remoteDir}" || exit 9; [ -x ./stop ] && ./stop >/dev/null 2>&1; exec ./start`,
+    ], { stdio: ["ignore", "pipe", "ignore"] });
+    const stop = () => {
+        try {
+            run(tunnel, `cd "${remoteDir}" && [ -x ./stop ] && ./stop`, { timeout: 10_000 });
+        }
+        catch { }
+        try {
+            child.kill();
+        }
+        catch { }
+    };
+    return new Promise((resolve, reject) => {
+        let buffer = "";
+        let done = false;
+        const finish = (result) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (result instanceof Error) {
+                stop();
+                reject(result);
+            }
+            else {
+                resolve(result);
+            }
+        };
+        const timer = setTimeout(() => {
+            finish(new Error(`[placeholder copy: ${name} never printed READY <url>]\n${tail.join("\n")}`));
+        }, READY_TIMEOUT_MS);
+        const sawLine = (line) => {
+            tail.push(line);
+            if (tail.length > 20)
+                tail.shift();
+            const ready = /^READY\s+(\S+)/.exec(line);
+            if (!ready)
+                return;
+            const url = pageUrl(ready[1]);
+            if (!url) {
+                finish(new Error(`[placeholder copy: ${name} printed READY ${ready[1]}, which is not an http(s) url]`));
+                return;
+            }
+            status(`${name} is up at ${url}`);
+            finish({ url, stop });
+        };
+        child.stdout.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            buffer += text;
+            let newline = buffer.indexOf("\n");
+            while (newline !== -1) {
+                const line = buffer.slice(0, newline).replace(/\r$/, "");
+                buffer = buffer.slice(newline + 1);
+                newline = buffer.indexOf("\n");
+                sawLine(line);
+            }
+        });
+        child.once("error", (error) => finish(error));
+        child.once("close", (code) => {
+            if (buffer.trim())
+                sawLine(buffer.trim());
+            finish(new Error(`[placeholder copy: ${name} exited with code ${code} before printing READY <url>]\n${tail.join("\n")}`));
+        });
+    });
+}
+function pageUrl(token) {
+    try {
+        const url = new URL(token);
+        return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function freshControlPath() {
+    const name = `${process.pid.toString(36)}-${Date.now().toString(36).slice(-5)}`;
+    const dir = node_path_1.default.join(node_os_1.default.tmpdir(), "pixel-ssh");
+    const candidate = node_path_1.default.join(dir, name);
+    if (candidate.length <= 80) {
+        node_fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        return candidate;
+    }
+    node_fs_1.default.mkdirSync("/tmp/pixel-ssh", { recursive: true, mode: 0o700 });
+    return node_path_1.default.join("/tmp/pixel-ssh", name);
+}
+function freePort() {
+    return new Promise((resolve, reject) => {
+        const server = node_net_1.default.createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            const port = typeof address === "object" && address ? address.port : null;
+            server.close(() => (port ? resolve(port) : reject(new Error("no free port"))));
+        });
+    });
+}
+function waitForSocks(port, destination) {
+    return new Promise((resolve, reject) => {
+        const socket = node_net_1.default.connect(port, "127.0.0.1");
+        const timer = setTimeout(() => {
+            socket.destroy();
+            reject(new Error(`[placeholder copy: the ssh proxy for ${destination} never started listening]`));
+        }, 5000);
+        socket.once("connect", () => {
+            clearTimeout(timer);
+            socket.end();
+            resolve();
+        });
+        socket.once("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}

package/dist/terminal/applescript.d.ts

@@ -0,0 +1,2 @@
+import type { Run } from "./run";
+export declare function appleScript(app: string, run: Run, language?: "JavaScript"): (script: string, args: string[]) => Promise<string>;

package/dist/terminal/applescript.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appleScript = appleScript;
+function appleScript(app, run, language) {
+    const flags = language ? ["-l", language] : [];
+    return async function osascript(script, args) {
+        try {
+            return (await run("osascript", [...flags, "-", ...args], script)).trim();
+        }
+        catch (error) {
+            if (error.signal === "SIGTERM") {
+                throw new Error(`controlling ${app} timed out — this environment may lack macOS automation permission for ${app}`);
+            }
+            const stderr = String(error.stderr ?? "").trim();
+            if (stderr)
+                throw new Error(`controlling ${app} failed: ${stderr}`);
+            throw error;
+        }
+    };
+}

package/dist/terminal/detect.d.ts

@@ -0,0 +1,10 @@
+import type { GraphicsSupport } from "./graphics";
+import type { Run } from "./run";
+import type { Terminal } from "./terminal";
+export declare function detect(env?: NodeJS.ProcessEnv, run?: Run): Terminal | null;
+export interface TerminalCheck {
+    terminal: Terminal | null;
+    graphics: GraphicsSupport;
+}
+export declare function checkTerminal(terminal: Terminal | null, env?: NodeJS.ProcessEnv): Promise<TerminalCheck>;
+export declare function cannotOpenPanes(terminal: Terminal | null): string;