ptywright 0.1.0 → 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,2 @@
+import { t as main } from "./cli-DIUx2w6X.mjs";
+export { main };

package/{src/index.ts → dist/index.mjs}

@@ -1,16 +1,14 @@
+import { t as createPtywrightServer } from "./server-VHuEWWj_.mjs";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-import { createPtywrightServer } from "./mcp/server";
-
+//#region src/index.ts
 const { server, sessions } = createPtywrightServer();
-
 const transport = new StdioServerTransport();
 await server.connect(transport);
-
-function shutdown(): void {
-  sessions.closeAll();
-  void server.close();
+function shutdown() {
+	sessions.closeAll();
+	server.close();
 }
-
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
+//#endregion
+export {};

package/dist/mcp.mjs

@@ -0,0 +1,2 @@
+import { t as createPtywrightServer } from "./server-VHuEWWj_.mjs";
+export { createPtywrightServer };

package/dist/pty-cassette.mjs

@@ -0,0 +1,24 @@
+import { S as dataToBytes, _ as ptyCassetteSchema, a as inspectPtyCassette, b as byteLength, c as createPtyCassetteReplay, d as PTY_CASSETTE_SCHEMA_URL, f as normalizePtyCassette, g as ptyCassetteResizeEventSchema, h as ptyCassetteExitEventSchema, i as formatPtyCassetteInspectLines, l as readPtyCassettePath, m as ptyCassetteEventSchema, n as PtyCassetteRecorder, o as inspectPtyCassettePath, p as ptyCassetteDataEventSchema, r as createPtyCassetteRecorder, s as PtyCassetteReplay, t as wrapPtyLike, u as writePtyCassettePath, v as validatePtyCassette, x as dataToBase64, y as base64ToBytes } from "./pty_like-Cpkh_O9B.mjs";
+//#region src/pty-cassette/bun_terminal.ts
+function wrapBunTerminalOptions(options, recorder) {
+	const onData = options.data;
+	const onExit = options.exit;
+	return {
+		...options,
+		data: (terminal, data) => {
+			recorder.recordOutput(data);
+			onData?.(terminal, data);
+		},
+		exit: onExit ? (terminal) => onExit(terminal) : void 0
+	};
+}
+function writeBunTerminalRecorded(terminal, recorder, data) {
+	recorder.recordInput(data);
+	terminal.write(data);
+}
+function resizeBunTerminalRecorded(terminal, recorder, cols, rows) {
+	recorder.recordResize(cols, rows);
+	terminal.resize(cols, rows);
+}
+//#endregion
+export { PTY_CASSETTE_SCHEMA_URL, PtyCassetteRecorder, PtyCassetteReplay, base64ToBytes, byteLength, createPtyCassetteRecorder, createPtyCassetteReplay, dataToBase64, dataToBytes, formatPtyCassetteInspectLines, inspectPtyCassette, inspectPtyCassettePath, normalizePtyCassette, ptyCassetteDataEventSchema, ptyCassetteEventSchema, ptyCassetteExitEventSchema, ptyCassetteResizeEventSchema, ptyCassetteSchema, readPtyCassettePath, resizeBunTerminalRecorded, validatePtyCassette, wrapBunTerminalOptions, wrapPtyLike, writeBunTerminalRecorded, writePtyCassettePath };

package/dist/pty_like-Cpkh_O9B.mjs

@@ -0,0 +1,404 @@
+import { z } from "zod";
+import { dirname } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { Buffer } from "node:buffer";
+//#region src/pty-cassette/data.ts
+function dataToBytes(data) {
+	if (typeof data === "string") return Buffer.from(data, "utf8");
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	return data;
+}
+function dataToBase64(data) {
+	return Buffer.from(dataToBytes(data)).toString("base64");
+}
+function base64ToBytes(dataBase64) {
+	return Buffer.from(dataBase64, "base64");
+}
+function byteLength(data) {
+	return dataToBytes(data).byteLength;
+}
+//#endregion
+//#region src/pty-cassette/schema.ts
+const PTY_CASSETTE_SCHEMA_URL = "https://ptywright.local/schemas/ptywright-pty-cassette.schema.json";
+const base64Schema = z.string().refine((value) => value.length % 4 === 0 && /^[A-Za-z0-9+/]*={0,2}$/.test(value), { message: "expected base64-encoded data" });
+const ptyCassetteDataEventSchema = z.object({
+	atMs: z.number().int().nonnegative(),
+	type: z.enum(["output", "input"]),
+	dataBase64: base64Schema
+});
+const ptyCassetteResizeEventSchema = z.object({
+	atMs: z.number().int().nonnegative(),
+	type: z.literal("resize"),
+	cols: z.number().int().positive(),
+	rows: z.number().int().positive()
+});
+const ptyCassetteExitEventSchema = z.object({
+	atMs: z.number().int().nonnegative(),
+	type: z.literal("exit"),
+	exitCode: z.number().int(),
+	signal: z.union([
+		z.number().int(),
+		z.string(),
+		z.null()
+	]).optional()
+});
+const ptyCassetteEventSchema = z.union([
+	ptyCassetteDataEventSchema,
+	ptyCassetteResizeEventSchema,
+	ptyCassetteExitEventSchema
+]);
+const ptyCassetteSchema = z.object({
+	$schema: z.string().optional(),
+	version: z.literal(1),
+	createdAt: z.string().min(1),
+	durationMs: z.number().int().nonnegative(),
+	terminal: z.object({
+		cols: z.number().int().positive(),
+		rows: z.number().int().positive(),
+		term: z.string().min(1).optional()
+	}),
+	command: z.object({
+		file: z.string().min(1),
+		args: z.array(z.string()).optional(),
+		cwd: z.string().optional(),
+		env: z.record(z.string()).optional()
+	}).optional(),
+	metadata: z.record(z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.null()
+	])).optional(),
+	events: z.array(ptyCassetteEventSchema)
+}).superRefine((value, ctx) => {
+	let last = -1;
+	for (let i = 0; i < value.events.length; i += 1) {
+		const event = value.events[i];
+		if (event.atMs < last) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: [
+				"events",
+				i,
+				"atMs"
+			],
+			message: "events must be ordered by atMs"
+		});
+		last = event.atMs;
+	}
+});
+function normalizePtyCassette(input) {
+	return ptyCassetteSchema.parse(input);
+}
+function validatePtyCassette(input) {
+	const result = ptyCassetteSchema.safeParse(input);
+	if (result.success) return {
+		ok: true,
+		cassette: result.data
+	};
+	return {
+		ok: false,
+		errors: result.error.issues.map((issue) => {
+			return `${issue.path.length ? `${issue.path.join(".")}: ` : ""}${issue.message}`;
+		})
+	};
+}
+//#endregion
+//#region src/pty-cassette/io.ts
+function readPtyCassettePath(path) {
+	return normalizePtyCassette(JSON.parse(readFileSync(path, "utf8")));
+}
+function writePtyCassettePath(path, cassette) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, JSON.stringify(normalizePtyCassette(cassette), null, 2) + "\n", "utf8");
+	return path;
+}
+//#endregion
+//#region src/pty-cassette/replay.ts
+var PtyCassetteReplay = class {
+	cassette;
+	speed;
+	outputListeners = /* @__PURE__ */ new Set();
+	dataListeners = /* @__PURE__ */ new Set();
+	inputListeners = /* @__PURE__ */ new Set();
+	resizeListeners = /* @__PURE__ */ new Set();
+	exitListeners = /* @__PURE__ */ new Set();
+	stopped = false;
+	started = false;
+	constructor(cassette, options = {}) {
+		this.cassette = cassette;
+		this.speed = Math.max(0, options.speed ?? 0);
+	}
+	onOutput(listener) {
+		this.outputListeners.add(listener);
+		return disposable(this.outputListeners, listener);
+	}
+	onData(listener) {
+		this.dataListeners.add(listener);
+		return disposable(this.dataListeners, listener);
+	}
+	onInput(listener) {
+		this.inputListeners.add(listener);
+		return disposable(this.inputListeners, listener);
+	}
+	onResize(listener) {
+		this.resizeListeners.add(listener);
+		return disposable(this.resizeListeners, listener);
+	}
+	onExit(listener) {
+		this.exitListeners.add(listener);
+		return disposable(this.exitListeners, listener);
+	}
+	stop() {
+		this.stopped = true;
+	}
+	async start() {
+		if (this.started) throw new Error("pty cassette replay already started");
+		this.started = true;
+		const outputDecoder = new TextDecoder();
+		const inputDecoder = new TextDecoder();
+		let lastAtMs = 0;
+		for (const event of this.cassette.events) {
+			if (this.stopped) break;
+			if (this.speed > 0) {
+				const delayMs = Math.max(0, event.atMs - lastAtMs) / this.speed;
+				if (delayMs > 0) await sleep(delayMs);
+			}
+			lastAtMs = event.atMs;
+			if (event.type === "output") {
+				const data = decodeReplayData(event, outputDecoder);
+				for (const listener of this.outputListeners) listener(data);
+				if (data.text) for (const listener of this.dataListeners) listener(data.text);
+				continue;
+			}
+			if (event.type === "input") {
+				const data = decodeReplayData(event, inputDecoder);
+				for (const listener of this.inputListeners) listener(data);
+				continue;
+			}
+			if (event.type === "resize") {
+				for (const listener of this.resizeListeners) listener(event);
+				continue;
+			}
+			for (const listener of this.exitListeners) listener(event);
+		}
+		const tail = outputDecoder.decode();
+		if (tail) for (const listener of this.dataListeners) listener(tail);
+	}
+};
+function createPtyCassetteReplay(cassetteOrPath, options) {
+	return new PtyCassetteReplay(typeof cassetteOrPath === "string" ? readPtyCassettePath(cassetteOrPath) : cassetteOrPath, options);
+}
+function decodeReplayData(event, decoder) {
+	const bytes = base64ToBytes(event.dataBase64);
+	return {
+		event,
+		bytes,
+		text: decoder.decode(bytes, { stream: true })
+	};
+}
+function disposable(set, listener) {
+	return { dispose: () => {
+		set.delete(listener);
+	} };
+}
+async function sleep(ms) {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+//#region src/pty-cassette/inspect.ts
+function inspectPtyCassette(cassette, path) {
+	let outputCount = 0;
+	let inputCount = 0;
+	let resizeCount = 0;
+	let exitCount = 0;
+	let outputBytes = 0;
+	let inputBytes = 0;
+	for (const event of cassette.events) if (event.type === "output") {
+		outputCount += 1;
+		outputBytes += base64ToBytes(event.dataBase64).byteLength;
+	} else if (event.type === "input") {
+		inputCount += 1;
+		inputBytes += base64ToBytes(event.dataBase64).byteLength;
+	} else if (event.type === "resize") resizeCount += 1;
+	else exitCount += 1;
+	return {
+		version: cassette.version,
+		path,
+		createdAt: cassette.createdAt,
+		durationMs: cassette.durationMs,
+		terminal: cassette.terminal,
+		command: cassette.command,
+		eventCount: cassette.events.length,
+		outputCount,
+		inputCount,
+		resizeCount,
+		exitCount,
+		outputBytes,
+		inputBytes
+	};
+}
+function inspectPtyCassettePath(path) {
+	return inspectPtyCassette(readPtyCassettePath(path), path);
+}
+function formatPtyCassetteInspectLines(result) {
+	const command = result.command ? [result.command.file, ...result.command.args ?? []].join(" ") : null;
+	return [
+		"ok pty-cassette",
+		result.path ? `path=${result.path}` : "",
+		`version=${result.version}`,
+		`createdAt=${result.createdAt}`,
+		`durationMs=${result.durationMs}`,
+		`terminal=${result.terminal.cols}x${result.terminal.rows}`,
+		result.terminal.term ? `term=${result.terminal.term}` : "",
+		command ? `command=${command}` : "",
+		`events=${result.eventCount}`,
+		`output=${result.outputCount} chunks/${result.outputBytes} bytes`,
+		`input=${result.inputCount} chunks/${result.inputBytes} bytes`,
+		`resize=${result.resizeCount}`,
+		`exit=${result.exitCount}`
+	].filter(Boolean);
+}
+//#endregion
+//#region src/pty-cassette/recorder.ts
+var PtyCassetteRecorder = class {
+	startedAtMs = performance.now();
+	cassette;
+	constructor(options) {
+		this.cassette = {
+			$schema: PTY_CASSETTE_SCHEMA_URL,
+			version: 1,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			durationMs: 0,
+			terminal: options.terminal,
+			command: options.command,
+			metadata: options.metadata,
+			events: []
+		};
+	}
+	recordOutput(data) {
+		this.recordData("output", data);
+	}
+	recordInput(data) {
+		this.recordData("input", data);
+	}
+	recordResize(cols, rows) {
+		this.pushEvent({
+			atMs: this.nowMs(),
+			type: "resize",
+			cols,
+			rows
+		});
+	}
+	recordExit(event) {
+		this.pushEvent({
+			atMs: this.nowMs(),
+			type: "exit",
+			exitCode: event.exitCode,
+			signal: event.signal ?? null
+		});
+		this.cassette.durationMs = this.nowMs();
+	}
+	snapshot() {
+		this.cassette.durationMs = this.nowMs();
+		return normalizePtyCassette({
+			...this.cassette,
+			terminal: { ...this.cassette.terminal },
+			command: this.cassette.command ? {
+				...this.cassette.command,
+				args: this.cassette.command.args ? [...this.cassette.command.args] : void 0,
+				env: this.cassette.command.env ? { ...this.cassette.command.env } : void 0
+			} : void 0,
+			metadata: this.cassette.metadata ? { ...this.cassette.metadata } : void 0,
+			events: this.cassette.events.map((event) => ({ ...event }))
+		});
+	}
+	stop() {
+		return this.snapshot();
+	}
+	writePath(path) {
+		return writePtyCassettePath(path, this.snapshot());
+	}
+	recordData(type, data) {
+		if (byteLength(data) === 0) return;
+		this.pushEvent({
+			atMs: this.nowMs(),
+			type,
+			dataBase64: dataToBase64(data)
+		});
+	}
+	pushEvent(event) {
+		this.cassette.events.push(event);
+		this.cassette.durationMs = Math.max(this.cassette.durationMs, event.atMs);
+	}
+	nowMs() {
+		return Math.max(0, Math.round(performance.now() - this.startedAtMs));
+	}
+};
+function createPtyCassetteRecorder(options) {
+	return new PtyCassetteRecorder(options);
+}
+//#endregion
+//#region src/pty-cassette/pty_like.ts
+function wrapPtyLike(pty, options = {}) {
+	const recorder = options.recorder ?? createPtyCassetteRecorder({
+		terminal: options.terminal ?? {
+			cols: 80,
+			rows: 24,
+			term: "xterm-256color"
+		},
+		command: options.command,
+		metadata: options.metadata
+	});
+	const path = options.path;
+	const autoWriteOnExit = options.autoWriteOnExit ?? Boolean(path);
+	const disposables = [];
+	let disposed = false;
+	disposables.push(pty.onData((data) => recorder.recordOutput(data)));
+	disposables.push(pty.onExit((event) => {
+		recorder.recordExit(event);
+		if (path && autoWriteOnExit) recorder.writePath(path);
+	}));
+	return {
+		pty,
+		recorder,
+		write(data) {
+			recorder.recordInput(data);
+			return pty.write(data);
+		},
+		resize(cols, rows) {
+			recorder.recordResize(cols, rows);
+			return pty.resize?.(cols, rows);
+		},
+		kill(signal) {
+			return pty.kill?.(signal);
+		},
+		onData(listener) {
+			return pty.onData(listener);
+		},
+		onExit(listener) {
+			return pty.onExit(listener);
+		},
+		stopRecording() {
+			return recorder.stop();
+		},
+		writeCassette(nextPath = path) {
+			if (!nextPath) throw new Error("writeCassette requires a path");
+			return recorder.writePath(nextPath);
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			for (const disposable of disposables) dispose(disposable);
+		}
+	};
+}
+function dispose(disposable) {
+	if (!disposable) return;
+	if (typeof disposable === "function") {
+		disposable();
+		return;
+	}
+	disposable.dispose();
+}
+//#endregion
+export { dataToBytes as S, ptyCassetteSchema as _, inspectPtyCassette as a, byteLength as b, createPtyCassetteReplay as c, PTY_CASSETTE_SCHEMA_URL as d, normalizePtyCassette as f, ptyCassetteResizeEventSchema as g, ptyCassetteExitEventSchema as h, formatPtyCassetteInspectLines as i, readPtyCassettePath as l, ptyCassetteEventSchema as m, PtyCassetteRecorder as n, inspectPtyCassettePath as o, ptyCassetteDataEventSchema as p, createPtyCassetteRecorder as r, PtyCassetteReplay as s, wrapPtyLike as t, writePtyCassettePath as u, validatePtyCassette as v, dataToBase64 as x, base64ToBytes as y };