@overdeck/desktop 0.45.10 → 0.45.12

package/server/supervisor/pty-supervisor.js

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+import { $ as getOverdeckHome, et as init_paths } from "./paths-3R6b989k.js";
+import { n as init_pty_token, r as readPtyToken, t as PTY_TOKEN_HEADER } from "./pty-token-CScQ32Rj.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { appendFile, chmod, mkdir, unlink } from "node:fs/promises";
+import { timingSafeEqual } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import { createServer } from "node:http";
+import * as pty from "@homebridge/node-pty-prebuilt-multiarch";
+//#region src/lib/channels/pty-supervisor.ts
+/**
+* PTY supervisor for orchestrator delivery.
+*
+* This process must run under Node 22, not Bun: it owns the node-pty master fd
+* for the child Claude Code process, and Bun's native-addon compatibility layer
+* is known to make this PTY exit immediately. Because the supervisor owns the
+* PTY, a supervisor crash terminates the child session; Deacon resume should
+* recreate the launcher and supervisor just like a fresh spawn.
+*
+* The launcher runs `node dist/pty-supervisor.js claude ...` with TERM,
+* COLORTERM, LANG, PATH, NODE_EXTRA_CA_CERTS, and the rest of process.env
+* passed through unchanged. The supervisor proxies stdin/stdout/resize between
+* tmux and Claude, and listens on `${OVERDECK_HOME}/sockets/pty-<agentId>.sock`
+* for authenticated HTTP-on-unix POSTs. Socket-injected messages echo to stdout
+* by default so the tmux transcript shows what Cloister sent. Permission relay
+* is intentionally out of scope; existing Channels MCP remains the bidirectional
+* permission path for agents that opt into it.
+*/
+init_paths();
+init_pty_token();
+const DEFAULT_COLS = 80;
+const DEFAULT_ROWS = 24;
+const SHUTDOWN_GRACE_MS = 2e3;
+const MAX_REQUEST_BYTES = 1024 * 1024;
+const INPUT_ECHO_CONFIRM_TIMEOUT_MS = 2500;
+const INPUT_ECHO_CONFIRM_INTERVAL_MS = 50;
+const INPUT_ECHO_CONFIRM_ATTEMPTS = 2;
+const INPUT_ECHO_CONFIRM_PREFIX_CHARS = 40;
+const INPUT_SETTLE_MS = 300;
+const INPUT_PURGE_MAX_CHARS = 8192;
+const INPUT_PURGE_SETTLE_MS = 150;
+function getPtySupervisorSocketPath(agentId) {
+	return join(getOverdeckHome(), "sockets", `pty-${agentId}.sock`);
+}
+function getPtySupervisorLogPath(agentId) {
+	return join(getOverdeckHome(), "logs", `pty-supervisor-${agentId}.log`);
+}
+function resolveAgentIdOrExit() {
+	const agentId = process.env.OVERDECK_AGENT_ID;
+	if (!agentId) {
+		process.stderr.write("pty-supervisor: OVERDECK_AGENT_ID env var is required. It is normally supplied by the launcher.\n");
+		process.exit(2);
+	}
+	return agentId;
+}
+function resolveChildCommandOrExit() {
+	const [command, ...args] = process.argv.slice(2);
+	if (!command) {
+		process.stderr.write("pty-supervisor: child command is required. Example: node dist/pty-supervisor.js claude\n");
+		process.exit(2);
+	}
+	return {
+		command,
+		args
+	};
+}
+function constantTimeHeaderMatch(provided, expected) {
+	const value = Array.isArray(provided) ? provided[0] : provided;
+	if (!value) return false;
+	const providedBuffer = Buffer.from(value, "utf8");
+	const expectedBuffer = Buffer.from(expected, "utf8");
+	if (providedBuffer.length !== expectedBuffer.length) return false;
+	return timingSafeEqual(providedBuffer, expectedBuffer);
+}
+async function validatePtyToken(req, agentId) {
+	const expected = await readPtyToken(agentId);
+	if (!expected) return false;
+	return constantTimeHeaderMatch(req.headers[PTY_TOKEN_HEADER], expected);
+}
+async function readJsonBody(req) {
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of req) {
+		const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+		total += buffer.length;
+		if (total > MAX_REQUEST_BYTES) throw new Error("request body too large");
+		chunks.push(buffer);
+	}
+	const text = Buffer.concat(chunks).toString("utf8");
+	return JSON.parse(text || "{}");
+}
+function parsePayload(value) {
+	if (value === null || typeof value !== "object") return null;
+	const payload = value;
+	if (typeof payload.content !== "string" || payload.content.length === 0) return null;
+	if (payload.echo !== void 0 && typeof payload.echo !== "boolean") return null;
+	if (payload.caller !== void 0 && typeof payload.caller !== "string") return null;
+	if (payload.meta !== void 0) {
+		if (payload.meta === null || typeof payload.meta !== "object" || Array.isArray(payload.meta)) return null;
+		for (const [key, metaValue] of Object.entries(payload.meta)) if (typeof key !== "string" || typeof metaValue !== "string") return null;
+	}
+	return payload;
+}
+function payloadCaller(payload) {
+	return payload.caller ?? payload.meta?.caller;
+}
+async function appendSocketWriteLog(agentId, payload) {
+	try {
+		const logPath = getPtySupervisorLogPath(agentId);
+		await mkdir(join(getOverdeckHome(), "logs"), {
+			recursive: true,
+			mode: 448
+		});
+		const caller = payloadCaller(payload);
+		await appendFile(logPath, `${JSON.stringify({
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			agentId,
+			kind: "socket_write",
+			contentLength: payload.content.length,
+			...caller ? { caller } : {}
+		})}\n`, "utf8");
+	} catch {}
+}
+/**
+* Record what the PTY actually showed when echo confirmation failed — without
+* this the only artifact of a failed delivery is the opaque 502 in the bridge
+* log, and the next occurrence is undiagnosable (PAN-1769).
+*/
+async function appendEchoFailureLog(agentId, payload, observedTail) {
+	try {
+		const logPath = getPtySupervisorLogPath(agentId);
+		await mkdir(join(getOverdeckHome(), "logs"), {
+			recursive: true,
+			mode: 448
+		});
+		const caller = payloadCaller(payload);
+		await appendFile(logPath, `${JSON.stringify({
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			agentId,
+			kind: "echo_confirm_failed",
+			contentLength: payload.content.length,
+			observedTail,
+			...caller ? { caller } : {}
+		})}\n`, "utf8");
+	} catch {}
+}
+function writeJson(res, status, body) {
+	const encoded = JSON.stringify(body);
+	res.writeHead(status, {
+		"Content-Type": "application/json",
+		"Content-Length": Buffer.byteLength(encoded)
+	});
+	res.end(encoded);
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stripAnsi(value) {
+	return value.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[@-_]/g, "");
+}
+function normalizePtyText(value) {
+	return stripAnsi(value).replace(/\s+/g, " ").trim();
+}
+/**
+* Echo matching must survive the TUI's composer rendering: long lines wrap at
+* arbitrary character positions (injecting whitespace mid-word) and wrapped
+* rows are separated by box-drawing border characters. Collapsing whitespace
+* to single spaces (normalizePtyText) is not enough — a wrap inside the prefix
+* breaks a contiguous `.includes()` match even though the paste landed
+* (PAN-1769). Strip all whitespace and box-drawing chars from both sides.
+*/
+function normalizeForEchoMatch(value) {
+	return stripAnsi(value).replace(/[─-╿]/g, "").replace(/\s+/g, "");
+}
+/**
+* Claude Code collapses large pastes into a `[Pasted text #N +M lines]`
+* placeholder — the raw text never echoes. Treat the placeholder appearing in
+* output observed since this delivery began as confirmation that the paste
+* landed. Matched against `normalizeForEchoMatch` output (box chars + ALL
+* whitespace removed), because the TUI renders the placeholder inside a
+* bordered composer whose box-draw glyphs and mid-word wrap break a literal
+* `"[Pasted text "` match — the miss that wedged every large swarm-dispatch
+* kickoff (7k-char prompts) with "input echo confirmation failed".
+*/
+const PASTE_PLACEHOLDER_NORMALIZED_RE = /\[Pastedtext#?\d*/;
+function confirmationPrefix(content) {
+	const lines = content.split("\n");
+	return normalizeForEchoMatch(([...lines].reverse().find((line) => line.trim().length >= 3) ?? lines[lines.length - 1])?.trim() ?? "").slice(0, INPUT_ECHO_CONFIRM_PREFIX_CHARS);
+}
+/**
+* Pure confirmation predicate: the delivered content is considered echoed once
+* the composer shows either its trailing-line prefix or a collapsed paste
+* placeholder. Exported for unit testing against captured PTY output.
+*/
+function isEchoConfirmed(rawOutput, prefix) {
+	if (prefix.length === 0) return true;
+	const normalized = normalizeForEchoMatch(rawOutput);
+	return normalized.includes(prefix) || PASTE_PLACEHOLDER_NORMALIZED_RE.test(normalized);
+}
+async function waitForPtyEcho(readOutput, prefix) {
+	const confirmed = () => isEchoConfirmed(readOutput(), prefix);
+	const deadline = Date.now() + INPUT_ECHO_CONFIRM_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		if (confirmed()) return true;
+		await sleep(INPUT_ECHO_CONFIRM_INTERVAL_MS);
+	}
+	return confirmed();
+}
+/**
+* Erase a just-written paste from the harness composer with one Backspace per
+* written character. The PTY input stream is ordered, so the DELs are applied
+* after the paste regardless of render timing; extras on an already-empty
+* composer are no-ops, and a collapsed `[Pasted text]` placeholder is deleted
+* atomically by the first DEL. Without this, an unconfirmed-but-landed write
+* stacks with the retry write and the caller's tmux fallback, submitting the
+* same message two or three times (PAN-1769).
+*/
+async function purgePtyInput(child, charCount) {
+	const count = Math.min(charCount, INPUT_PURGE_MAX_CHARS) + 8;
+	child.write("".repeat(count));
+	await sleep(INPUT_PURGE_SETTLE_MS);
+}
+async function injectPtyMessage(child, agentId, payload) {
+	const trimmed = payload.content.replace(/\n+$/, "");
+	const prefix = confirmationPrefix(trimmed);
+	let observedOutput = "";
+	const subscription = child.onData((data) => {
+		observedOutput = `${observedOutput}${data}`.slice(-64 * 1024);
+	});
+	try {
+		let confirmed = prefix.length === 0;
+		for (let attempt = 1; attempt <= INPUT_ECHO_CONFIRM_ATTEMPTS && !confirmed; attempt++) {
+			if (attempt > 1) await purgePtyInput(child, trimmed.length);
+			child.write(trimmed);
+			confirmed = await waitForPtyEcho(() => observedOutput, prefix);
+			if (!confirmed && attempt < INPUT_ECHO_CONFIRM_ATTEMPTS) console.warn(`[pty-supervisor] Input echo not confirmed for ${agentId} after ${INPUT_ECHO_CONFIRM_TIMEOUT_MS}ms (attempt ${attempt}/${INPUT_ECHO_CONFIRM_ATTEMPTS}); purging and rewriting content before Enter.`);
+		}
+		if (!confirmed) {
+			await purgePtyInput(child, trimmed.length);
+			await appendEchoFailureLog(agentId, payload, normalizePtyText(observedOutput).slice(-200));
+			throw new Error(`input echo confirmation failed after ${INPUT_ECHO_CONFIRM_ATTEMPTS} attempts × ${INPUT_ECHO_CONFIRM_TIMEOUT_MS}ms`);
+		}
+		await sleep(INPUT_SETTLE_MS);
+		child.write("\r");
+		if (payload.echo !== false) process.stdout.write(trimmed.endsWith("\n") ? trimmed : `${trimmed}\n`);
+		await appendSocketWriteLog(agentId, payload);
+	} finally {
+		subscription.dispose();
+	}
+}
+function createPtySupervisorServer(agentId, child) {
+	return createServer(async (req, res) => {
+		if (req.method !== "POST") {
+			writeJson(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!await validatePtyToken(req, agentId)) {
+			writeJson(res, 403, { error: "forbidden" });
+			return;
+		}
+		let body;
+		try {
+			body = await readJsonBody(req);
+		} catch (error) {
+			writeJson(res, 400, { error: error instanceof Error ? error.message : "invalid json" });
+			return;
+		}
+		const payload = parsePayload(body);
+		if (!payload) {
+			writeJson(res, 400, { error: "content is required and must be a non-empty string" });
+			return;
+		}
+		try {
+			await injectPtyMessage(child, agentId, payload);
+			writeJson(res, 200, "ok");
+		} catch (error) {
+			writeJson(res, 502, { error: error instanceof Error ? error.message : String(error) });
+		}
+	});
+}
+async function unlinkIfExists(path) {
+	try {
+		if (existsSync(path)) await unlink(path);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+function waitForServerClose(server) {
+	return new Promise((resolve) => {
+		server.close(() => resolve());
+	});
+}
+async function bindSocket(server, socketPath) {
+	await mkdir(join(getOverdeckHome(), "sockets"), {
+		recursive: true,
+		mode: 448
+	});
+	await unlinkIfExists(socketPath);
+	await new Promise((resolve, reject) => {
+		const onError = (error) => {
+			server.off("listening", onListening);
+			reject(error);
+		};
+		const onListening = () => {
+			server.off("error", onError);
+			resolve();
+		};
+		server.once("error", onError);
+		server.once("listening", onListening);
+		server.listen(socketPath);
+	});
+	await chmod(socketPath, 384);
+}
+function stdoutDimensions() {
+	return {
+		cols: process.stdout.columns || DEFAULT_COLS,
+		rows: process.stdout.rows || DEFAULT_ROWS
+	};
+}
+function proxyPtyToStdout(child) {
+	child.onData((data) => {
+		if (process.stdout.write(data)) return;
+		child.pause();
+		process.stdout.once("drain", () => child.resume());
+	});
+}
+function proxyStdinToPty(child) {
+	process.stdin.on("data", (chunk) => child.write(chunk.toString()));
+	if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") process.stdin.setRawMode(true);
+	process.stdin.resume();
+}
+function proxyResizeToPty(child) {
+	const resize = () => {
+		const { cols, rows } = stdoutDimensions();
+		child.resize(cols, rows);
+	};
+	process.stdout.on("resize", resize);
+}
+async function main() {
+	const agentId = resolveAgentIdOrExit();
+	const { command, args } = resolveChildCommandOrExit();
+	const { cols, rows } = stdoutDimensions();
+	const child = pty.spawn(command, args, {
+		name: process.env.TERM || "xterm-256color",
+		cols,
+		rows,
+		cwd: process.cwd(),
+		env: process.env
+	});
+	proxyPtyToStdout(child);
+	proxyStdinToPty(child);
+	proxyResizeToPty(child);
+	const socketPath = getPtySupervisorSocketPath(agentId);
+	const server = createPtySupervisorServer(agentId, child);
+	let shuttingDown = false;
+	const childExited = new Promise((resolve) => {
+		child.onExit(resolve);
+	});
+	const cleanup = async () => {
+		await waitForServerClose(server).catch(() => void 0);
+		await unlinkIfExists(socketPath).catch(() => void 0);
+	};
+	const shutdown = async (signal) => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		try {
+			child.kill("SIGTERM");
+		} catch {}
+		await Promise.race([childExited, new Promise((resolve) => setTimeout(resolve, SHUTDOWN_GRACE_MS))]);
+		await cleanup();
+		process.exit(0);
+	};
+	process.once("SIGTERM", () => void shutdown("SIGTERM"));
+	process.once("SIGINT", () => void shutdown("SIGINT"));
+	await bindSocket(server, socketPath);
+	const result = await childExited;
+	if (shuttingDown) return;
+	shuttingDown = true;
+	await cleanup();
+	process.exit(result.exitCode ?? (result.signal ? 128 + result.signal : 0));
+}
+const invokedPath = process.argv[1] ? pathToFileURL(process.argv[1]).href : "";
+if (import.meta.url === invokedPath) main().catch((error) => {
+	process.stderr.write(`pty-supervisor: ${error instanceof Error ? error.message : String(error)}\n`);
+	process.exit(1);
+});
+//#endregion
+export { confirmationPrefix, createPtySupervisorServer, getPtySupervisorLogPath, getPtySupervisorSocketPath, injectPtyMessage, isEchoConfirmed };
+
+//# sourceMappingURL=pty-supervisor.js.map

package/server/supervisor/pty-token-CScQ32Rj.js

@@ -0,0 +1,43 @@
+import { t as __esmMin } from "./chunk-ruWRV7i3.js";
+import { $ as getOverdeckHome, et as init_paths } from "./paths-3R6b989k.js";
+import "node:fs";
+import { join } from "node:path";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+//#region src/lib/pty-token.ts
+function ptyTokenDir(agentId) {
+	return join(getOverdeckHome(), "agents", agentId);
+}
+function getPtyTokenPath(agentId) {
+	return join(ptyTokenDir(agentId), "pty-token");
+}
+async function readPtyToken(agentId) {
+	try {
+		const value = (await readFile(getPtyTokenPath(agentId), "utf8")).trim();
+		return value.length > 0 ? value : null;
+	} catch {
+		return null;
+	}
+}
+async function writePtyToken(agentId) {
+	await mkdir(ptyTokenDir(agentId), {
+		recursive: true,
+		mode: 448
+	});
+	const token = randomBytes(32).toString("hex");
+	const path = getPtyTokenPath(agentId);
+	await writeFile(path, `${token}\n`, { mode: 384 });
+	try {
+		await chmod(path, 384);
+	} catch {}
+	return token;
+}
+var PTY_TOKEN_HEADER;
+var init_pty_token = __esmMin((() => {
+	init_paths();
+	PTY_TOKEN_HEADER = "x-overdeck-pty-token";
+}));
+//#endregion
+export { writePtyToken as i, init_pty_token as n, readPtyToken as r, PTY_TOKEN_HEADER as t };
+
+//# sourceMappingURL=pty-token-CScQ32Rj.js.map

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/LICENSE

@@ -0,0 +1,69 @@
+Copyright (c) 2012-2015, Christopher Jeffrey (https://github.com/chjj/)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+
+The MIT License (MIT)
+
+Copyright (c) 2016, Daniel Imms (http://www.growingwiththeweb.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
+MIT License
+
+Copyright (c) 2018 - present Microsoft Corporation
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/README.md

@@ -0,0 +1,67 @@
+<p align="center">
+  <a href="https://homebridge.io"><img src="https://raw.githubusercontent.com/homebridge/branding/latest/logos/homebridge-color-round-stylized.png" height="140"></a>
+</p>
+<span align="center">
+
+# node-pty-prebuilt-multiarch
+
+[![npm](https://badgen.net/npm/v/@homebridge/node-pty-prebuilt-multiarch/latest)](https://www.npmjs.com/package/@homebridge/node-pty-prebuilt-multiarch)
+[![npm](https://badgen.net/npm/dt/@homebridge/node-pty-prebuilt-multiarch?label=downloads)](https://www.npmjs.com/package/@homebridge/node-pty-prebuilt-multiarch)
+![Prebuild Binaries](https://github.com/homebridge/node-pty-prebuilt-multiarch/workflows/Build%20and%20Test/badge.svg)
+[![Discord](https://badgen.net/discord/online-members/C87Pvq3?icon=discord&label=discord)](https://discord.gg/C87Pvq3)
+
+</span>
+
+This project is a parallel fork of [`node-pty`](https://github.com/Microsoft/node-pty) providing prebuilt packages for certain Node.js and Electron versions.
+
+Inspired by [daviwil/node-pty-prebuilt](https://github.com/daviwil/node-pty-prebuilt).
+
+## Usage
+
+Thanks to the excellent [`prebuild`](https://github.com/prebuild/prebuild), [`prebuild-install`](https://github.com/prebuild/prebuild) modules, and [`prebuildify`](https://github.com/prebuild/prebuildify) using this module is extremely easy.
+You merely have to change your `node-pty` dependency to `@homebridge/node-pty-prebuilt-multiarch` and then change any `require` statements in your code from `require('node-pty')` to `require('@homebridge/node-pty-prebuilt-multiarch')`.
+
+## How It Works
+
+We maintain a parallel fork of the `node-pty` codebase that will be updated as new releases are shipped.
+When we merge new updates to the code into the `prebuilt-multiarch` branch, new prebuilt packages for our supported Node.js and Electron versions are updated to the corresponding [GitHub release](https://github.com/homebridge/node-pty-prebuilt-multiarch/releases).
+
+When `@homebridge/node-pty-prebuilt-multiarch` is installed as a package dependency, the installation script checks to see if there's a prebuilt package on this repo for the OS, ABI version, and architecture of the current process and then downloads it, extracting it into the module path.
+If a corresponding prebuilt package is not found, `node-gyp` is invoked to build the package for the current platform.
+
+## Prebuilt Versions
+
+| OS            | Architectures             |
+|---------------|---------------------------|
+| macOS         | x64, arm64                |
+| Linux (glibc) | ia32, x64, aarch64 |
+| Linux (musl)  | x64, aarch64       |
+| Windows       | ia32, x64                 |
+
+We only provide prebuilt binaries for Node.js 18 and Electron 17.0.0 or higher.  Pls note that prebuilds for Electron 28 are not supplied due to build issues.
+
+## Build / Package
+
+Please note releasing this package uses the GitHub action `Stage 1 - Run prebuild's and Create GitHub and NPM release` and `Stage 2 - Validate NPM Package contents`.
+
+The github action takes the branch selected from the workflow start drop down, and creates a GitHub and NPM Release containing the prebuild artifacts.
+The version of the Release comes from the package.json, and in the case of a BETA release automatically appends the beta release version.
+During processing, it leverages a branch called `release-candidate` as a holding area for prebuilds.
+
+When running the job, most times a couple of the instances of the sub step `Commit & Push Changes` within `Prebuild NPM and GitHub Release artifacts` fails.
+When this occurs just re-run. This is due to concurrency issues between the steps and GitHub.
+A typical run has 3-4 steps fail.
+
+1. Create branch `release-candidate` if not existing (the script deletes it before starting and will fail if it isn't present)
+2. Ensure version tag within package.json reflects version you want to publish, please note beta tags are added by the action.
+3. Run Action `Run prebuild's and Create GitHub and NPM release`, and select branch you wish to publish, and if it needs to be BETA tagged and versioned
+4. This will run for about an hour, and create a GitHub release with the prebuild artifacts attached, and a npm release with the prebuild artifacts attached
+
+## License
+
+* Copyright (c) 2012-2015, Christopher Jeffrey (MIT License).
+* Copyright (c) 2016, Daniel Imms (MIT License).
+* Copyright (c) 2018, Microsoft Corporation (MIT License).
+* Copyright (c) 2018, David Wilson (MIT License).
+* Copyright (c) 2018, oznu (MIT License).
+* Copyright (c) 2025, Homebridge (MIT License).