opencode-zellij 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1047 @@
+import { randomUUID } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+import { tool } from "@opencode-ai/plugin";
+import { execFile, spawn } from "node:child_process";
+import process from "node:process";
+import { promisify } from "node:util";
+import { Buffer } from "node:buffer";
+//#region src/utils/shell-args.ts
+const directCommandExitWrapper = "token=\"$1\"; shift; set +e; \"$@\"; code=$?; printf \"\\n[zellij-pty:%s] exit-code=%s\\n\" \"$token\" \"$code\"; exit \"$code\"";
+const shellCommandExitWrapper = "token=\"$1\"; command=\"$2\"; set +e; bash -lc \"$command\"; code=$?; printf \"\\n[zellij-pty:%s] exit-code=%s\\n\" \"$token\" \"$code\"; exit \"$code\"";
+function buildCommandArgv(input, options = {}) {
+	const command = input.command.trim();
+	if (!command) throw new Error("command is required");
+	if (options.exitCodeToken) {
+		if (input.args && input.args.length > 0) return [
+			"bash",
+			"-lc",
+			directCommandExitWrapper,
+			"zellij-pty",
+			options.exitCodeToken,
+			command,
+			...input.args
+		];
+		return [
+			"bash",
+			"-lc",
+			shellCommandExitWrapper,
+			"zellij-pty",
+			options.exitCodeToken,
+			command
+		];
+	}
+	if (input.args && input.args.length > 0) return [command, ...input.args];
+	return [
+		"bash",
+		"-lc",
+		command
+	];
+}
+function commandLineForPolicy(input) {
+	if (!input.args || input.args.length === 0) return input.command.trim();
+	return [input.command, ...input.args].join(" ").trim();
+}
+//#endregion
+//#region src/permissions/policy.ts
+const denyPatterns = [
+	/(^|\s)rm\s+-[^\n&;r|]*r[^\n&;|]*f\s+\//,
+	/(^|\s)mkfs(?:\s|$)/,
+	/(^|\s)dd\s+(?:[^\s&;|][^\n;|&]*)?\bof=\/dev\//,
+	/:\(\)\s*\{\s*:\|:\s*&\s*\}\s*;/
+];
+const sudoPattern = /(?:^|[\s;&|])sudo(?:[\s;&|]|$)/;
+let configuredDenyCommands = [];
+let configuredAllowCommands = [];
+let allowSudoPane = true;
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function escapeRegex(value) {
+	return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function wildcardMatches(pattern, commandLine) {
+	return new RegExp(`^${pattern.split("*").map(escapeRegex).join(".*")}$`).test(commandLine);
+}
+function configurePolicy(config) {
+	if (!config || typeof config !== "object") return;
+	const object = config;
+	if (isStringArray(object.denyCommands)) configuredDenyCommands = object.denyCommands;
+	if (isStringArray(object.allowCommands)) configuredAllowCommands = object.allowCommands;
+	if (typeof object.allowSudoPane === "boolean") allowSudoPane = object.allowSudoPane;
+}
+function assertCommandAllowed(input) {
+	const commandLine = commandLineForPolicy(input);
+	for (const pattern of denyPatterns) if (pattern.test(commandLine)) throw new Error(`Command denied by zellij-pty policy: ${commandLine}`);
+	for (const pattern of configuredDenyCommands) if (wildcardMatches(pattern, commandLine)) throw new Error(`Command denied by zellij-pty configured deny rule: ${commandLine}`);
+	if (configuredAllowCommands.length > 0 && !configuredAllowCommands.some((pattern) => wildcardMatches(pattern, commandLine))) throw new Error(`Command denied by zellij-pty allow list: ${commandLine}`);
+	if (!input.humanInputOnly && sudoPattern.test(commandLine)) throw new Error("sudo commands must use request_sudo so credentials stay human-input-only and never pass through agent tool input.");
+	if (input.humanInputOnly && sudoPattern.test(commandLine) && !allowSudoPane) throw new Error("sudo pane is disabled by zellij-pty policy.");
+}
+//#endregion
+//#region src/utils/ids.ts
+const paneIdPattern = /\b(?:terminal_)?(\d+)\b/;
+function createSessionId() {
+	return `zpty_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+}
+function normalizePaneId(rawPaneId) {
+	const trimmed = rawPaneId.trim();
+	if (/^terminal_\d+$/.test(trimmed)) return trimmed;
+	if (/^\d+$/.test(trimmed)) return `terminal_${trimmed}`;
+	throw new Error(`Invalid Zellij terminal pane id: ${rawPaneId}`);
+}
+function parsePaneId(output) {
+	const match = output.match(paneIdPattern);
+	if (!match?.[1]) throw new Error(`Unable to parse Zellij pane id from output: ${output.trim() || "<empty>"}`);
+	return normalizePaneId(match[1]);
+}
+//#endregion
+//#region src/pty/manager.ts
+var SessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	create(input) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const session = {
+			id: createSessionId(),
+			openCodeSessionId: input.openCodeSessionId ?? null,
+			paneId: input.paneId,
+			title: input.title,
+			command: input.command,
+			args: input.args ?? [],
+			cwd: input.cwd,
+			status: "running",
+			lineCount: 0,
+			createdAt: now,
+			updatedAt: now,
+			allowAgentInput: input.allowAgentInput,
+			humanInputOnly: input.humanInputOnly,
+			exitCode: null,
+			exitedAt: null,
+			exitCodeToken: input.exitCodeToken ?? null
+		};
+		this.sessions.set(session.id, session);
+		return session;
+	}
+	get(id) {
+		const session = this.sessions.get(id);
+		if (!session) throw new Error(`Unknown zellij PTY session: ${id}`);
+		return session;
+	}
+	list() {
+		return Array.from(this.sessions.values()).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+	}
+	updateLineCount(id, lineCount) {
+		const session = this.get(id);
+		session.lineCount = lineCount;
+		session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		return session;
+	}
+	updateStatus(id, status) {
+		const session = this.get(id);
+		session.status = status;
+		session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		return session;
+	}
+	markExited(id, exitCode) {
+		const session = this.get(id);
+		session.status = "exited";
+		session.exitCode = exitCode;
+		session.exitedAt = (/* @__PURE__ */ new Date()).toISOString();
+		session.updatedAt = session.exitedAt;
+		return session;
+	}
+	listByOpenCodeSession(openCodeSessionId) {
+		return this.list().filter((session) => session.openCodeSessionId === openCodeSessionId);
+	}
+	remove(id) {
+		if (!this.sessions.delete(id)) throw new Error(`Unknown zellij PTY session: ${id}`);
+	}
+};
+const sessionManager = new SessionManager();
+//#endregion
+//#region src/zellij/cli.ts
+const execFileAsync = promisify(execFile);
+function zellijCommandArgs(actionArgs) {
+	const sessionName = process.env.ZELLIJ_SESSION_NAME?.trim();
+	if (sessionName) return [
+		"--session",
+		sessionName,
+		...actionArgs
+	];
+	return actionArgs;
+}
+function zellijActionArgs(action, args = []) {
+	return [
+		"action",
+		action,
+		...args
+	];
+}
+function buildNewPaneActionArgs(options) {
+	const args = ["action", "new-pane"];
+	if (process.env.ZELLIJ) args.push("--near-current-pane");
+	if (options.title) args.push("--name", options.title);
+	if (options.cwd) args.push("--cwd", options.cwd);
+	if (options.floating) args.push("--floating");
+	args.push("--", ...buildCommandArgv(options, { exitCodeToken: options.exitCodeToken }));
+	return args;
+}
+function ensureZellijTarget() {
+	if (process.env.ZELLIJ || process.env.ZELLIJ_SESSION_NAME) return;
+	throw new Error("Zellij context not found. Run OpenCode inside Zellij or set ZELLIJ_SESSION_NAME to an existing session.");
+}
+async function runZellij(actionArgs, options = {}) {
+	ensureZellijTarget();
+	try {
+		const result = await execFileAsync("zellij", zellijCommandArgs(actionArgs), {
+			encoding: "utf8",
+			timeout: options.timeoutMs ?? 1e4,
+			maxBuffer: 20 * 1024 * 1024
+		});
+		return {
+			stdout: result.stdout ?? "",
+			stderr: result.stderr ?? ""
+		};
+	} catch (cause) {
+		const error = cause;
+		const stderr = error.stderr?.trim();
+		const stdout = error.stdout?.trim();
+		const detail = stderr || stdout || error.message || "unknown error";
+		throw new Error(`zellij ${actionArgs.join(" ")} failed: ${detail}`);
+	}
+}
+var ZellijCli = class {
+	async newPane(options) {
+		return parsePaneId((await runZellij(buildNewPaneActionArgs(options))).stdout);
+	}
+	async writeChars(paneId, data) {
+		await runZellij(zellijActionArgs("write-chars", [
+			"--pane-id",
+			paneId,
+			data
+		]));
+	}
+	async sendCtrlC(paneId) {
+		await runZellij(zellijActionArgs("send-keys", [
+			"--pane-id",
+			paneId,
+			"Ctrl c"
+		]));
+	}
+	async closePane(paneId) {
+		await runZellij(zellijActionArgs("close-pane", ["--pane-id", paneId]));
+	}
+	async focusPane(paneId) {
+		await runZellij(zellijActionArgs("focus-pane-id", [paneId]));
+	}
+	async dumpScreen(paneId) {
+		return (await runZellij(zellijActionArgs("dump-screen", [
+			"--pane-id",
+			paneId,
+			"--full"
+		]), { timeoutMs: 1e4 })).stdout;
+	}
+};
+const zellijCli = new ZellijCli();
+//#endregion
+//#region src/pty/ring-buffer.ts
+const ansiPattern$1 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[a-z]`, "gi");
+function normalizeLines(input) {
+	const lines = Array.isArray(input) ? input : input.replace(/\r\n/g, "\n").split("\n");
+	if (lines.at(-1) === "") return lines.slice(0, -1);
+	return lines;
+}
+function stripAnsi(line) {
+	return line.replace(ansiPattern$1, "");
+}
+function overlapSize(existing, incoming) {
+	const max = Math.min(existing.length, incoming.length);
+	for (let size = max; size > 0; size -= 1) {
+		const existingStart = existing.length - size;
+		let matches = true;
+		for (let index = 0; index < size; index += 1) if (existing[existingStart + index] !== incoming[index]) {
+			matches = false;
+			break;
+		}
+		if (matches) return size;
+	}
+	return 0;
+}
+var RingBuffer = class {
+	maxLines;
+	lines = [];
+	totalAppended = 0;
+	constructor(maxLines = 5e4) {
+		this.maxLines = Math.max(1, maxLines);
+	}
+	get lineCount() {
+		return this.totalAppended;
+	}
+	get startOffset() {
+		return Math.max(0, this.totalAppended - this.lines.length);
+	}
+	append(input) {
+		const incoming = normalizeLines(input);
+		if (incoming.length === 0) return 0;
+		this.lines.push(...incoming);
+		this.totalAppended += incoming.length;
+		this.trim();
+		return incoming.length;
+	}
+	appendSnapshot(input) {
+		const incoming = normalizeLines(input);
+		if (incoming.length === 0) return 0;
+		const overlap = overlapSize(this.lines, incoming);
+		return this.append(incoming.slice(overlap));
+	}
+	read(input = {}) {
+		const limit = Math.max(1, Math.min(input.limit ?? 200, 5e3));
+		const firstReadableOffset = this.startOffset;
+		const defaultOffset = Math.max(firstReadableOffset, this.lineCount - limit);
+		const requestedOffset = input.offset ?? defaultOffset;
+		const offset = Math.max(firstReadableOffset, Math.min(requestedOffset, this.lineCount));
+		const relativeOffset = offset - firstReadableOffset;
+		const unfiltered = this.lines.slice(relativeOffset, relativeOffset + limit);
+		const pattern = input.grep ? new RegExp(input.grep, input.ignoreCase ? "i" : "") : void 0;
+		const lines = unfiltered.map(stripAnsi).filter((line) => pattern ? pattern.test(line) : true);
+		return {
+			offset,
+			returned: lines.length,
+			lineCount: this.lineCount,
+			lines
+		};
+	}
+	clear() {
+		this.lines = [];
+		this.totalAppended = 0;
+	}
+	trim() {
+		if (this.lines.length <= this.maxLines) return;
+		this.lines = this.lines.slice(this.lines.length - this.maxLines);
+	}
+};
+//#endregion
+//#region src/utils/exit-code.ts
+const markerPattern = /^\[zellij-pty:([a-f0-9]+)\] exit-code=(\d+)$/;
+const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[a-z]`, "gi");
+function createExitCodeToken() {
+	return randomUUID().replaceAll("-", "");
+}
+function parseExitCodeMarker(line) {
+	const match = line.replace(ansiPattern, "").trim().match(markerPattern);
+	if (!match?.[1] || !match[2]) return null;
+	return {
+		token: match[1],
+		exitCode: Number(match[2])
+	};
+}
+//#endregion
+//#region src/zellij/subscribe.ts
+const maxStderrLines = 200;
+function splitLines(input) {
+	const lines = input.replace(/\r\n/g, "\n").split("\n");
+	if (lines.at(-1) === "") return lines.slice(0, -1);
+	return lines;
+}
+function textFromCell(cell) {
+	if (typeof cell === "string") return cell;
+	if (!cell || typeof cell !== "object") return "";
+	const object = cell;
+	const value = object.text ?? object.character ?? object.ch ?? object.content;
+	return typeof value === "string" ? value : "";
+}
+function linesFromRows(rows) {
+	return rows.map((row) => {
+		if (typeof row === "string") return row;
+		if (Array.isArray(row)) return row.map(textFromCell).join("");
+		return textFromCell(row);
+	});
+}
+function eventPaneId(event) {
+	const paneId = event.pane_id ?? event.paneId;
+	return typeof paneId === "string" ? paneId : void 0;
+}
+function eventType(event) {
+	const type = event.event ?? event.type;
+	return typeof type === "string" ? type : void 0;
+}
+function extractRenderedLines(event) {
+	for (const key of [
+		"viewport",
+		"scrollback",
+		"lines"
+	]) {
+		const value = event[key];
+		if (Array.isArray(value)) return linesFromRows(value);
+	}
+	for (const key of [
+		"text",
+		"output",
+		"content"
+	]) {
+		const value = event[key];
+		if (typeof value === "string") return splitLines(value);
+	}
+	return [];
+}
+var SubscriberManager = class {
+	subscribers = /* @__PURE__ */ new Map();
+	constructor(sessions, maxBufferLines = Number(process.env.PTY_MAX_BUFFER_LINES ?? 5e4)) {
+		this.sessions = sessions;
+		this.maxBufferLines = maxBufferLines;
+	}
+	async start(session) {
+		const existing = this.subscribers.get(session.id);
+		if (existing?.child) return;
+		ensureZellijTarget();
+		const state = existing ?? {
+			child: null,
+			buffer: new RingBuffer(this.maxBufferLines),
+			stderr: [],
+			stdoutRemainder: "",
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			lastExitedAt: null
+		};
+		if (!existing) {
+			try {
+				state.buffer.appendSnapshot(await zellijCli.dumpScreen(session.paneId));
+				this.sessions.updateLineCount(session.id, state.buffer.lineCount);
+			} catch {}
+			this.subscribers.set(session.id, state);
+		}
+		const child = spawn("zellij", zellijCommandArgs([
+			"subscribe",
+			"--pane-id",
+			session.paneId,
+			"--scrollback",
+			"--format",
+			"json",
+			"--ansi"
+		]), { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		child.stdin.end();
+		state.child = child;
+		state.lastExitedAt = null;
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => this.handleStdout(session.id, chunk));
+		child.stderr.setEncoding("utf8");
+		child.stderr.on("data", (chunk) => this.handleStderr(session.id, chunk));
+		child.on("exit", () => this.handleSubscriberExit(session.id));
+		child.on("error", (error) => this.handleSubscriberError(session.id, error));
+	}
+	read(sessionId, input) {
+		const state = this.subscribers.get(sessionId);
+		if (!state) throw new Error(`No subscriber buffer exists for session: ${sessionId}`);
+		return state.buffer.read(input);
+	}
+	has(sessionId) {
+		return this.subscribers.has(sessionId);
+	}
+	status(sessionId) {
+		const state = this.subscribers.get(sessionId);
+		return {
+			hasBuffer: Boolean(state),
+			active: Boolean(state?.child),
+			lastExitedAt: state?.lastExitedAt ?? null
+		};
+	}
+	stderr(sessionId) {
+		return this.subscribers.get(sessionId)?.stderr ?? [];
+	}
+	stop(sessionId) {
+		const state = this.subscribers.get(sessionId);
+		if (!state) return;
+		state.child?.kill("SIGTERM");
+		state.child = null;
+		state.lastExitedAt = (/* @__PURE__ */ new Date()).toISOString();
+	}
+	forget(sessionId) {
+		this.stop(sessionId);
+		this.subscribers.delete(sessionId);
+	}
+	stopAll() {
+		for (const sessionId of this.subscribers.keys()) this.forget(sessionId);
+	}
+	async closeSessionPane(sessionId) {
+		const session = this.sessions.get(sessionId);
+		this.stop(sessionId);
+		try {
+			await zellijCli.closePane(session.paneId);
+		} catch {}
+	}
+	handleStdout(sessionId, chunk) {
+		const state = this.subscribers.get(sessionId);
+		if (!state) return;
+		const parts = `${state.stdoutRemainder}${chunk}`.split("\n");
+		state.stdoutRemainder = parts.pop() ?? "";
+		for (const part of parts) this.handleJsonLine(sessionId, part);
+	}
+	handleJsonLine(sessionId, line) {
+		const state = this.subscribers.get(sessionId);
+		if (!state) return;
+		const trimmed = line.trim();
+		if (!trimmed) return;
+		let event;
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (!parsed || typeof parsed !== "object") return;
+			event = parsed;
+		} catch {
+			state.buffer.append(trimmed);
+			this.sessions.updateLineCount(sessionId, state.buffer.lineCount);
+			return;
+		}
+		const session = this.sessions.get(sessionId);
+		const paneId = eventPaneId(event);
+		if (paneId && paneId !== session.paneId) return;
+		const type = eventType(event);
+		if (type === "pane_closed" || type === "PaneClosed") {
+			state.buffer.append(`[zellij-pty] Pane ${session.paneId} closed at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+			this.sessions.updateLineCount(sessionId, state.buffer.lineCount);
+			this.sessions.updateStatus(sessionId, session.status === "killed" ? "killed" : "exited");
+			this.stop(sessionId);
+			return;
+		}
+		const lines = extractRenderedLines(event);
+		if (lines.length === 0) return;
+		state.buffer.appendSnapshot(lines);
+		this.captureExitCode(sessionId, lines);
+		this.sessions.updateLineCount(sessionId, state.buffer.lineCount);
+	}
+	captureExitCode(sessionId, lines) {
+		const session = this.sessions.get(sessionId);
+		if (!session.exitCodeToken) return;
+		for (const line of lines) {
+			const marker = parseExitCodeMarker(line);
+			if (!marker || marker.token !== session.exitCodeToken) continue;
+			this.sessions.markExited(sessionId, marker.exitCode);
+			return;
+		}
+	}
+	handleStderr(sessionId, chunk) {
+		const state = this.subscribers.get(sessionId);
+		if (!state) return;
+		state.stderr.push(...splitLines(chunk));
+		if (state.stderr.length > maxStderrLines) state.stderr = state.stderr.slice(state.stderr.length - maxStderrLines);
+	}
+	handleSubscriberExit(sessionId) {
+		const state = this.subscribers.get(sessionId);
+		if (!state) return;
+		state.child = null;
+		state.lastExitedAt = (/* @__PURE__ */ new Date()).toISOString();
+		state.stderr.push(`[zellij-pty] subscriber exited at ${state.lastExitedAt}; last buffered output is retained.`);
+		if (state.stderr.length > maxStderrLines) state.stderr = state.stderr.slice(state.stderr.length - maxStderrLines);
+	}
+	handleSubscriberError(sessionId, error) {
+		const state = this.subscribers.get(sessionId);
+		if (state) state.stderr.push(error.message);
+		this.sessions.updateStatus(sessionId, "unknown");
+	}
+};
+const subscriberManager = new SubscriberManager(sessionManager);
+//#endregion
+//#region src/tools/format.ts
+function publicSession(session) {
+	return {
+		id: session.id,
+		paneId: session.paneId,
+		title: session.title,
+		command: session.command,
+		args: session.args,
+		cwd: session.cwd,
+		status: session.status,
+		lineCount: session.lineCount,
+		createdAt: session.createdAt,
+		updatedAt: session.updatedAt,
+		agentWritable: session.allowAgentInput,
+		humanInputOnly: session.humanInputOnly,
+		exitCode: session.exitCode,
+		exitedAt: session.exitedAt
+	};
+}
+function nextAdvice(retryable, reason) {
+	return {
+		retryable,
+		reason
+	};
+}
+function jsonResponse(value) {
+	return JSON.stringify(value, null, 2);
+}
+//#endregion
+//#region src/tools/output.ts
+function emptyOutputSnapshot(lineCount = 0) {
+	return {
+		text: "",
+		lines: [],
+		lineCount,
+		returned: 0,
+		truncated: false
+	};
+}
+function validateGrep(grep) {
+	if (!grep) return null;
+	try {
+		new RegExp(grep).test("");
+		return null;
+	} catch (error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+}
+function readOutputSnapshot(sessionId, options = {}) {
+	const grepError = validateGrep(options.grep);
+	if (grepError) throw new Error(`Invalid grep regex: ${grepError}`);
+	const buffered = subscriberManager.read(sessionId, {
+		limit: options.maxLines,
+		grep: options.grep,
+		ignoreCase: options.ignoreCase
+	});
+	sessionManager.updateLineCount(sessionId, buffered.lineCount);
+	return {
+		text: buffered.lines.join("\n"),
+		lines: buffered.lines,
+		lineCount: buffered.lineCount,
+		returned: buffered.returned,
+		truncated: buffered.offset > 0
+	};
+}
+function outputMatches(sessionId, grep, ignoreCase) {
+	return readOutputSnapshot(sessionId, {
+		maxLines: 5e3,
+		grep,
+		ignoreCase
+	}).returned > 0;
+}
+//#endregion
+//#region src/tools/kill.ts
+const schema$4 = tool.schema;
+function closeFailureMeansGone(message) {
+	return /not found|no such|does not exist|already closed|already gone|unknown pane/i.test(message);
+}
+const zellijPtyKillTool = tool({
+	description: "Terminate a known Zellij PTY session by sending Ctrl-C, then closing its pane.",
+	args: { id: schema$4.string().describe("zellij-pty session id.") },
+	async execute(args) {
+		const session = sessionManager.get(args.id);
+		const warnings = [];
+		const output = subscriberManager.has(session.id) ? readOutputSnapshot(session.id) : void 0;
+		try {
+			await zellijCli.sendCtrlC(session.paneId);
+			await setTimeout(500);
+		} catch (error) {
+			warnings.push(`Ctrl-C failed or pane was already gone: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		try {
+			await zellijCli.closePane(session.paneId);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			warnings.push(`close-pane failed: ${message}`);
+			if (!closeFailureMeansGone(message)) return jsonResponse({
+				killed: false,
+				cleanedUp: false,
+				session: publicSession(sessionManager.updateStatus(session.id, "unknown")),
+				output,
+				next: nextAdvice(true, "close-pane failed and the pane may still be running; the session was kept so kill can be retried."),
+				warnings
+			});
+		}
+		subscriberManager.stop(session.id);
+		subscriberManager.forget(session.id);
+		sessionManager.remove(session.id);
+		return jsonResponse({
+			killed: true,
+			cleanedUp: true,
+			id: session.id,
+			paneId: session.paneId,
+			output,
+			next: nextAdvice(false, "Session was closed and removed from the in-memory registry."),
+			warnings
+		});
+	}
+});
+//#endregion
+//#region src/tools/list.ts
+const zellijPtyListTool = tool({
+	description: "List known Zellij pane-backed PTY sessions created by this plugin process for the current OpenCode session.",
+	args: {},
+	async execute(_args, context) {
+		return jsonResponse({ sessions: sessionManager.listByOpenCodeSession(context.sessionID).map((session) => ({
+			...publicSession(session),
+			subscriber: subscriberManager.status(session.id)
+		})) });
+	}
+});
+//#endregion
+//#region src/tools/read.ts
+const schema$3 = tool.schema;
+const zellijPtyReadTool = tool({
+	description: "Read recent rendered output from a Zellij PTY session. Supports regex grep filtering.",
+	args: {
+		id: schema$3.string().describe("zellij-pty session id."),
+		maxLines: schema$3.number().int().positive().max(5e3).optional().describe("Maximum recent output lines to return. Defaults to 200."),
+		grep: schema$3.string().optional().describe("Regex used to filter returned lines."),
+		ignoreCase: schema$3.boolean().optional().describe("Use case-insensitive regex matching.")
+	},
+	async execute(args) {
+		const session = sessionManager.get(args.id);
+		const grepError = validateGrep(args.grep);
+		if (grepError) return jsonResponse({
+			session: publicSession(session),
+			output: {
+				text: "",
+				lines: [],
+				lineCount: session.lineCount,
+				returned: 0,
+				truncated: false
+			},
+			next: nextAdvice(false, `Invalid grep regex: ${grepError}`),
+			warnings: []
+		});
+		if (!subscriberManager.has(session.id)) await subscriberManager.start(session);
+		const subscriberStatus = subscriberManager.status(session.id);
+		const warnings = [];
+		if (session.humanInputOnly) warnings.push("This pane is human-input-only: agent writes are forbidden, but rendered output is visible to the agent.");
+		if (!subscriberStatus.active) {
+			warnings.push("Subscriber is inactive; returned output may be stale.");
+			if (session.status === "running") sessionManager.updateStatus(session.id, "unknown");
+		}
+		const output = readOutputSnapshot(session.id, {
+			maxLines: args.maxLines,
+			grep: args.grep,
+			ignoreCase: args.ignoreCase
+		});
+		return jsonResponse({
+			session: publicSession(session),
+			output,
+			next: nextAdvice(session.status !== "exited" && session.status !== "killed", nextReadReason(session.status)),
+			subscriberActive: subscriberStatus.active,
+			subscriberLastExitedAt: subscriberStatus.lastExitedAt,
+			subscriberErrors: subscriberManager.stderr(session.id),
+			warnings
+		});
+	}
+});
+function nextReadReason(status) {
+	if (status === "running") return "Session is still running; read again later if more output is expected.";
+	if (status === "unknown") return "Session state is unknown because the subscriber is inactive; output may be stale, but retrying read may restart observation.";
+	return "Session is no longer running.";
+}
+//#endregion
+//#region src/utils/pane-title.ts
+const generatedInstanceId = randomUUID().replaceAll("-", "").slice(0, 8);
+const existingOpenCodePrefixPattern = /^oc:[a-z0-9]{4,16}:/i;
+function createOpenCodePaneTitle(title, instanceId = generatedInstanceId) {
+	const trimmedTitle = title.trim() || "opencode";
+	if (existingOpenCodePrefixPattern.test(trimmedTitle)) return trimmedTitle;
+	return `oc:${instanceId.replace(/[^a-z0-9]/gi, "").slice(0, 8) || generatedInstanceId}:${trimmedTitle}`;
+}
+//#endregion
+//#region src/tools/request-sudo.ts
+const schema$2 = tool.schema;
+function shellQuote(value) {
+	return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function buildReviewScript(summary, scripts) {
+	const lines = [
+		"set +e",
+		"printf '%s\\n' '=== OpenCode sudo request ==='",
+		`printf '%s\\n' ${shellQuote(summary)}`,
+		"printf '\\n%s\\n' 'Commands to review:'"
+	];
+	scripts.forEach((script, index) => {
+		const number = index + 1;
+		lines.push(`printf '\\n[%s/%s] %s\\n' ${shellQuote(String(number))} ${shellQuote(String(scripts.length))} ${shellQuote(script.description)}`);
+		lines.push(`printf '  $ %s\\n' ${shellQuote(script.command)}`);
+	});
+	lines.push("printf '\\n%s\\n' 'This pane is human-input-only. The agent cannot type here.'", "read -r -p 'Type YES to run these commands, anything else to cancel: ' answer", "if [ \"$answer\" != YES ]; then printf '%s\\n' 'Cancelled by user.'; exit 130; fi", "status=0");
+	scripts.forEach((script, index) => {
+		const number = index + 1;
+		lines.push(`printf '\\n[%s/%s] %s\\n' ${shellQuote(String(number))} ${shellQuote(String(scripts.length))} ${shellQuote(script.description)}`);
+		lines.push(`printf '$ %s\\n' ${shellQuote(script.command)}`);
+		lines.push(`bash -lc ${shellQuote(script.command)}`);
+		lines.push("code=$?");
+		lines.push("if [ $code -ne 0 ]; then status=$code; printf 'Command failed with exit code %s\\n' \"$code\"; break; fi");
+	});
+	lines.push("exit $status");
+	return lines.join("\n");
+}
+const requestSudoTool = tool({
+	description: "Open a human-reviewed, human-input-only Zellij pane for sudo or other privileged commands.",
+	args: {
+		summary: schema$2.string().min(1).describe("TL;DR of why privileged or human-reviewed execution is needed."),
+		scripts: schema$2.array(schema$2.object({
+			command: schema$2.string().min(1).describe("Command or script to run after the user explicitly approves in the pane."),
+			description: schema$2.string().min(1).describe("Why this command is needed and what it is expected to change.")
+		})).min(1).describe("Commands shown to the user for review before execution.")
+	},
+	async execute(args, context) {
+		const cwd = context.directory;
+		const exitCodeToken = createExitCodeToken();
+		for (const script of args.scripts) assertCommandAllowed({
+			command: script.command,
+			humanInputOnly: true
+		});
+		const command = buildReviewScript(args.summary, args.scripts);
+		const title = createOpenCodePaneTitle("request_sudo");
+		const paneId = await zellijCli.newPane({
+			command: "bash",
+			args: ["-lc", command],
+			cwd,
+			title,
+			floating: true,
+			exitCodeToken
+		});
+		const warnings = [];
+		try {
+			await zellijCli.focusPane(paneId);
+		} catch (error) {
+			if (!(error instanceof Error ? error.message : String(error)).includes("already focused")) throw error;
+			warnings.push("Pane was already focused after creation.");
+		}
+		const session = sessionManager.create({
+			openCodeSessionId: context.sessionID,
+			paneId,
+			title,
+			command: "request_sudo",
+			args: [],
+			cwd,
+			allowAgentInput: false,
+			humanInputOnly: true,
+			exitCodeToken
+		});
+		await subscriberManager.start(session);
+		return jsonResponse({
+			session: publicSession(session),
+			output: readOutputSnapshot(session.id),
+			next: nextAdvice(false, "The user must review the summary and commands in Zellij, then type YES and any required credentials directly in the pane."),
+			warnings
+		});
+	}
+});
+//#endregion
+//#region src/pty/probe.ts
+const defaultSleepSeconds = 1;
+const defaultProbeTimeoutSeconds = 20;
+const pollIntervalMs = 250;
+async function runProbe(probe, outputReader) {
+	const startedAt = Date.now();
+	const effectiveProbe = probe ?? {
+		type: "sleep",
+		seconds: defaultSleepSeconds
+	};
+	if (effectiveProbe.type === "sleep") {
+		const seconds = effectiveProbe.seconds ?? defaultSleepSeconds;
+		await setTimeout(seconds * 1e3);
+		return result(effectiveProbe.type, true, `Slept for ${seconds}s.`, startedAt);
+	}
+	if (effectiveProbe.type === "output") {
+		const timeoutSeconds = effectiveProbe.timeoutSeconds ?? defaultProbeTimeoutSeconds;
+		const deadline = Date.now() + timeoutSeconds * 1e3;
+		while (Date.now() <= deadline) {
+			if (outputReader(effectiveProbe.grep, effectiveProbe.ignoreCase)) return result(effectiveProbe.type, true, `Observed output matching /${effectiveProbe.grep}/.`, startedAt);
+			await setTimeout(pollIntervalMs);
+		}
+		return result(effectiveProbe.type, false, `Timed out after ${timeoutSeconds}s waiting for output matching /${effectiveProbe.grep}/.`, startedAt);
+	}
+	const timeoutSeconds = effectiveProbe.timeoutSeconds ?? defaultProbeTimeoutSeconds;
+	const deadline = Date.now() + timeoutSeconds * 1e3;
+	const expectStatus = effectiveProbe.expectStatus;
+	let lastError = "no response";
+	while (Date.now() <= deadline) {
+		try {
+			const remainingMs = Math.max(1, deadline - Date.now());
+			const response = await fetch(effectiveProbe.url, { signal: AbortSignal.timeout(Math.min(remainingMs, 3e3)) });
+			if (expectStatus === void 0 ? response.status >= 200 && response.status < 400 : response.status === expectStatus) {
+				const expected = expectStatus === void 0 ? "2xx/3xx" : String(expectStatus);
+				return result(effectiveProbe.type, true, `HTTP probe ${effectiveProbe.url} returned expected status ${expected}.`, startedAt);
+			}
+			lastError = `HTTP ${response.status}`;
+		} catch (error) {
+			lastError = error instanceof Error ? error.message : String(error);
+		}
+		await setTimeout(pollIntervalMs);
+	}
+	return result(effectiveProbe.type, false, `Timed out after ${timeoutSeconds}s probing ${effectiveProbe.url}: ${lastError}.`, startedAt);
+}
+function result(type, ok, message, startedAt) {
+	return {
+		type,
+		ok,
+		message,
+		elapsedMs: Date.now() - startedAt
+	};
+}
+//#endregion
+//#region src/tools/spawn.ts
+const schema$1 = tool.schema;
+const probeSchema = schema$1.discriminatedUnion("type", [
+	schema$1.object({
+		type: schema$1.literal("sleep"),
+		seconds: schema$1.number().positive().max(300).optional().describe("Seconds to wait before returning initial output. Defaults to 1.")
+	}),
+	schema$1.object({
+		type: schema$1.literal("http"),
+		url: schema$1.string().url().describe("HTTP URL to poll until it returns the expected status."),
+		expectStatus: schema$1.number().int().min(100).max(599).optional().describe("Expected HTTP status. Defaults to any 2xx/3xx response."),
+		timeoutSeconds: schema$1.number().positive().max(300).optional().describe("How long to poll before returning a failed probe result. Defaults to 20.")
+	}),
+	schema$1.object({
+		type: schema$1.literal("output"),
+		grep: schema$1.string().describe("Regex to search for in observed pane output."),
+		ignoreCase: schema$1.boolean().optional().describe("Use case-insensitive regex matching."),
+		timeoutSeconds: schema$1.number().positive().max(300).optional().describe("How long to wait for matching output. Defaults to 20.")
+	})
+]);
+const zellijPtySpawnTool = tool({
+	description: "Create a visible Zellij pane and run a command in it.",
+	args: {
+		command: schema$1.string().describe("Command to run. Without args, it is executed through bash -lc."),
+		args: schema$1.array(schema$1.string()).optional().describe("Optional argv. When provided, command is executed directly without shell parsing."),
+		cwd: schema$1.string().optional().describe("Working directory for the new pane."),
+		title: schema$1.string().optional().describe("Pane title/name."),
+		probe: probeSchema.optional().describe("Optional readiness probe. Defaults to a short sleep before returning output."),
+		maxLines: schema$1.number().int().positive().max(5e3).optional().describe("Maximum recent output lines to return. Defaults to 200.")
+	},
+	async execute(args, context) {
+		const cwd = args.cwd ?? context.directory;
+		const exitCodeToken = createExitCodeToken();
+		assertCommandAllowed({
+			command: args.command,
+			args: args.args,
+			humanInputOnly: false
+		});
+		const grepError = args.probe?.type === "output" ? validateGrep(args.probe.grep) : null;
+		if (grepError) throw new Error(`Invalid probe.grep regex: ${grepError}`);
+		const title = createOpenCodePaneTitle(args.title ?? args.command);
+		const paneId = await zellijCli.newPane({
+			command: args.command,
+			args: args.args,
+			cwd,
+			title,
+			floating: false,
+			exitCodeToken
+		});
+		const session = sessionManager.create({
+			openCodeSessionId: context.sessionID,
+			paneId,
+			title,
+			command: args.command,
+			args: args.args,
+			cwd,
+			allowAgentInput: true,
+			humanInputOnly: false,
+			exitCodeToken
+		});
+		await subscriberManager.start(session);
+		const probe = await runProbe(args.probe, (grep, ignoreCase) => outputMatches(session.id, grep, ignoreCase));
+		const output = readOutputSnapshot(session.id, { maxLines: args.maxLines });
+		return jsonResponse({
+			session: publicSession(session),
+			output,
+			probe,
+			next: nextAdvice(probe.ok, probe.ok ? "Probe completed; continue with this session or read later for long-running output." : probe.message),
+			warnings: ["Registry remains in-memory; restarting OpenCode loses plugin session records."]
+		});
+	}
+});
+//#endregion
+//#region src/pty/write-data.ts
+const defaultMaxWriteBytes = 64 * 1024;
+const defaultChunkBytes = 8 * 1024;
+function maxWriteBytes() {
+	const configured = Number(process.env.ZELLIJ_PTY_MAX_WRITE_BYTES ?? defaultMaxWriteBytes);
+	return Number.isFinite(configured) && configured > 0 ? configured : defaultMaxWriteBytes;
+}
+function assertWriteSizeAllowed(data) {
+	const bytes = Buffer.byteLength(data, "utf8");
+	const maxBytes = maxWriteBytes();
+	if (bytes > maxBytes) throw new Error(`Write payload is too large: ${bytes} bytes exceeds ${maxBytes} bytes. Split the input into smaller writes.`);
+}
+function chunkWriteData(data, maxChunkBytes = defaultChunkBytes) {
+	const chunks = [];
+	let current = "";
+	let currentBytes = 0;
+	for (const character of data) {
+		const characterBytes = Buffer.byteLength(character, "utf8");
+		if (current && currentBytes + characterBytes > maxChunkBytes) {
+			chunks.push(current);
+			current = "";
+			currentBytes = 0;
+		}
+		current += character;
+		currentBytes += characterBytes;
+	}
+	if (current) chunks.push(current);
+	return chunks;
+}
+//#endregion
+//#region src/tools/write.ts
+const schema = tool.schema;
+const zellijPtyWriteTool = tool({
+	description: "Write stdin to a Zellij PTY session. Refuses human-input-only sessions.",
+	args: {
+		id: schema.string().describe("zellij-pty session id returned by zellij_pty_spawn or request_sudo."),
+		data: schema.string().describe("Text to write. Use  to send Ctrl-C."),
+		maxLines: schema.number().int().positive().max(5e3).optional().describe("Maximum recent output lines to return. Defaults to 200."),
+		interruptAfterSeconds: schema.number().positive().max(300).optional().describe("Blindly send Ctrl-C after this many seconds if the pane is still running; keeps the pane alive.")
+	},
+	async execute(args) {
+		const session = sessionManager.get(args.id);
+		if (session.humanInputOnly || !session.allowAgentInput) return jsonResponse({
+			session: publicSession(session),
+			output: subscriberManager.has(session.id) ? readOutputSnapshot(session.id, { maxLines: args.maxLines }) : emptyOutputSnapshot(session.lineCount),
+			next: nextAdvice(false, "This session is human-input-only; the user must type directly in the Zellij pane."),
+			warnings: ["Agent writes to human-input-only sessions are forbidden."]
+		});
+		if (args.data === "" || args.data === "") await zellijCli.sendCtrlC(session.paneId);
+		else {
+			assertWriteSizeAllowed(args.data);
+			for (const chunk of chunkWriteData(args.data)) await zellijCli.writeChars(session.paneId, chunk);
+		}
+		session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		if (args.interruptAfterSeconds) {
+			await setTimeout(args.interruptAfterSeconds * 1e3);
+			if (sessionManager.get(session.id).status === "running") {
+				await zellijCli.sendCtrlC(session.paneId);
+				await setTimeout(500);
+			}
+		} else await setTimeout(1e3);
+		return jsonResponse({
+			session: publicSession(session),
+			output: readOutputSnapshot(session.id, { maxLines: args.maxLines }),
+			next: nextAdvice(true, args.interruptAfterSeconds ? "Input was sent; Ctrl-C was sent after the requested interrupt timeout if the session was still running." : "Input was sent and recent output was observed."),
+			warnings: []
+		});
+	}
+});
+//#endregion
+//#region src/plugin.ts
+const ZellijPtyPlugin = async (_input, options) => {
+	configurePolicy(options?.zellijPty ?? options);
+	return {
+		async event(input) {
+			if (input.event.type === "session.deleted") {
+				const sessions = sessionManager.listByOpenCodeSession(input.event.properties.info.id);
+				await Promise.all(sessions.map(async (session) => {
+					await subscriberManager.closeSessionPane(session.id);
+					subscriberManager.forget(session.id);
+					sessionManager.remove(session.id);
+				}));
+			}
+		},
+		tool: {
+			zellij_pty_spawn: zellijPtySpawnTool,
+			zellij_pty_list: zellijPtyListTool,
+			zellij_pty_write: zellijPtyWriteTool,
+			zellij_pty_read: zellijPtyReadTool,
+			zellij_pty_kill: zellijPtyKillTool,
+			request_sudo: requestSudoTool
+		}
+	};
+};
+//#endregion
+export { ZellijPtyPlugin, ZellijPtyPlugin as default };
+
+//# sourceMappingURL=index.mjs.map