@zenbu-labs/pixel 0.0.0 → 0.0.13

package/dist/terminal/terminals/ghostty-script.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GHOSTTY_SCRIPT = void 0;
+exports.GHOSTTY_SCRIPT = String.raw `ObjC.import("Foundation");
+
+const Descriptor = $.NSAppleEventDescriptor;
+const WAIT_FOR_REPLY = 3;
+const NOT_FOUND = -1728;
+
+function code(text) {
+  return ((text.charCodeAt(0) << 24) | (text.charCodeAt(1) << 16) | (text.charCodeAt(2) << 8) | text.charCodeAt(3)) >>> 0;
+}
+const typeCode = (text) => Descriptor.descriptorWithTypeCode(code(text));
+const enumCode = (text) => Descriptor.descriptorWithEnumCode(code(text));
+const string = (text) => Descriptor.descriptorWithString(text);
+const boolean = (value) => Descriptor.descriptorWithBoolean(value);
+const nothing = Descriptor.nullDescriptor;
+// the "every element" ordinal is the four-char code 'all ' stored in native (little-endian) byte order
+const everyOrdinal = Descriptor.descriptorWithDescriptorTypeData(
+  code("abso"),
+  $(" lla").dataUsingEncoding($.NSMacOSRomanStringEncoding),
+);
+
+function specifier(wanted, container, form, key) {
+  const record = Descriptor.recordDescriptor;
+  record.setDescriptorForKeyword(typeCode(wanted), code("want"));
+  record.setDescriptorForKeyword(container, code("from"));
+  record.setDescriptorForKeyword(enumCode(form), code("form"));
+  record.setDescriptorForKeyword(key, code("seld"));
+  return record.coerceToDescriptorType(code("obj "));
+}
+const every = (cls, container) => specifier(cls, container, "indx", everyOrdinal);
+const property = (name, of) => specifier("prop", of, "prop", typeCode(name));
+const terminal = (id) => specifier("Gtrm", nothing, "ID  ", string(id));
+const window = (id) => specifier("Gwnd", nothing, "ID  ", string(id));
+// tabs are only reachable through their window, so a tab needs both ids
+const tab = (windowId, id) => specifier("Gtab", window(windowId), "ID  ", string(id));
+
+function unwrap(descriptor) {
+  if (descriptor.isNil()) return null;
+  const type = descriptor.descriptorType;
+  if (type === code("list")) {
+    const items = [];
+    for (let i = 1; i <= descriptor.numberOfItems; i++) items.push(unwrap(descriptor.descriptorAtIndex(i)));
+    return items;
+  }
+  if (type === code("bool") || type === code("true") || type === code("fals")) return descriptor.booleanValue;
+  const text = descriptor.stringValue;
+  return text.isNil() ? null : ObjC.unwrap(text);
+}
+
+function send(pid, eventClass, eventId, params) {
+  const event = Descriptor.appleEventWithEventClassEventIDTargetDescriptorReturnIDTransactionID(
+    code(eventClass),
+    code(eventId),
+    Descriptor.descriptorWithProcessIdentifier(pid),
+    -1,
+    0,
+  );
+  for (const keyword of Object.keys(params)) event.setParamDescriptorForKeyword(params[keyword], code(keyword));
+  const failure = Ref();
+  const reply = event.sendEventWithOptionsTimeoutError(WAIT_FOR_REPLY, 10, failure);
+  if (reply.isNil()) {
+    throw new Error("[placeholder copy: Ghostty (pid " + pid + ") did not answer: " + ObjC.unwrap(failure[0].localizedDescription) + "]");
+  }
+  const number = reply.paramDescriptorForKeyword(code("errn"));
+  if (!number.isNil()) {
+    const message = reply.paramDescriptorForKeyword(code("errs"));
+    const detail = message.isNil() ? "" : ": " + ObjC.unwrap(message.stringValue);
+    const error = new Error("[placeholder copy: Ghostty (pid " + pid + ") refused the request (" + number.int32Value + ")" + detail + "]");
+    error.code = number.int32Value;
+    throw error;
+  }
+  return reply.paramDescriptorForKeyword(code("----"));
+}
+
+const get = (pid, name, of) => unwrap(send(pid, "core", "getd", { "----": property(name, of) }));
+const performAction = (pid, action, on) => unwrap(send(pid, "Ghst", "PfAc", { "----": string(action), GonT: on }));
+
+function list(pid) {
+  const windows = every("Gwnd", nothing);
+  const tabs = every("Gtab", windows);
+  const terminals = every("Gtrm", tabs);
+  const optional = (name) => {
+    try {
+      return get(pid, name, terminals);
+    } catch (error) {
+      if (error.code === NOT_FOUND) return null;
+      throw error;
+    }
+  };
+  const windowIds = get(pid, "ID  ", windows);
+  const tabIds = get(pid, "ID  ", tabs);
+  const ids = get(pid, "ID  ", terminals);
+  const cwds = get(pid, "Gwdr", terminals);
+  const foregroundPids = optional("Gpid");
+  const ttys = optional("Gtty");
+  let out = "";
+  windowIds.forEach((windowId, w) => {
+    tabIds[w].forEach((tabId, t) => {
+      ids[w][t].forEach((id, i) => {
+        const foreground = foregroundPids ? foregroundPids[w][t][i] : "";
+        const tty = ttys ? ttys[w][t][i] : "";
+        out += [windowId, tabId, id, foreground ?? "", tty ?? "", cwds[w][t][i] ?? ""].join("\t") + "\n";
+      });
+    });
+  });
+  return out;
+}
+
+// Ghostty does not report where splits sit, but goto_split says whether it could
+// move and the tab says where focus landed. Focus moves a moment after each
+// action returns, so every move is waited for; focus is put back where it was.
+function neighbor(pid, windowId, tabId, id, direction) {
+  const inTab = tab(windowId, tabId);
+  const focused = () => get(pid, "ID  ", property("GTfT", inTab));
+  const settle = (until) => {
+    for (let i = 0; i < 50; i++) {
+      const now = focused();
+      if (until(now)) return now;
+      delay(0.02);
+    }
+    return focused();
+  };
+  const focus = (target) => {
+    send(pid, "Ghst", "Fcus", { "----": terminal(target) });
+    settle((now) => now === target);
+  };
+  const startId = focused();
+  if (startId !== id) focus(id);
+  const moved = performAction(pid, "goto_split:" + direction, terminal(id)) === true;
+  const endId = moved ? settle((now) => now !== id) : id;
+  if (focused() !== startId) focus(startId);
+  return moved && endId !== id ? endId : "";
+}
+
+function orNotFound(work) {
+  try {
+    return work();
+  } catch (error) {
+    if (error.code === NOT_FOUND) return "not-found";
+    throw error;
+  }
+}
+
+function run(argv) {
+  const [pid, command, ...rest] = argv;
+  const target = Number(pid);
+  switch (command) {
+    case "list":
+      return list(target);
+    case "split":
+      return orNotFound(() => {
+        const [id, direction, directory, command] = rest;
+        const configuration = Descriptor.recordDescriptor;
+        configuration.setDescriptorForKeyword(string(directory), code("GScD"));
+        configuration.setDescriptorForKeyword(string(command), code("GScC"));
+        configuration.setDescriptorForKeyword(boolean(false), code("GScW"));
+        const opened = send(target, "Ghst", "Splt", { "----": terminal(id), GSpd: enumCode(direction), GSpS: configuration });
+        return get(target, "ID  ", opened);
+      });
+    case "input":
+      return orNotFound(() => {
+        send(target, "Ghst", "InTx", { "----": string(rest[1]), GItT: terminal(rest[0]) });
+        return "ok";
+      });
+    case "focus":
+      return orNotFound(() => {
+        send(target, "Ghst", "Fcus", { "----": terminal(rest[0]) });
+        return "ok";
+      });
+    case "action":
+      return orNotFound(() => String(performAction(target, rest[1], terminal(rest[0]))));
+    case "neighbor":
+      return orNotFound(() => neighbor(target, rest[0], rest[1], rest[2], rest[3]));
+  }
+  throw new Error("unknown command " + command);
+}
+`;

package/dist/terminal/terminals/ghostty.d.ts

@@ -0,0 +1,2 @@
+import type { Detect } from "../terminal";
+export declare const ghostty: Detect;

package/dist/terminal/terminals/ghostty.js

@@ -0,0 +1,336 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ghostty = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const applescript_1 = require("../applescript");
+const ghostty_script_1 = require("./ghostty-script");
+const graphics_1 = require("../graphics");
+const shared_1 = require("../shared");
+const DIRECTION_CODES = {
+    right: "GSrt",
+    left: "GSlf",
+    down: "GSdn",
+    up: "GSup",
+};
+const GHOSTTY_BINARY = /\/Ghostty\.app\/Contents\/MacOS\/ghostty(\s|$)/;
+function ghosttyAbove(start, processes) {
+    for (let pid = start, hops = 0; hops < 64 && processes.has(pid); hops++) {
+        const { parent, command } = processes.get(pid);
+        if (GHOSTTY_BINARY.test(command))
+            return pid;
+        pid = parent;
+    }
+    return null;
+}
+function markerDirectory() {
+    const name = `pixel-pane-${process.pid}-`;
+    try {
+        return node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), name));
+    }
+    catch {
+        return node_path_1.default.join(node_os_1.default.tmpdir(), name + Math.floor(Math.random() * 1e9));
+    }
+}
+const ghostty = (env, run) => {
+    const looksLikeGhostty = (env.TERM ?? "").includes("ghostty") ||
+        env.TERM_PROGRAM === "ghostty" ||
+        Boolean(env.GHOSTTY_RESOURCES_DIR);
+    if (!looksLikeGhostty)
+        return null;
+    if (process.platform !== "darwin") {
+        return {
+            name: "ghostty",
+            async split() {
+                throw new Error("--split is not supported inside ghostty on this platform");
+            },
+        };
+    }
+    const tooOld = (env.TERM_PROGRAM_VERSION?.localeCompare("1.3.0", undefined, { numeric: true }) ?? 0) < 0;
+    if (tooOld) {
+        return {
+            name: "ghostty",
+            async split() {
+                throw new Error(`Ghostty ${env.TERM_PROGRAM_VERSION} does not support automation: upgrade to Ghostty 1.3.0 or newer.`);
+            },
+        };
+    }
+    const osascript = (0, applescript_1.appleScript)("Ghostty", run, "JavaScript");
+    const directories = new Map();
+    let owner = null;
+    function ownerPid(tty) {
+        owner ??= findOwner(tty).catch((error) => {
+            owner = null;
+            throw error;
+        });
+        return owner;
+    }
+    async function ghosttyAncestor() {
+        for (let pid = process.pid, hops = 0; pid > 1 && hops < 64; hops++) {
+            const line = await run("ps", ["-o", "pid=,ppid=,command=", "-p", String(pid)]).catch(() => "");
+            const parts = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+            if (!parts)
+                return null;
+            if (GHOSTTY_BINARY.test(parts[3]))
+                return pid;
+            pid = Number(parts[2]);
+        }
+        return null;
+    }
+    async function findOwner(tty) {
+        const ancestor = await ghosttyAncestor();
+        if (ancestor !== null)
+            return ancestor;
+        const processes = new Map();
+        for (const line of (await run("ps", ["-axo", "pid=,ppid=,tty=,command="])).split("\n")) {
+            const parts = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/);
+            if (parts)
+                processes.set(Number(parts[1]), { parent: Number(parts[2]), tty: parts[3], command: parts[4] });
+        }
+        const above = ghosttyAbove(process.pid, processes);
+        if (above !== null)
+            return above;
+        if (tty) {
+            for (const [pid, { tty: owned }] of processes) {
+                if (`/dev/${owned}` !== tty)
+                    continue;
+                const found = ghosttyAbove(pid, processes);
+                if (found !== null)
+                    return found;
+            }
+        }
+        const running = [...processes].filter(([, { command }]) => GHOSTTY_BINARY.test(command)).map(([pid]) => pid);
+        if (running.length === 1)
+            return running[0];
+        if (running.length === 0) {
+            throw new Error("[placeholder copy: Ghostty is not running, so there is no window to script]");
+        }
+        throw new Error(`[placeholder copy: ${running.length} Ghostty processes are running (pids ${running.join(", ")}) and this shell is not inside any of them, so we cannot tell which one to script]`);
+    }
+    async function ghosttyCommand(command, args, tty = null) {
+        return osascript(ghostty_script_1.GHOSTTY_SCRIPT, [String(await ownerPid(tty)), command, ...args]);
+    }
+    let scale = null;
+    async function backingScale() {
+        if (scale !== null)
+            return scale;
+        const read = await run("osascript", [
+            "-l",
+            "JavaScript",
+            "-e",
+            "ObjC.import('AppKit'); $.NSScreen.mainScreen.backingScaleFactor",
+        ]).catch(() => "");
+        const found = Number(read.trim());
+        scale = Number.isFinite(found) && found > 0 ? found : 2;
+        return scale;
+    }
+    async function listPanes(tty = null) {
+        const listed = [];
+        const pids = new Map();
+        directories.clear();
+        for (const line of (await ghosttyCommand("list", [], tty)).split("\n")) {
+            if (!line.trim())
+                continue;
+            const [window, tab, pane, pid, paneTty, ...directory] = line.split("\t");
+            directories.set(pane, directory.join("\t"));
+            if (pid && !paneTty)
+                pids.set(pane, pid);
+            listed.push({ id: pane, tab: `${window}:${tab}`, tty: paneTty || null, command: null });
+        }
+        if (pids.size > 0) {
+            const byPid = new Map();
+            const listing = await run("ps", ["-o", "pid=,tty=", "-p", [...pids.values()].join(",")]).catch(() => "");
+            for (const line of listing.split("\n")) {
+                const [pid, paneTty] = line.trim().split(/\s+/);
+                if (pid && paneTty && paneTty !== "??")
+                    byPid.set(pid, `/dev/${paneTty}`);
+            }
+            for (const pane of listed) {
+                const pid = pids.get(pane.id);
+                if (pid)
+                    pane.tty = byPid.get(pid) ?? null;
+            }
+        }
+        return listed;
+    }
+    const paneByTty = new Map();
+    const missedAt = new Map();
+    const MISS_MEMORY_MS = 60_000;
+    async function cwdByPane() {
+        const cwds = new Map();
+        for (const line of (await ghosttyCommand("list", [])).split("\n")) {
+            if (!line.trim())
+                continue;
+            const [, , pane, , , ...directory] = line.split("\t");
+            cwds.set(pane, directory.join("\t"));
+        }
+        return cwds;
+    }
+    async function processCwd(pid) {
+        const listing = await run("lsof", ["-a", "-d", "cwd", "-Fn", "-p", pid]).catch(() => "");
+        const found = listing.split("\n").find((line) => line.startsWith("n/"));
+        return found ? found.slice(1) : node_os_1.default.homedir();
+    }
+    async function mapTtys(ttys, listed, cwdOf) {
+        const alive = new Set(listed.map((pane) => pane.id));
+        const pending = ttys.filter((tty) => {
+            const known = paneByTty.get(tty);
+            if (known && alive.has(known))
+                return false;
+            return Date.now() - (missedAt.get(tty) ?? 0) > MISS_MEMORY_MS;
+        });
+        if (pending.length === 0)
+            return;
+        const markers = new Map();
+        for (const tty of pending) {
+            const marker = markerDirectory();
+            try {
+                (0, shared_1.setPaneWorkingDirectory)(tty, marker);
+                markers.set(tty, marker);
+            }
+            catch {
+                missedAt.set(tty, Date.now());
+                node_fs_1.default.rmSync(marker, { recursive: true, force: true });
+            }
+        }
+        const mapped = new Map();
+        try {
+            // Ghostty applies OSC 7 as soon as it reads it, so one listing normally sees every
+            // marker; a second look only happens when the first saw none at all
+            for (let attempt = 0; attempt < 2 && mapped.size === 0 && markers.size > 0; attempt++) {
+                if (attempt > 0)
+                    await (0, shared_1.sleep)(120);
+                for (const [pane, cwd] of await cwdByPane()) {
+                    for (const [tty, marker] of markers) {
+                        if (cwd === marker && alive.has(pane))
+                            mapped.set(tty, pane);
+                    }
+                }
+            }
+        }
+        finally {
+            for (const [tty, marker] of markers) {
+                const pane = mapped.get(tty);
+                let restore = node_os_1.default.homedir();
+                if (pane) {
+                    paneByTty.set(tty, pane);
+                    restore = directories.get(pane) ?? restore;
+                }
+                else {
+                    missedAt.set(tty, Date.now());
+                    restore = await cwdOf(tty).catch(() => restore);
+                }
+                try {
+                    (0, shared_1.setPaneWorkingDirectory)(tty, restore);
+                }
+                catch { }
+                node_fs_1.default.rmSync(marker, { recursive: true, force: true });
+            }
+        }
+    }
+    async function ttysRunning(match) {
+        const byTty = new Map();
+        const listing = await run("ps", ["-e", "-o", "pid=,tty=,args="]).catch(() => "");
+        for (const line of listing.split("\n")) {
+            const parts = line.trim().match(/^(\d+)\s+(\S+)\s+(.*)$/);
+            if (!parts || parts[2].startsWith("?"))
+                continue;
+            const tty = `/dev/${parts[2]}`;
+            byTty.set(tty, [...(byTty.get(tty) ?? []), { pid: parts[1], command: parts[3] }]);
+        }
+        const matched = new Map();
+        for (const [tty, processes] of byTty) {
+            const command = processes.map((running) => running.command).join("\n");
+            if (match(command))
+                matched.set(tty, { pid: processes[processes.length - 1].pid, command });
+        }
+        return matched;
+    }
+    async function listPanesMatching(options) {
+        const listed = await listPanes(options?.tty ?? null);
+        if (!options?.commands || listed.some((pane) => pane.tty))
+            return listed;
+        const running = await ttysRunning(options.commands);
+        await mapTtys([...running.keys()], listed, (tty) => processCwd(running.get(tty).pid));
+        for (const [tty, { command }] of running) {
+            const pane = listed.find((candidate) => candidate.id === paneByTty.get(tty));
+            if (!pane)
+                continue;
+            pane.tty = tty;
+            pane.command = command;
+        }
+        return listed;
+    }
+    async function getCurrentPane({ tty, cwd }) {
+        if (!tty)
+            return null;
+        const before = await listPanes(tty);
+        const byTty = before.find((pane) => pane.tty === tty);
+        if (byTty)
+            return byTty;
+        missedAt.delete(tty);
+        await mapTtys([tty], before, async () => cwd);
+        const id = paneByTty.get(tty);
+        const found = id ? before.find((pane) => pane.id === id) : null;
+        if (!found) {
+            throw new Error(`could not find this pane in Ghostty — we marked ${tty} and no Ghostty pane reported it back, so ${tty} is not a Ghostty pane (a shell inside tmux or a remote session looks like this)`);
+        }
+        return found;
+    }
+    async function sizeSplit(pane, direction, size) {
+        const pixels = await (0, graphics_1.panePixels)();
+        if (!pixels)
+            return;
+        const sideways = direction === "right" || direction === "left";
+        const whole = sideways ? pixels.width : pixels.height;
+        const points = ((size - 0.5) * whole) / (await backingScale());
+        const amount = Math.round(Math.abs(points));
+        if (amount < 3)
+            return;
+        const away = {
+            right: "left",
+            left: "right",
+            down: "up",
+            up: "down",
+        };
+        const grow = points >= 0 ? away[direction] : direction;
+        await ghosttyCommand("action", [pane, `resize_split:${grow},${amount}`]);
+    }
+    return {
+        name: "ghostty",
+        getCurrentPane,
+        listPanes: listPanesMatching,
+        async sendText(pane, text) {
+            const result = await ghosttyCommand("input", [pane, text]);
+            if (result !== "ok")
+                throw new Error(`Ghostty could not type into pane ${pane}`);
+        },
+        async neighbor(from, direction) {
+            const [window, tab] = from.tab.split(":");
+            const result = (await ghosttyCommand("neighbor", [window, tab, from.id, direction])).trim();
+            return result && result !== "not-found" ? { id: result, tab: from.tab } : null;
+        },
+        async focusPane(pane) {
+            const result = await ghosttyCommand("focus", [pane]);
+            if (result !== "ok")
+                throw new Error(`Ghostty could not focus pane ${pane}`);
+        },
+        async split({ from, direction, command, size }) {
+            const startDir = directories.get(from.id) ?? process.cwd();
+            // Ghostty execs the command from login, and Electron logs a code-signing
+            // error when its parent is login; a shell in between keeps the pane quiet
+            const wrapped = (0, shared_1.shellQuote)(["/bin/sh", "-c", `${(0, shared_1.shellQuote)(command)}; exit $?`]);
+            const opened = await ghosttyCommand("split", [from.id, DIRECTION_CODES[direction], startDir, wrapped]);
+            if (!opened || opened === "not-found") {
+                throw new Error("this pane went away before we could split it");
+            }
+            if (size !== null)
+                await sizeSplit(opened, direction, size);
+        },
+    };
+};
+exports.ghostty = ghostty;

package/dist/terminal/terminals/herdr.d.ts

@@ -0,0 +1,2 @@
+import type { Detect } from "../terminal";
+export declare const herdr: Detect;

package/dist/terminal/terminals/herdr.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.herdr = void 0;
+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"));
+const shared_1 = require("../shared");
+function herdrConfigPath(env) {
+    if (env.HERDR_CONFIG_PATH)
+        return env.HERDR_CONFIG_PATH;
+    if (process.platform === "win32") {
+        return node_path_1.default.join(env.APPDATA ?? node_path_1.default.join(env.HOME ?? node_os_1.default.homedir(), "AppData", "Roaming"), "herdr", "config.toml");
+    }
+    return node_path_1.default.join(env.HOME ?? node_os_1.default.homedir(), ".config", "herdr", "config.toml");
+}
+function enableKittyGraphics(config) {
+    const flag = /^([ \t]*kitty_graphics[ \t]*=[ \t]*)false([ \t]*)$/m;
+    if (flag.test(config))
+        return config.replace(flag, "$1true$2");
+    const header = /^\[experimental\][ \t]*$/m;
+    if (header.test(config))
+        return config.replace(header, "[experimental]\nkitty_graphics = true");
+    const trimmed = config.replace(/\s+$/, "");
+    return `${trimmed}${trimmed ? "\n\n" : ""}[experimental]\nkitty_graphics = true\n`;
+}
+const NATIVE_DIRECTION = {
+    right: "right",
+    left: "right",
+    down: "down",
+    up: "down",
+};
+const OPPOSITE = { right: "left", down: "up" };
+const herdr = (env, run) => {
+    if (!env.HERDR_PANE_ID)
+        return null;
+    const bin = env.HERDR_BIN_PATH || "herdr";
+    const herdr = (args) => run(bin, args);
+    async function splitPane(args) {
+        return JSON.parse(await herdr(["pane", "split", ...args, "--right-click", "pane"]));
+    }
+    async function prepare() {
+        try {
+            const configPath = herdrConfigPath(env);
+            const current = node_fs_1.default.existsSync(configPath) ? node_fs_1.default.readFileSync(configPath, "utf8") : "";
+            if (/^[ \t]*kitty_graphics[ \t]*=[ \t]*true[ \t]*$/m.test(current))
+                return;
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(configPath), { recursive: true });
+            node_fs_1.default.writeFileSync(configPath, enableKittyGraphics(current));
+            await herdr(["server", "reload-config"]);
+        }
+        catch {
+        }
+    }
+    async function listPanes() {
+        const { result } = JSON.parse(await herdr(["pane", "list"]));
+        const workspace = env.HERDR_PANE_ID.split(":")[0];
+        const visible = result.panes.filter((pane) => (pane.workspace_id ?? pane.pane_id.split(":")[0]) === workspace);
+        const processes = await Promise.all(visible.map((pane) => herdr(["pane", "process-info", "--pane", pane.pane_id])
+            .then((out) => JSON.parse(out).result.process_info)
+            .catch(() => ({}))));
+        const ttyByPid = await shellTtys(processes.map((info) => info.shell_pid).filter((pid) => pid != null));
+        return visible.map((pane, i) => ({
+            id: pane.pane_id,
+            tab: pane.tab_id,
+            tty: processes[i].shell_pid != null ? ttyByPid.get(processes[i].shell_pid) ?? null : null,
+            command: (processes[i].foreground_processes ?? []).map((process) => process.cmdline ?? "").join("\n") || null,
+        }));
+    }
+    async function shellTtys(pids) {
+        const byPid = new Map();
+        if (pids.length === 0)
+            return byPid;
+        const listing = await run("ps", ["-o", "pid=,tty=", "-p", pids.join(",")]).catch(() => "");
+        for (const line of listing.split("\n")) {
+            const [pid, tty] = line.trim().split(/\s+/);
+            if (pid && tty && tty !== "??")
+                byPid.set(Number(pid), `/dev/${tty}`);
+        }
+        return byPid;
+    }
+    function socketCall(method, params) {
+        const socketPath = env.HERDR_SOCKET_PATH ?? node_path_1.default.join(env.HOME ?? node_os_1.default.homedir(), ".config", "herdr", "herdr.sock");
+        return new Promise((resolve, reject) => {
+            const socket = node_net_1.default.connect(socketPath);
+            let buffer = "";
+            socket.setTimeout(5000, () => socket.destroy(new Error("herdr socket timed out")));
+            socket.on("error", reject);
+            socket.on("data", (chunk) => {
+                buffer += chunk.toString();
+                const line = buffer.indexOf("\n");
+                if (line < 0)
+                    return;
+                socket.end();
+                const reply = JSON.parse(buffer.slice(0, line));
+                if (reply.error)
+                    reject(new Error(reply.error.message ?? "herdr socket call failed"));
+                else
+                    resolve(reply.result);
+            });
+            socket.on("connect", () => {
+                socket.write(`${JSON.stringify({ id: "pixel", method, params })}\n`);
+            });
+        });
+    }
+    async function focusPane(pane) {
+        const { result } = JSON.parse(await herdr(["pane", "get", pane]));
+        if (result.pane.tab_id !== env.HERDR_TAB_ID)
+            await herdr(["tab", "focus", result.pane.tab_id]);
+        await socketCall("pane.focus", { pane_id: pane });
+    }
+    return {
+        name: "herdr",
+        prepare,
+        getCurrentPane: async () => ({ id: env.HERDR_PANE_ID, tab: env.HERDR_TAB_ID }),
+        listPanes,
+        async neighbor(from, direction) {
+            const { result } = JSON.parse(await herdr(["pane", "neighbor", "--pane", from.id, "--direction", direction]));
+            const id = result.neighbor.neighbor_pane_id;
+            return id ? { id, tab: result.neighbor.layout.tab_id } : null;
+        },
+        async sendText(pane, text) {
+            await herdr(["pane", "send-text", pane, (0, shared_1.bracketedPaste)(text)]);
+        },
+        focusPane,
+        async split({ from, direction, command, size }) {
+            const native = NATIVE_DIRECTION[direction];
+            const ratio = size ? ["--ratio", String(size)] : [];
+            const { result } = await splitPane(["--pane", from.id, "--direction", native, "--focus", ...ratio]);
+            const newPaneId = result.pane.pane_id;
+            if (direction === "left" || direction === "up") {
+                await herdr(["pane", "swap", "--pane", newPaneId, "--direction", OPPOSITE[native]]);
+            }
+            await herdr(["pane", "run", newPaneId, (0, shared_1.shellQuote)(command)]);
+        },
+    };
+};
+exports.herdr = herdr;

package/dist/terminal/terminals/index.d.ts

@@ -0,0 +1,5 @@
+import type { Detect } from "../terminal";
+/**
+ * not fantastic, but ordering does matter
+ */
+export declare const TERMINALS: Detect[];