editprompt 1.5.0 → 1.7.0

package/dist/index.js

@@ -2,15 +2,33 @@
 import { configureSync, getAnsiColorFormatter, getLogger, getTextFormatter, parseLogLevel, withFilter } from "@logtape/logtape";
 import { cli, define } from "gunshi";
 import { appendFileSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { createConnection } from "node:net";
+import Conf from "conf";
 import { exec, spawn } from "node:child_process";
 import { promisify } from "node:util";
-import Conf from "conf";
 import clipboardy from "clipboardy";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { randomBytes } from "node:crypto";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
 //#region src/modules/logger.ts
 function resolveLogFilePath(options) {
 	if (options.logFile) return options.logFile;
@@ -72,7 +90,7 @@ function setupLogger(options = {}) {
 
 //#endregion
 //#region package.json
-var version = "1.5.0";
+var version = "1.7.0";
 
 //#endregion
 //#region src/config/constants.ts
@@ -82,6 +100,9 @@ const DEFAULT_EDITOR = "vim";
 const TMUX_IMSG_LIMIT_BYTES = 16 * 1024;
 const TMUX_SEND_CHUNK_BYTES = TMUX_IMSG_LIMIT_BYTES / 2;
 const WEZTERM_SEND_CHUNK_BYTES = TMUX_SEND_CHUNK_BYTES;
+const HERDR_REQUEST_LIMIT_BYTES = 1024 * 1024;
+const HERDR_SEND_CHUNK_BYTES = HERDR_REQUEST_LIMIT_BYTES / 8;
+const NIWATERM_SEND_CHUNK_BYTES = WEZTERM_SEND_CHUNK_BYTES;
 
 //#endregion
 //#region src/utils/contentChunker.ts
@@ -111,10 +132,368 @@ function splitByByteSize(content, maxBytes) {
 	return chunks;
 }
 
+//#endregion
+//#region src/modules/conf.ts
+const projectName = process.env.NODE_ENV === "test" ? "editprompt-test" : "editprompt";
+const conf = new Conf({ projectName });
+
+//#endregion
+//#region src/modules/herdr.ts
+var herdr_exports = /* @__PURE__ */ __exportAll({
+	appendToQuoteText: () => appendToQuoteText$1,
+	calculateEditorSplitRatio: () => calculateEditorSplitRatio,
+	checkPaneExists: () => checkPaneExists$3,
+	clearEditorPaneId: () => clearEditorPaneId$3,
+	clearQuoteText: () => clearQuoteText$1,
+	closePane: () => closePane,
+	focusPane: () => focusPane$3,
+	getCurrentPaneId: () => getCurrentPaneId$3,
+	getEditorPaneId: () => getEditorPaneId$3,
+	getQuoteText: () => getQuoteText$1,
+	getStorageNamespace: () => getStorageNamespace,
+	getTargetPaneIds: () => getTargetPaneIds$3,
+	inputToHerdrPane: () => inputToHerdrPane,
+	isEditorPaneFromConf: () => isEditorPaneFromConf$1,
+	markAsEditorPane: () => markAsEditorPane$3,
+	resumeEditorPane: () => resumeEditorPane,
+	runCommandInPane: () => runCommandInPane,
+	saveEditorPaneId: () => saveEditorPaneId$3,
+	sendKeyToHerdrPane: () => sendKeyToHerdrPane,
+	splitEditorPane: () => splitEditorPane
+});
+const logger$14 = getLogger(["editprompt", "herdr"]);
+const HERDR_REQUEST_TIMEOUT_MS = 6e3;
+let requestSequence = 0;
+function getSocketPath() {
+	const socketPath = process.env.HERDR_SOCKET_PATH?.trim();
+	if (!socketPath) throw new Error("HERDR_SOCKET_PATH is not set");
+	return socketPath;
+}
+async function sendRequest(method, params) {
+	const id = `editprompt_${process.pid}_${++requestSequence}`;
+	const request = `${JSON.stringify({
+		id,
+		method,
+		params
+	})}\n`;
+	return new Promise((resolve, reject) => {
+		const socket = createConnection(getSocketPath());
+		let buffer = "";
+		let settled = false;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			socket.end();
+			callback();
+		};
+		socket.setEncoding("utf8");
+		socket.setTimeout(HERDR_REQUEST_TIMEOUT_MS);
+		socket.on("connect", () => {
+			socket.write(request);
+		});
+		socket.on("data", (chunk) => {
+			buffer += chunk;
+			const newlineIndex = buffer.indexOf("\n");
+			if (newlineIndex === -1) return;
+			const line = buffer.slice(0, newlineIndex);
+			let response;
+			try {
+				response = JSON.parse(line);
+			} catch (error) {
+				finish(() => {
+					reject(/* @__PURE__ */ new Error(`Invalid response from Herdr: ${error instanceof Error ? error.message : "Unknown error"}`));
+				});
+				return;
+			}
+			if (response.id !== id) {
+				finish(() => {
+					reject(/* @__PURE__ */ new Error(`Unexpected response ID from Herdr: ${response.id}`));
+				});
+				return;
+			}
+			if (response.error) {
+				finish(() => {
+					reject(/* @__PURE__ */ new Error(`Herdr ${response.error?.code}: ${response.error?.message}`));
+				});
+				return;
+			}
+			finish(() => {
+				resolve(response.result);
+			});
+		});
+		socket.on("error", (error) => {
+			finish(() => {
+				reject(/* @__PURE__ */ new Error(`Failed to communicate with Herdr: ${error.message}`));
+			});
+		});
+		socket.on("timeout", () => {
+			if (settled) return;
+			settled = true;
+			socket.destroy();
+			reject(/* @__PURE__ */ new Error(`Timed out waiting for Herdr response after ${HERDR_REQUEST_TIMEOUT_MS}ms`));
+		});
+		socket.on("end", () => {
+			if (!settled) finish(() => {
+				reject(/* @__PURE__ */ new Error("Herdr closed the socket before sending a response"));
+			});
+		});
+	});
+}
+function getStorageNamespace() {
+	return `herdr.session_${createHash("sha256").update(getSocketPath()).digest("hex").slice(0, 16)}`;
+}
+function targetPaneKey(paneId) {
+	return `${getStorageNamespace()}.targetPane.pane_${paneId}`;
+}
+function editorPaneKey(paneId) {
+	return `${getStorageNamespace()}.editorPane.pane_${paneId}`;
+}
+async function getCurrentPaneId$3() {
+	const paneId = process.env.HERDR_PANE_ID?.trim() || process.env.HERDR_ACTIVE_PANE_ID?.trim();
+	if (!paneId) throw new Error("HERDR_PANE_ID or HERDR_ACTIVE_PANE_ID is not set");
+	return paneId;
+}
+async function checkPaneExists$3(paneId) {
+	try {
+		await sendRequest("pane.get", { pane_id: paneId });
+		return true;
+	} catch (error) {
+		logger$14.debug("checkPaneExists failed: {error}", { error });
+		return false;
+	}
+}
+async function focusPane$3(paneId) {
+	await sendRequest("pane.focus", { pane_id: paneId });
+}
+function calculateEditorSplitRatio(paneHeight, editorPaneRows) {
+	if (!Number.isInteger(paneHeight) || paneHeight <= 1) throw new Error(`Invalid Herdr pane height: ${paneHeight}`);
+	if (!Number.isInteger(editorPaneRows) || editorPaneRows <= 0) throw new Error(`Invalid Herdr editor pane rows: ${editorPaneRows}`);
+	return Math.min(.9, Math.max(.1, 1 - editorPaneRows / paneHeight));
+}
+async function splitEditorPane(targetPaneId, editorPaneRows, cwd, env = {}) {
+	const paneHeight = ((await sendRequest("pane.layout", { pane_id: targetPaneId })).layout?.panes?.find((pane) => pane.pane_id === targetPaneId))?.rect?.height;
+	if (typeof paneHeight !== "number") throw new Error(`Herdr pane.layout did not return a height for pane ${targetPaneId}`);
+	const params = {
+		target_pane_id: targetPaneId,
+		direction: "down",
+		ratio: calculateEditorSplitRatio(paneHeight, editorPaneRows),
+		focus: true,
+		env
+	};
+	if (cwd?.trim()) params.cwd = cwd;
+	const editorPaneId = (await sendRequest("pane.split", params)).pane?.pane_id;
+	if (typeof editorPaneId !== "string" || editorPaneId === "") throw new Error("Herdr pane.split did not return the new pane ID");
+	return editorPaneId;
+}
+function quoteShellWord$1(value) {
+	return `'${value.replace(/'/g, "'\\''")}'`;
+}
+async function runCommandInPane(paneId, argv) {
+	if (argv.length === 0) throw new Error("Cannot run an empty command in a Herdr pane");
+	await sendRequest("pane.send_input", {
+		pane_id: paneId,
+		text: `exec ${argv.map(quoteShellWord$1).join(" ")}`,
+		keys: ["Enter"]
+	});
+}
+async function closePane(paneId) {
+	await sendRequest("pane.close", { pane_id: paneId });
+}
+async function inputToHerdrPane(paneId, content) {
+	const chunks = splitByByteSize(content, HERDR_SEND_CHUNK_BYTES);
+	for (const chunk of chunks) await sendRequest("pane.send_text", {
+		pane_id: paneId,
+		text: chunk
+	});
+	logger$14.debug("Content sent to Herdr pane: {paneId} ({chunkCount} chunks)", {
+		paneId,
+		chunkCount: chunks.length
+	});
+}
+async function sendKeyToHerdrPane(paneId, key, delay = 1e3) {
+	await new Promise((resolve) => setTimeout(resolve, delay));
+	await sendRequest("pane.send_keys", {
+		pane_id: paneId,
+		keys: [key]
+	});
+}
+async function saveEditorPaneId$3(targetPaneId, editorPaneId) {
+	const data = conf.get(targetPaneKey(targetPaneId));
+	const existing = typeof data === "object" && data !== null ? data : {};
+	conf.set(targetPaneKey(targetPaneId), {
+		...existing,
+		editorPaneId
+	});
+}
+async function getEditorPaneId$3(targetPaneId) {
+	const data = conf.get(targetPaneKey(targetPaneId));
+	if (typeof data === "object" && data !== null && "editorPaneId" in data) return String(data.editorPaneId);
+	return "";
+}
+async function clearEditorPaneId$3(targetPaneId, expectedEditorPaneId) {
+	const editorPaneId = await getEditorPaneId$3(targetPaneId);
+	if (expectedEditorPaneId && editorPaneId !== expectedEditorPaneId) {
+		conf.delete(editorPaneKey(expectedEditorPaneId));
+		return;
+	}
+	const data = conf.get(targetPaneKey(targetPaneId));
+	if (typeof data === "object" && data !== null && "editorPaneId" in data) {
+		const { editorPaneId: _, ...remaining } = data;
+		if (Object.keys(remaining).length === 0) conf.delete(targetPaneKey(targetPaneId));
+		else conf.set(targetPaneKey(targetPaneId), remaining);
+	}
+	if (editorPaneId) conf.delete(editorPaneKey(editorPaneId));
+}
+async function markAsEditorPane$3(editorPaneId, targetPaneIds) {
+	const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
+	conf.set(editorPaneKey(editorPaneId), { targetPaneIds: uniqueTargetPaneIds });
+	for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId$3(targetPaneId, editorPaneId);
+}
+async function getTargetPaneIds$3(editorPaneId) {
+	const data = conf.get(editorPaneKey(editorPaneId));
+	if (typeof data === "object" && data !== null && "targetPaneIds" in data) {
+		const targetPaneIds = data.targetPaneIds;
+		if (Array.isArray(targetPaneIds)) return targetPaneIds.map((id) => String(id));
+	}
+	return [];
+}
+function isEditorPaneFromConf$1(paneId) {
+	return conf.has(editorPaneKey(paneId));
+}
+async function resumeEditorPane(targetPaneId) {
+	const currentPaneId = await getCurrentPaneId$3();
+	const editorPaneId = isEditorPaneFromConf$1(currentPaneId) ? currentPaneId : isEditorPaneFromConf$1(targetPaneId) ? targetPaneId : "";
+	if (editorPaneId) {
+		const targetPaneIds = await getTargetPaneIds$3(editorPaneId);
+		for (const paneId of targetPaneIds) if (await checkPaneExists$3(paneId)) {
+			await focusPane$3(paneId);
+			return true;
+		}
+		return false;
+	}
+	const registeredEditorPaneId = await getEditorPaneId$3(targetPaneId);
+	if (registeredEditorPaneId === "") return false;
+	if (!await checkPaneExists$3(registeredEditorPaneId)) {
+		await clearEditorPaneId$3(targetPaneId);
+		return false;
+	}
+	await focusPane$3(registeredEditorPaneId);
+	return true;
+}
+async function appendToQuoteText$1(paneId, content) {
+	const data = conf.get(targetPaneKey(paneId));
+	const existing = typeof data === "object" && data !== null ? data : {};
+	const existingQuoteText = "quote_text" in existing ? String(existing.quote_text) : "";
+	const quoteText = existingQuoteText.trim() !== "" ? `${existingQuoteText}\n\n${content}` : content;
+	conf.set(targetPaneKey(paneId), {
+		...existing,
+		quote_text: quoteText
+	});
+}
+async function getQuoteText$1(paneId) {
+	const data = conf.get(targetPaneKey(paneId));
+	if (typeof data === "object" && data !== null && "quote_text" in data) return String(data.quote_text);
+	return "";
+}
+async function clearQuoteText$1(paneId) {
+	const data = conf.get(targetPaneKey(paneId));
+	if (typeof data === "object" && data !== null && "quote_text" in data) {
+		const { quote_text: _, ...remaining } = data;
+		if (Object.keys(remaining).length === 0) conf.delete(targetPaneKey(paneId));
+		else conf.set(targetPaneKey(paneId), remaining);
+	}
+}
+
+//#endregion
+//#region src/modules/niwaterm.ts
+const execAsync$2 = promisify(exec);
+const logger$13 = getLogger(["editprompt", "niwaterm"]);
+const VAR_EDITOR_PANE = "editprompt_editor_pane";
+const VAR_IS_EDITOR = "editprompt_is_editor";
+const VAR_TARGET_PANES = "editprompt_target_panes";
+const VAR_QUOTE = "editprompt_quote";
+function quoteShellWord(value) {
+	return `'${value.replace(/'/g, "'\\''")}'`;
+}
+async function getCurrentPaneId$2() {
+	const tabId = process.env.NIWATERM_TAB_ID?.trim();
+	if (!tabId) throw new Error("NIWATERM_TAB_ID is not set");
+	return tabId;
+}
+async function getTabVar(tabId, key) {
+	try {
+		const { stdout } = await execAsync$2(`niwa tab var get -t ${quoteShellWord(tabId)} ${quoteShellWord(key)}`);
+		return stdout.trim();
+	} catch (error) {
+		logger$13.debug("getTabVar failed: {error}", { error });
+		return "";
+	}
+}
+async function setTabVar(tabId, key, value) {
+	await execAsync$2(`niwa tab var set -t ${quoteShellWord(tabId)} ${quoteShellWord(key)} ${quoteShellWord(value)}`);
+}
+async function checkPaneExists$2(paneId) {
+	try {
+		await execAsync$2(`niwa tab var list -t ${quoteShellWord(paneId)}`);
+		return true;
+	} catch (error) {
+		logger$13.debug("checkPaneExists failed: {error}", { error });
+		return false;
+	}
+}
+async function focusPane$2(paneId) {
+	await execAsync$2(`niwa tab focus -t ${quoteShellWord(paneId)}`);
+}
+async function saveEditorPaneId$2(targetPaneId, editorPaneId) {
+	await setTabVar(targetPaneId, VAR_EDITOR_PANE, editorPaneId);
+}
+async function clearEditorPaneId$2(targetPaneId) {
+	await setTabVar(targetPaneId, VAR_EDITOR_PANE, "");
+}
+async function getEditorPaneId$2(targetPaneId) {
+	return getTabVar(targetPaneId, VAR_EDITOR_PANE);
+}
+async function markAsEditorPane$2(editorPaneId, targetPaneIds) {
+	const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
+	await setTabVar(editorPaneId, VAR_IS_EDITOR, "1");
+	await setTabVar(editorPaneId, VAR_TARGET_PANES, uniqueTargetPaneIds.join(","));
+	for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId$2(targetPaneId, editorPaneId);
+}
+async function getTargetPaneIds$2(editorPaneId) {
+	const value = await getTabVar(editorPaneId, VAR_TARGET_PANES);
+	if (value === "") return [];
+	return value.split(",").map((id) => id.trim());
+}
+async function isEditorPane$1(paneId) {
+	return await getTabVar(paneId, VAR_IS_EDITOR) === "1";
+}
+async function getQuoteVariableContent$1(paneId) {
+	return getTabVar(paneId, VAR_QUOTE);
+}
+async function appendToQuoteVariable$1(paneId, content) {
+	const existingContent = await getQuoteVariableContent$1(paneId);
+	await setTabVar(paneId, VAR_QUOTE, existingContent.trim() !== "" ? `${existingContent}\n${content}` : content);
+}
+async function clearQuoteVariable$1(paneId) {
+	await setTabVar(paneId, VAR_QUOTE, "");
+}
+async function sendKeyToNiwatermPane(paneId, key, delay = 1e3) {
+	await new Promise((resolve) => setTimeout(resolve, delay));
+	await execAsync$2(`niwa tab send-keys -t ${quoteShellWord(paneId)} ${quoteShellWord(key)}`);
+}
+async function inputToNiwatermPane(paneId, content) {
+	const chunks = splitByByteSize(content, NIWATERM_SEND_CHUNK_BYTES);
+	for (const chunk of chunks) await execAsync$2(`niwa tab send-keys -t ${quoteShellWord(paneId)} ${quoteShellWord(chunk)}`);
+	logger$13.debug("Content sent to niwaterm pane: {paneId} ({chunks} chunk(s))", {
+		paneId,
+		chunks: chunks.length
+	});
+}
+
 //#endregion
 //#region src/modules/tmux.ts
 const execAsync$1 = promisify(exec);
-const logger$11 = getLogger(["editprompt", "tmux"]);
+const logger$12 = getLogger(["editprompt", "tmux"]);
 async function getCurrentPaneId$1() {
 	const envPaneId = process.env.TMUX_PANE?.trim();
 	if (envPaneId) return envPaneId;
@@ -196,20 +575,15 @@ async function inputToTmuxPane(paneId, content) {
 	await execAsync$1(`tmux if-shell -t '${paneId}' '[ "#{pane_in_mode}" = "1" ]' "copy-mode -q -t '${paneId}'"`);
 	const chunks = splitByByteSize(content, TMUX_SEND_CHUNK_BYTES);
 	for (const chunk of chunks) await execAsync$1(`tmux send-keys -t '${paneId}' -- '${chunk.replace(/'/g, "'\\''")}'`);
-	logger$11.debug("Content sent to tmux pane: {paneId} ({chunks} chunk(s))", {
+	logger$12.debug("Content sent to tmux pane: {paneId} ({chunks} chunk(s))", {
 		paneId,
 		chunks: chunks.length
 	});
 }
 
-//#endregion
-//#region src/modules/conf.ts
-const projectName = process.env.NODE_ENV === "test" ? "editprompt-test" : "editprompt";
-const conf = new Conf({ projectName });
-
 //#endregion
 //#region src/modules/wezterm.ts
-const logger$10 = getLogger(["editprompt", "wezterm"]);
+const logger$11 = getLogger(["editprompt", "wezterm"]);
 const execAsync = promisify(exec);
 async function getCurrentPaneId() {
 	try {
@@ -217,26 +591,26 @@ async function getCurrentPaneId() {
 		const activePane = JSON.parse(stdout).find((pane) => pane.is_active === true);
 		return String(activePane?.pane_id);
 	} catch (error) {
-		logger$10.debug("getCurrentPaneId failed: {error}", { error });
+		logger$11.debug("getCurrentPaneId failed: {error}", { error });
 		return "";
 	}
 }
 async function checkPaneExists(paneId) {
 	try {
 		const { stdout } = await execAsync("wezterm cli list --format json");
-		logger$10.debug("wezterm cli list output: {stdout}", { stdout });
+		logger$11.debug("wezterm cli list output: {stdout}", { stdout });
 		return JSON.parse(stdout).some((pane) => String(pane.pane_id) === paneId);
 	} catch (error) {
-		logger$10.debug("checkPaneExists failed: {error}", { error });
+		logger$11.debug("checkPaneExists failed: {error}", { error });
 		return false;
 	}
 }
 async function saveEditorPaneId(targetPaneId, editorPaneId) {
-	logger$10.debug("Saving editor pane ID to conf key: wezterm.targetPane.pane_{targetPaneId}", { targetPaneId });
+	logger$11.debug("Saving editor pane ID to conf key: wezterm.targetPane.pane_{targetPaneId}", { targetPaneId });
 	try {
 		conf.set(`wezterm.targetPane.pane_${targetPaneId}`, { editorPaneId });
 	} catch (error) {
-		logger$10.debug("saveEditorPaneId failed: {error}", { error });
+		logger$11.debug("saveEditorPaneId failed: {error}", { error });
 	}
 }
 async function getEditorPaneId(targetPaneId) {
@@ -245,7 +619,7 @@ async function getEditorPaneId(targetPaneId) {
 		if (typeof data === "object" && data !== null && "editorPaneId" in data) return String(data.editorPaneId);
 		return "";
 	} catch (error) {
-		logger$10.debug("getEditorPaneId failed: {error}", { error });
+		logger$11.debug("getEditorPaneId failed: {error}", { error });
 		return "";
 	}
 }
@@ -255,7 +629,7 @@ async function clearEditorPaneId(targetPaneId) {
 		conf.delete(`wezterm.targetPane.pane_${targetPaneId}`);
 		if (editorPaneId) conf.delete(`wezterm.editorPane.pane_${editorPaneId}`);
 	} catch (error) {
-		logger$10.debug("clearEditorPaneId failed: {error}", { error });
+		logger$11.debug("clearEditorPaneId failed: {error}", { error });
 	}
 }
 async function focusPane(paneId) {
@@ -267,7 +641,7 @@ async function markAsEditorPane(editorPaneId, targetPaneIds) {
 		conf.set(`wezterm.editorPane.pane_${editorPaneId}`, { targetPaneIds: uniqueTargetPaneIds });
 		for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId(targetPaneId, editorPaneId);
 	} catch (error) {
-		logger$10.debug("markAsEditorPane failed: {error}", { error });
+		logger$11.debug("markAsEditorPane failed: {error}", { error });
 	}
 }
 async function getTargetPaneIds(editorPaneId) {
@@ -279,7 +653,7 @@ async function getTargetPaneIds(editorPaneId) {
 		}
 		return [];
 	} catch (error) {
-		logger$10.debug("getTargetPaneIds failed: {error}", { error });
+		logger$11.debug("getTargetPaneIds failed: {error}", { error });
 		return [];
 	}
 }
@@ -287,7 +661,7 @@ function isEditorPaneFromConf(paneId) {
 	try {
 		return conf.has(`wezterm.editorPane.pane_${paneId}`);
 	} catch (error) {
-		logger$10.debug("isEditorPaneFromConf failed: {error}", { error });
+		logger$11.debug("isEditorPaneFromConf failed: {error}", { error });
 		return false;
 	}
 }
@@ -305,7 +679,7 @@ async function appendToQuoteText(paneId, content) {
 		} else newData = { quote_text: content };
 		conf.set(`wezterm.targetPane.pane_${paneId}`, newData);
 	} catch (error) {
-		logger$10.debug("appendToQuoteText failed: {error}", { error });
+		logger$11.debug("appendToQuoteText failed: {error}", { error });
 	}
 }
 async function getQuoteText(paneId) {
@@ -314,7 +688,7 @@ async function getQuoteText(paneId) {
 		if (typeof data === "object" && data !== null && "quote_text" in data) return String(data.quote_text);
 		return "";
 	} catch (error) {
-		logger$10.debug("getQuoteText failed: {error}", { error });
+		logger$11.debug("getQuoteText failed: {error}", { error });
 		return "";
 	}
 }
@@ -323,7 +697,7 @@ async function clearQuoteText(paneId) {
 		const key = `wezterm.targetPane.pane_${paneId}.quote_text`;
 		if (conf.has(key)) conf.delete(key);
 	} catch (error) {
-		logger$10.debug("clearQuoteText failed: {error}", { error });
+		logger$11.debug("clearQuoteText failed: {error}", { error });
 	}
 }
 async function sendKeyToWeztermPane(paneId, key, delay = 1e3) {
@@ -333,7 +707,7 @@ async function sendKeyToWeztermPane(paneId, key, delay = 1e3) {
 async function inputToWeztermPane(paneId, content) {
 	const chunks = splitByByteSize(content, WEZTERM_SEND_CHUNK_BYTES);
 	for (const chunk of chunks) await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' -- '${chunk.replace(/'/g, "'\\''")}'`);
-	logger$10.debug("Content sent to wezterm pane: {paneId} ({chunks} chunk(s))", {
+	logger$11.debug("Content sent to wezterm pane: {paneId} ({chunks} chunk(s))", {
 		paneId,
 		chunks: chunks.length
 	});
@@ -477,87 +851,40 @@ function processQuoteText(text, options) {
 }
 
 //#endregion
-//#region src/modes/common.ts
-const logger$9 = getLogger(["editprompt", "delivery"]);
+//#region src/utils/mux.ts
+const SUPPORTED_MUXES = [
+	"tmux",
+	"wezterm",
+	"herdr",
+	"niwaterm"
+];
 function isMuxType(value) {
-	return value === "tmux" || value === "wezterm";
+	return value === "tmux" || value === "wezterm" || value === "herdr" || value === "niwaterm";
 }
-const SUPPORTED_MUXES = ["tmux", "wezterm"];
-async function copyToClipboard(content) {
-	await clipboardy.write(content);
+function hasValue(value) {
+	return typeof value === "string" && value.trim() !== "";
 }
-async function inputContentToPane(content, mux, targetPaneId) {
-	if (mux === "wezterm") await inputToWeztermPane(targetPaneId, content);
-	else await inputToTmuxPane(targetPaneId, content);
+function isHerdrEnvironment(env = process.env) {
+	return hasValue(env.HERDR_SOCKET_PATH) && (hasValue(env.HERDR_PANE_ID) || hasValue(env.HERDR_ACTIVE_PANE_ID));
 }
-async function focusFirstSuccessPane(mux, targetPanes, failedPanes) {
-	const firstSuccessPane = targetPanes.find((p) => !failedPanes.includes(p));
-	if (firstSuccessPane) if (mux === "tmux") await focusPane$1(firstSuccessPane);
-	else await focusPane(firstSuccessPane);
+function isNiwatermEnvironment(env = process.env) {
+	return hasValue(env.NIWATERM_TAB_ID);
 }
-async function handleContentDelivery(content, mux, targetPanes) {
-	if (!content) return {
-		successCount: 0,
-		totalCount: 0,
-		allSuccess: true,
-		allFailed: false,
-		failedPanes: []
-	};
-	if (targetPanes.length === 0) {
-		try {
-			await copyToClipboard(content);
-			logger$9.info("Content copied to clipboard.");
-		} catch (error) {
-			logger$9.warn(`Failed to copy to clipboard: ${error instanceof Error ? error.message : "Unknown error"}`);
-		}
-		return {
-			successCount: 0,
-			totalCount: 0,
-			allSuccess: true,
-			allFailed: false,
-			failedPanes: []
-		};
-	}
-	const results = [];
-	for (const targetPane of targetPanes) try {
-		await inputContentToPane(content, mux, targetPane);
-		results.push({
-			pane: targetPane,
-			success: true
-		});
-	} catch (error) {
-		logger$9.warn(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
-		results.push({
-			pane: targetPane,
-			success: false
-		});
+function resolveMux(explicitMux, env = process.env) {
+	const muxValue = explicitMux || env.EDITPROMPT_MUX || (isHerdrEnvironment(env) ? "herdr" : isNiwatermEnvironment(env) ? "niwaterm" : "tmux");
+	if (!isMuxType(muxValue)) {
+		const displayValue = typeof muxValue === "string" ? muxValue : `<${typeof muxValue}>`;
+		throw new Error(`Invalid multiplexer type '${displayValue}'. Supported values: ${SUPPORTED_MUXES.join(", ")}`);
 	}
-	const successCount = results.filter((r) => r.success).length;
-	const failedPanes = results.filter((r) => !r.success).map((r) => r.pane);
-	const allSuccess = successCount === targetPanes.length;
-	const allFailed = successCount === 0;
-	if (allSuccess) logger$9.info("Content sent successfully to all panes!");
-	else if (allFailed) {
-		logger$9.error("All target panes failed to receive content.");
-		logger$9.info("Falling back to clipboard...");
-		await copyToClipboard(content);
-		logger$9.info("Content copied to clipboard.");
-	} else logger$9.warn(`Content sent to ${successCount}/${targetPanes.length} panes. Failed panes: ${failedPanes.join(", ")}`);
-	return {
-		successCount,
-		totalCount: targetPanes.length,
-		allSuccess,
-		allFailed,
-		failedPanes
-	};
+	return muxValue;
 }
 
 //#endregion
 //#region src/modes/args.ts
-const logger$8 = getLogger(["editprompt"]);
+const logger$10 = getLogger(["editprompt"]);
 const ARG_MUX = {
 	short: "m",
-	description: "Multiplexer type (tmux or wezterm, default: tmux)",
+	description: "Multiplexer type (tmux, wezterm, herdr, or niwaterm; auto-detects Herdr and niwaterm, otherwise tmux)",
 	type: "string"
 };
 const ARG_TARGET_PANE_SINGLE = {
@@ -603,17 +930,23 @@ const ARG_VERBOSE = {
 	description: "Enable debug-level log output",
 	type: "boolean"
 };
+const ARG_ENV = {
+	short: "E",
+	description: "Environment variables to set (e.g., KEY=VALUE)",
+	type: "string",
+	multiple: true
+};
 function validateMux(value) {
-	const muxValue = value || "tmux";
-	if (!isMuxType(muxValue)) {
-		logger$8.error(`Invalid multiplexer type '${muxValue}'. Supported values: ${SUPPORTED_MUXES.join(", ")}`);
+	try {
+		return resolveMux(value);
+	} catch (error) {
+		logger$10.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
-	return muxValue;
 }
 function validateTargetPane(value, commandName) {
 	if (!value || typeof value !== "string") {
-		logger$8.error(`--target-pane is required for ${commandName} command`);
+		logger$10.error(`--target-pane is required for ${commandName} command`);
 		process.exit(1);
 	}
 	return value;
@@ -626,7 +959,7 @@ function normalizeTargetPanes(value) {
 
 //#endregion
 //#region src/modes/collect.ts
-const logger$7 = getLogger(["editprompt", "collect"]);
+const logger$9 = getLogger(["editprompt", "collect"]);
 const SUPPORTED_OUTPUTS = ["buffer", "stdout"];
 async function readStdin() {
 	return new Promise((resolve, reject) => {
@@ -650,7 +983,7 @@ function normalizeCollectOutputs(value) {
 	const uniqueOutputs = [...new Set(outputs)];
 	const invalid = uniqueOutputs.filter((v) => !SUPPORTED_OUTPUTS.includes(v));
 	if (invalid.length > 0) {
-		logger$7.error(`Invalid output(s) '${invalid.join(", ")}'. Supported values: ${SUPPORTED_OUTPUTS.join(", ")}`);
+		logger$9.error(`Invalid output(s) '${invalid.join(", ")}'. Supported values: ${SUPPORTED_OUTPUTS.join(", ")}`);
 		process.exit(1);
 	}
 	return uniqueOutputs;
@@ -661,12 +994,13 @@ async function runCollectMode(mux, targetPaneId, rawContent, outputs = ["buffer"
 		if (rawContent !== void 0) selection = rawContent;
 		else selection = await readStdin();
 		const processedText = processQuoteText(selection, { withQuote });
-		for (const output of outputs) if (output === "buffer") {
-			if (mux === "tmux") await appendToQuoteVariable(targetPaneId, processedText);
-			else if (mux === "wezterm") await appendToQuoteText(targetPaneId, processedText);
-		} else if (output === "stdout") process.stdout.write(processedText);
+		for (const output of outputs) if (output === "buffer") if (mux === "tmux") await appendToQuoteVariable(targetPaneId, processedText);
+		else if (mux === "wezterm") await appendToQuoteText(targetPaneId, processedText);
+		else if (mux === "niwaterm") await appendToQuoteVariable$1(targetPaneId, processedText);
+		else await appendToQuoteText$1(targetPaneId, processedText);
+		else if (output === "stdout") process.stdout.write(processedText);
 	} catch (error) {
-		logger$7.error(`${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$9.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 		process.exit(1);
 	}
 }
@@ -693,10 +1027,10 @@ const collectCommand = define({
 		const outputs = normalizeCollectOutputs(ctx.values.output);
 		const withQuote = !ctx.values["no-quote"];
 		let rawContent;
-		if (mux === "wezterm") {
+		if (mux === "wezterm" || mux === "herdr" || mux === "niwaterm") {
 			rawContent = extractRawContent(ctx.rest, ctx.positionals);
 			if (rawContent === void 0) {
-				logger$7.error("Text content is required for collect mode with wezterm. Use: editprompt collect --mux wezterm --target-pane <id> -- \"<text>\"");
+				logger$9.error(`Text content is required for collect mode with ${mux}. Use: editprompt collect --mux ${mux} --target-pane <id> -- "<text>"`);
 				process.exit(1);
 			}
 		}
@@ -706,11 +1040,8 @@ const collectCommand = define({
 
 //#endregion
 //#region src/utils/sendConfig.ts
-const VALID_MUX_TYPES = ["tmux", "wezterm"];
 function readSendConfig() {
-	const muxValue = process.env.EDITPROMPT_MUX || "tmux";
-	if (!VALID_MUX_TYPES.includes(muxValue)) throw new Error(`Invalid EDITPROMPT_MUX value: ${muxValue}. Must be one of: ${VALID_MUX_TYPES.join(", ")}`);
-	const mux = muxValue;
+	const mux = resolveMux();
 	const alwaysCopy = process.env.EDITPROMPT_ALWAYS_COPY === "1";
 	const delayValue = process.env.EDITPROMPT_SEND_KEY_DELAY;
 	const parsedDelay = delayValue ? Number.parseInt(delayValue, 10) : NaN;
@@ -723,7 +1054,7 @@ function readSendConfig() {
 
 //#endregion
 //#region src/modes/dump.ts
-const logger$6 = getLogger(["editprompt", "dump"]);
+const logger$8 = getLogger(["editprompt", "dump"]);
 async function runDumpMode() {
 	try {
 		const config = readSendConfig();
@@ -732,19 +1063,27 @@ async function runDumpMode() {
 		if (config.mux === "tmux") {
 			currentPaneId = await getCurrentPaneId$1();
 			isEditor = await isEditorPane(currentPaneId);
-		} else {
+		} else if (config.mux === "wezterm") {
 			currentPaneId = await getCurrentPaneId();
 			isEditor = isEditorPaneFromConf(currentPaneId);
+		} else if (config.mux === "niwaterm") {
+			currentPaneId = await getCurrentPaneId$2();
+			isEditor = await isEditorPane$1(currentPaneId);
+		} else {
+			currentPaneId = await getCurrentPaneId$3();
+			isEditor = isEditorPaneFromConf$1(currentPaneId);
 		}
 		if (!isEditor) {
-			logger$6.error("Current pane is not an editor pane");
+			logger$8.error("Current pane is not an editor pane");
 			process.exit(1);
 		}
 		let targetPanes;
 		if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
-		else targetPanes = await getTargetPaneIds(currentPaneId);
+		else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
+		else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$2(currentPaneId);
+		else targetPanes = await getTargetPaneIds$3(currentPaneId);
 		if (targetPanes.length === 0) {
-			logger$6.error("No target panes registered for this editor pane");
+			logger$8.error("No target panes registered for this editor pane");
 			process.exit(1);
 		}
 		const quoteContents = [];
@@ -753,9 +1092,15 @@ async function runDumpMode() {
 			if (config.mux === "tmux") {
 				content = await getQuoteVariableContent(targetPane);
 				await clearQuoteVariable(targetPane);
-			} else {
+			} else if (config.mux === "wezterm") {
 				content = await getQuoteText(targetPane);
 				await clearQuoteText(targetPane);
+			} else if (config.mux === "niwaterm") {
+				content = await getQuoteVariableContent$1(targetPane);
+				await clearQuoteVariable$1(targetPane);
+			} else {
+				content = await getQuoteText$1(targetPane);
+				await clearQuoteText$1(targetPane);
 			}
 			if (content.trim() !== "") quoteContents.push(content);
 		}
@@ -763,7 +1108,7 @@ async function runDumpMode() {
 		process.stdout.write(combinedContent.replace(/\n{3,}$/, "\n\n"));
 		process.exit(0);
 	} catch (error) {
-		logger$6.error(`${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$8.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 		process.exit(1);
 	}
 }
@@ -793,13 +1138,89 @@ function processContent(content) {
 	return processed;
 }
 
+//#endregion
+//#region src/modes/common.ts
+const logger$7 = getLogger(["editprompt", "delivery"]);
+async function copyToClipboard(content) {
+	await clipboardy.write(content);
+}
+async function inputContentToPane(content, mux, targetPaneId) {
+	if (mux === "wezterm") await inputToWeztermPane(targetPaneId, content);
+	else if (mux === "herdr") await inputToHerdrPane(targetPaneId, content);
+	else if (mux === "niwaterm") await inputToNiwatermPane(targetPaneId, content);
+	else await inputToTmuxPane(targetPaneId, content);
+}
+async function focusFirstSuccessPane(mux, targetPanes, failedPanes) {
+	const firstSuccessPane = targetPanes.find((p) => !failedPanes.includes(p));
+	if (firstSuccessPane) if (mux === "tmux") await focusPane$1(firstSuccessPane);
+	else if (mux === "wezterm") await focusPane(firstSuccessPane);
+	else if (mux === "niwaterm") await focusPane$2(firstSuccessPane);
+	else await focusPane$3(firstSuccessPane);
+}
+async function handleContentDelivery(content, mux, targetPanes) {
+	if (!content) return {
+		successCount: 0,
+		totalCount: 0,
+		allSuccess: true,
+		allFailed: false,
+		failedPanes: []
+	};
+	if (targetPanes.length === 0) {
+		try {
+			await copyToClipboard(content);
+			logger$7.info("Content copied to clipboard.");
+		} catch (error) {
+			logger$7.warn(`Failed to copy to clipboard: ${error instanceof Error ? error.message : "Unknown error"}`);
+		}
+		return {
+			successCount: 0,
+			totalCount: 0,
+			allSuccess: true,
+			allFailed: false,
+			failedPanes: []
+		};
+	}
+	const results = [];
+	for (const targetPane of targetPanes) try {
+		await inputContentToPane(content, mux, targetPane);
+		results.push({
+			pane: targetPane,
+			success: true
+		});
+	} catch (error) {
+		logger$7.warn(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
+		results.push({
+			pane: targetPane,
+			success: false
+		});
+	}
+	const successCount = results.filter((r) => r.success).length;
+	const failedPanes = results.filter((r) => !r.success).map((r) => r.pane);
+	const allSuccess = successCount === targetPanes.length;
+	const allFailed = successCount === 0;
+	if (allSuccess) logger$7.info("Content sent successfully to all panes!");
+	else if (allFailed) {
+		logger$7.error("All target panes failed to receive content.");
+		logger$7.info("Falling back to clipboard...");
+		await copyToClipboard(content);
+		logger$7.info("Content copied to clipboard.");
+	} else logger$7.warn(`Content sent to ${successCount}/${targetPanes.length} panes. Failed panes: ${failedPanes.join(", ")}`);
+	return {
+		successCount,
+		totalCount: targetPanes.length,
+		allSuccess,
+		allFailed,
+		failedPanes
+	};
+}
+
 //#endregion
 //#region src/modes/input.ts
-const logger$5 = getLogger(["editprompt", "input"]);
+const logger$6 = getLogger(["editprompt", "input"]);
 async function runInputMode(rawContent, autoSend, sendKey, sendKeyDelay) {
 	const content = processContent(rawContent);
 	if (!content) {
-		logger$5.info("No content to send. Exiting.");
+		logger$6.info("No content to send. Exiting.");
 		return;
 	}
 	const config = readSendConfig();
@@ -808,44 +1229,58 @@ async function runInputMode(rawContent, autoSend, sendKey, sendKeyDelay) {
 	if (config.mux === "tmux") {
 		currentPaneId = await getCurrentPaneId$1();
 		isEditor = await isEditorPane(currentPaneId);
-	} else {
+	} else if (config.mux === "wezterm") {
 		currentPaneId = await getCurrentPaneId();
 		isEditor = isEditorPaneFromConf(currentPaneId);
+	} else if (config.mux === "niwaterm") {
+		currentPaneId = await getCurrentPaneId$2();
+		isEditor = await isEditorPane$1(currentPaneId);
+	} else {
+		currentPaneId = await getCurrentPaneId$3();
+		isEditor = isEditorPaneFromConf$1(currentPaneId);
 	}
 	if (!isEditor) {
-		logger$5.error("Current pane is not an editor pane");
+		logger$6.error("Current pane is not an editor pane");
 		process.exit(1);
 	}
 	let targetPanes;
 	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
-	else targetPanes = await getTargetPaneIds(currentPaneId);
+	else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
+	else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$2(currentPaneId);
+	else targetPanes = await getTargetPaneIds$3(currentPaneId);
 	if (targetPanes.length === 0) {
-		logger$5.error("No target panes registered for this editor pane");
+		logger$6.error("No target panes registered for this editor pane");
 		process.exit(1);
 	}
 	if (autoSend) {
-		const key = sendKey || (config.mux === "wezterm" ? "\\r" : "C-m");
+		const key = sendKey || (config.mux === "wezterm" ? "\\r" : config.mux === "herdr" ? "enter" : "C-m");
 		const delay = /\.(png|webp|avif|jpe?g|gif)\b/i.test(content) ? sendKeyDelay ?? 1e3 : 200;
 		let successCount = 0;
 		for (const targetPane of targetPanes) try {
 			if (config.mux === "wezterm") {
 				await inputToWeztermPane(targetPane, content);
 				await sendKeyToWeztermPane(targetPane, key, delay);
+			} else if (config.mux === "herdr") {
+				await inputToHerdrPane(targetPane, content);
+				await sendKeyToHerdrPane(targetPane, key, delay);
+			} else if (config.mux === "niwaterm") {
+				await inputToNiwatermPane(targetPane, content);
+				await sendKeyToNiwatermPane(targetPane, key, delay);
 			} else {
 				await inputToTmuxPane(targetPane, content);
 				await sendKeyToTmuxPane(targetPane, key, delay);
 			}
 			successCount++;
 		} catch (error) {
-			logger$5.error(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
+			logger$6.error(`Failed to send to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
 		}
 		if (config.alwaysCopy) {
 			await copyToClipboard(content);
-			logger$5.info("Also copied to clipboard.");
+			logger$6.info("Also copied to clipboard.");
 		}
-		if (successCount > 0) logger$5.info("Content sent and submitted successfully!");
+		if (successCount > 0) logger$6.info("Content sent and submitted successfully!");
 		else {
-			logger$5.error("All target panes failed to receive content");
+			logger$6.error("All target panes failed to receive content");
 			process.exit(1);
 		}
 		return;
@@ -854,12 +1289,12 @@ async function runInputMode(rawContent, autoSend, sendKey, sendKeyDelay) {
 		const result = await handleContentDelivery(content, config.mux, targetPanes);
 		if (config.alwaysCopy && !result.allFailed) {
 			await copyToClipboard(content);
-			logger$5.info("Also copied to clipboard.");
+			logger$6.info("Also copied to clipboard.");
 		}
 		if (result.successCount > 0) await focusFirstSuccessPane(config.mux, targetPanes, result.failedPanes);
 		if (result.allFailed) process.exit(1);
 	} catch (error) {
-		logger$5.error(`${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$6.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 		process.exit(1);
 	}
 }
@@ -887,13 +1322,13 @@ const inputCommand = define({
 		});
 		const rawContent = extractRawContent(ctx.rest, ctx.positionals);
 		if (rawContent === void 0) {
-			logger$5.error("Content is required for input command");
-			logger$5.error("Usage: editprompt input \"your content\"");
-			logger$5.error("   or: editprompt input -- \"your content\"");
+			logger$6.error("Content is required for input command");
+			logger$6.error("Usage: editprompt input \"your content\"");
+			logger$6.error("   or: editprompt input -- \"your content\"");
 			process.exit(1);
 		}
 		if (ctx.values["send-key"] && !ctx.values["auto-send"]) {
-			logger$5.error("--send-key requires --auto-send to be enabled");
+			logger$6.error("--send-key requires --auto-send to be enabled");
 			process.exit(1);
 		}
 		const config = readSendConfig();
@@ -987,8 +1422,9 @@ async function openEditorAndGetContent(editorOption, envVars, sendConfig) {
 
 //#endregion
 //#region src/modes/openEditor.ts
-const logger$4 = getLogger(["editprompt", "open"]);
+const logger$5 = getLogger(["editprompt", "open"]);
 async function runOpenEditorMode(options) {
+	let herdrEditorPaneId;
 	if (options.targetPanes.length > 0 && options.mux === "tmux") try {
 		await markAsEditorPane$1(await getCurrentPaneId$1(), options.targetPanes);
 	} catch {}
@@ -996,16 +1432,25 @@ async function runOpenEditorMode(options) {
 		const currentPaneId = await getCurrentPaneId();
 		await markAsEditorPane(currentPaneId, options.targetPanes);
 	} catch {}
+	else if (options.targetPanes.length > 0 && options.mux === "herdr") try {
+		const currentPaneId = await getCurrentPaneId$3();
+		herdrEditorPaneId = currentPaneId;
+		await markAsEditorPane$3(currentPaneId, options.targetPanes);
+	} catch {}
+	else if (options.targetPanes.length > 0 && options.mux === "niwaterm") try {
+		const currentPaneId = await getCurrentPaneId$2();
+		await markAsEditorPane$2(currentPaneId, options.targetPanes);
+	} catch {}
 	try {
 		const sendConfig = {
 			mux: options.mux,
 			alwaysCopy: options.alwaysCopy,
 			sendKeyDelay: Number.parseInt(process.env.EDITPROMPT_SEND_KEY_DELAY || "", 10) || 1e3
 		};
-		logger$4.info("Opening editor...");
+		logger$5.info("Opening editor...");
 		const content = await openEditorAndGetContent(options.editor, options.env, sendConfig);
 		if (!content) {
-			logger$4.info("No content entered. Exiting.");
+			logger$5.info("No content entered. Exiting.");
 			return;
 		}
 		try {
@@ -1014,12 +1459,12 @@ async function runOpenEditorMode(options) {
 			console.log(content);
 			if (options.alwaysCopy && !result.allFailed) {
 				await copyToClipboard(content);
-				logger$4.info("Also copied to clipboard.");
+				logger$5.info("Also copied to clipboard.");
 			}
 			if (options.targetPanes.length > 0 && result.successCount > 0) await focusFirstSuccessPane(options.mux, options.targetPanes, result.failedPanes);
 			if (!result.allSuccess) process.exit(1);
 		} catch (error) {
-			logger$4.error(`${error instanceof Error ? error.message : "Unknown error"}`);
+			logger$5.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 			process.exit(1);
 		}
 	} finally {
@@ -1029,6 +1474,12 @@ async function runOpenEditorMode(options) {
 		else if (options.targetPanes.length > 0 && options.mux === "wezterm") try {
 			for (const targetPane of options.targetPanes) await clearEditorPaneId(targetPane);
 		} catch {}
+		else if (options.targetPanes.length > 0 && options.mux === "herdr") try {
+			for (const targetPane of options.targetPanes) await clearEditorPaneId$3(targetPane, herdrEditorPaneId);
+		} catch {}
+		else if (options.targetPanes.length > 0 && options.mux === "niwaterm") try {
+			for (const targetPane of options.targetPanes) await clearEditorPaneId$2(targetPane);
+		} catch {}
 	}
 }
 const openCommand = define({
@@ -1042,12 +1493,7 @@ const openCommand = define({
 		"log-file": ARG_LOG_FILE,
 		quiet: ARG_QUIET,
 		verbose: ARG_VERBOSE,
-		env: {
-			short: "E",
-			description: "Environment variables to set (e.g., KEY=VALUE)",
-			type: "string",
-			multiple: true
-		}
+		env: ARG_ENV
 	},
 	async run(ctx) {
 		setupLogger({
@@ -1067,10 +1513,10 @@ const openCommand = define({
 
 //#endregion
 //#region src/modes/register.ts
-const logger$3 = getLogger(["editprompt", "register"]);
+const logger$4 = getLogger(["editprompt", "register"]);
 async function runRegisterMode(options) {
 	if (options.targetPanes.length === 0) {
-		logger$3.error("--target-pane is required for register command");
+		logger$4.error("--target-pane is required for register command");
 		process.exit(1);
 	}
 	let editorPaneId;
@@ -1078,29 +1524,45 @@ async function runRegisterMode(options) {
 	else if (options.mux === "tmux") {
 		editorPaneId = await getCurrentPaneId$1();
 		if (!await isEditorPane(editorPaneId)) {
-			logger$3.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
+			logger$4.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
 			process.exit(1);
 		}
 	} else if (options.mux === "wezterm") {
 		editorPaneId = await getCurrentPaneId();
 		if (!isEditorPaneFromConf(editorPaneId)) {
-			logger$3.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
+			logger$4.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
+			process.exit(1);
+		}
+	} else if (options.mux === "herdr") {
+		editorPaneId = await getCurrentPaneId$3();
+		if (!isEditorPaneFromConf$1(editorPaneId)) {
+			logger$4.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
+			process.exit(1);
+		}
+	} else if (options.mux === "niwaterm") {
+		editorPaneId = await getCurrentPaneId$2();
+		if (!await isEditorPane$1(editorPaneId)) {
+			logger$4.error("Current pane is not an editor pane. Please run this command from an editor pane or specify --editor-pane.");
 			process.exit(1);
 		}
 	} else {
-		logger$3.error("Unsupported multiplexer");
+		logger$4.error("Unsupported multiplexer");
 		process.exit(1);
 	}
 	try {
 		let existingPanes = [];
 		if (options.mux === "tmux") existingPanes = await getTargetPaneIds$1(editorPaneId);
 		else if (options.mux === "wezterm") existingPanes = await getTargetPaneIds(editorPaneId);
+		else if (options.mux === "herdr") existingPanes = await getTargetPaneIds$3(editorPaneId);
+		else if (options.mux === "niwaterm") existingPanes = await getTargetPaneIds$2(editorPaneId);
 		const mergedTargetPanes = [...new Set([...existingPanes, ...options.targetPanes])];
 		if (options.mux === "tmux") await markAsEditorPane$1(editorPaneId, mergedTargetPanes);
 		else if (options.mux === "wezterm") await markAsEditorPane(editorPaneId, mergedTargetPanes);
-		logger$3.info(`Editor pane ${editorPaneId} registered with target panes: ${mergedTargetPanes.join(", ")}`);
+		else if (options.mux === "herdr") await markAsEditorPane$3(editorPaneId, mergedTargetPanes);
+		else if (options.mux === "niwaterm") await markAsEditorPane$2(editorPaneId, mergedTargetPanes);
+		logger$4.info(`Editor pane ${editorPaneId} registered with target panes: ${mergedTargetPanes.join(", ")}`);
 	} catch (error) {
-		logger$3.error(`${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$4.error(`${error instanceof Error ? error.message : "Unknown error"}`);
 		process.exit(1);
 	}
 }
@@ -1135,15 +1597,65 @@ const registerCommand = define({
 
 //#endregion
 //#region src/modes/resume.ts
-const logger$2 = getLogger(["editprompt", "resume"]);
+const logger$3 = getLogger(["editprompt", "resume"]);
 async function runResumeMode(targetPane, mux) {
+	if (mux === "herdr") try {
+		process.exit(await resumeEditorPane(targetPane) ? 0 : 1);
+	} catch (error) {
+		logger$3.debug("Herdr resume failed: {error}", { error });
+		process.exit(1);
+	}
+	if (mux === "niwaterm") {
+		const currentPaneId = await getCurrentPaneId$2();
+		if (await isEditorPane$1(currentPaneId)) {
+			logger$3.debug("Current pane is an editor pane");
+			const originalTargetPaneIds = await getTargetPaneIds$2(currentPaneId);
+			if (originalTargetPaneIds.length === 0) {
+				logger$3.debug("No target pane IDs found for editor pane");
+				process.exit(1);
+			}
+			let focused = false;
+			for (const paneId of originalTargetPaneIds) if (await checkPaneExists$2(paneId)) {
+				await focusPane$2(paneId);
+				focused = true;
+				break;
+			}
+			if (!focused) {
+				logger$3.debug("All target panes do not exist");
+				process.exit(1);
+			}
+			process.exit(0);
+		}
+		logger$3.debug("Current pane is not an editor pane");
+		const editorPaneId = await getEditorPaneId$2(targetPane);
+		logger$3.debug("niwaterm editorPaneId: {editorPaneId}", { editorPaneId });
+		if (editorPaneId === "") {
+			logger$3.debug("Editor pane ID not found");
+			process.exit(1);
+		}
+		if (!await checkPaneExists$2(editorPaneId)) {
+			logger$3.debug("Editor pane does not exist");
+			await clearEditorPaneId$2(targetPane);
+			process.exit(1);
+		}
+		try {
+			await focusPane$2(editorPaneId);
+			process.exit(0);
+		} catch (error) {
+			logger$3.debug("Can't focus editorPaneId: {editorPaneId}, error: {error}", {
+				editorPaneId,
+				error
+			});
+			process.exit(1);
+		}
+	}
 	if (mux === "wezterm") {
 		const currentPaneId = await getCurrentPaneId();
 		if (isEditorPaneFromConf(currentPaneId)) {
-			logger$2.debug("Current pane is an editor pane");
+			logger$3.debug("Current pane is an editor pane");
 			const originalTargetPaneIds = await getTargetPaneIds(currentPaneId);
 			if (originalTargetPaneIds.length === 0) {
-				logger$2.debug("No target pane IDs found for editor pane");
+				logger$3.debug("No target pane IDs found for editor pane");
 				process.exit(1);
 			}
 			let focused = false;
@@ -1153,20 +1665,20 @@ async function runResumeMode(targetPane, mux) {
 				break;
 			}
 			if (!focused) {
-				logger$2.debug("All target panes do not exist");
+				logger$3.debug("All target panes do not exist");
 				process.exit(1);
 			}
 			process.exit(0);
 		}
-		logger$2.debug("Current pane is not an editor pane");
+		logger$3.debug("Current pane is not an editor pane");
 		const editorPaneId = await getEditorPaneId(targetPane);
-		logger$2.debug("wezterm editorPaneId: {editorPaneId}", { editorPaneId });
+		logger$3.debug("wezterm editorPaneId: {editorPaneId}", { editorPaneId });
 		if (editorPaneId === "") {
-			logger$2.debug("Editor pane ID not found");
+			logger$3.debug("Editor pane ID not found");
 			process.exit(1);
 		}
 		if (!await checkPaneExists(editorPaneId)) {
-			logger$2.debug("Editor pane does not exist");
+			logger$3.debug("Editor pane does not exist");
 			await clearEditorPaneId(targetPane);
 			process.exit(1);
 		}
@@ -1174,7 +1686,7 @@ async function runResumeMode(targetPane, mux) {
 			await focusPane(editorPaneId);
 			process.exit(0);
 		} catch (error) {
-			logger$2.debug("Can't focus editorPaneId: {editorPaneId}, error: {error}", {
+			logger$3.debug("Can't focus editorPaneId: {editorPaneId}, error: {error}", {
 				editorPaneId,
 				error
 			});
@@ -1225,10 +1737,10 @@ const resumeCommand = define({
 
 //#endregion
 //#region src/modes/press.ts
-const logger$1 = getLogger(["editprompt", "press"]);
+const logger$2 = getLogger(["editprompt", "press"]);
 async function runPressMode(key, delay = 0) {
 	if (!key) {
-		logger$1.error("Key is required");
+		logger$2.error("Key is required");
 		process.exit(1);
 	}
 	const config = readSendConfig();
@@ -1237,32 +1749,42 @@ async function runPressMode(key, delay = 0) {
 	if (config.mux === "tmux") {
 		currentPaneId = await getCurrentPaneId$1();
 		isEditor = await isEditorPane(currentPaneId);
-	} else {
+	} else if (config.mux === "wezterm") {
 		currentPaneId = await getCurrentPaneId();
 		isEditor = isEditorPaneFromConf(currentPaneId);
+	} else if (config.mux === "niwaterm") {
+		currentPaneId = await getCurrentPaneId$2();
+		isEditor = await isEditorPane$1(currentPaneId);
+	} else {
+		currentPaneId = await getCurrentPaneId$3();
+		isEditor = isEditorPaneFromConf$1(currentPaneId);
 	}
 	if (!isEditor) {
-		logger$1.error("Current pane is not an editor pane");
+		logger$2.error("Current pane is not an editor pane");
 		process.exit(1);
 	}
 	let targetPanes;
 	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
-	else targetPanes = await getTargetPaneIds(currentPaneId);
+	else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
+	else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$2(currentPaneId);
+	else targetPanes = await getTargetPaneIds$3(currentPaneId);
 	if (targetPanes.length === 0) {
-		logger$1.error("No target panes registered for this editor pane");
+		logger$2.error("No target panes registered for this editor pane");
 		process.exit(1);
 	}
 	let successCount = 0;
 	for (const targetPane of targetPanes) try {
 		if (config.mux === "wezterm") await sendKeyToWeztermPane(targetPane, key, delay);
+		else if (config.mux === "herdr") await sendKeyToHerdrPane(targetPane, key, delay);
+		else if (config.mux === "niwaterm") await sendKeyToNiwatermPane(targetPane, key, delay);
 		else await sendKeyToTmuxPane(targetPane, key, delay);
 		successCount++;
 	} catch (error) {
-		logger$1.warn(`Failed to send key to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
+		logger$2.warn(`Failed to send key to pane ${targetPane}: ${error instanceof Error ? error.message : "Unknown error"}`);
 	}
-	if (successCount > 0) logger$1.info("Key sent successfully!");
+	if (successCount > 0) logger$2.info("Key sent successfully!");
 	else {
-		logger$1.error("All target panes failed to receive key");
+		logger$2.error("All target panes failed to receive key");
 		process.exit(1);
 	}
 }
@@ -1286,8 +1808,8 @@ const pressCommand = define({
 		});
 		const key = extractRawContent(ctx.rest, ctx.positionals);
 		if (key === void 0 || key === "") {
-			logger$1.error("Key is required for press command");
-			logger$1.error("Usage: editprompt press -- \"Tab\"");
+			logger$2.error("Key is required for press command");
+			logger$2.error("Usage: editprompt press -- \"Tab\"");
 			process.exit(1);
 		}
 		await runPressMode(key, ctx.values.delay ? Number(ctx.values.delay) : 0);
@@ -1296,9 +1818,9 @@ const pressCommand = define({
 
 //#endregion
 //#region src/modes/stash.ts
-const logger = getLogger(["editprompt", "stash"]);
+const logger$1 = getLogger(["editprompt", "stash"]);
 function getStashKey(mux, targetPaneId) {
-	return `${mux}.targetPane.pane_${targetPaneId}.stash`;
+	return `${mux === "herdr" ? getStorageNamespace() : mux}.targetPane.pane_${targetPaneId}.stash`;
 }
 async function pushStash(mux, targetPaneId, content) {
 	const key = (/* @__PURE__ */ new Date()).toISOString();
@@ -1345,19 +1867,27 @@ async function getTargetPaneForStash() {
 	if (config.mux === "tmux") {
 		currentPaneId = await getCurrentPaneId$1();
 		isEditor = await isEditorPane(currentPaneId);
-	} else {
+	} else if (config.mux === "wezterm") {
 		currentPaneId = await getCurrentPaneId();
 		isEditor = isEditorPaneFromConf(currentPaneId);
+	} else if (config.mux === "niwaterm") {
+		currentPaneId = await getCurrentPaneId$2();
+		isEditor = await isEditorPane$1(currentPaneId);
+	} else {
+		currentPaneId = await getCurrentPaneId$3();
+		isEditor = isEditorPaneFromConf$1(currentPaneId);
 	}
 	if (!isEditor) {
-		logger.error("Current pane is not an editor pane");
+		logger$1.error("Current pane is not an editor pane");
 		process.exit(1);
 	}
 	let targetPanes;
 	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
-	else targetPanes = await getTargetPaneIds(currentPaneId);
+	else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
+	else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$2(currentPaneId);
+	else targetPanes = await getTargetPaneIds$3(currentPaneId);
 	if (targetPanes.length === 0) {
-		logger.error("No target panes registered for this editor pane");
+		logger$1.error("No target panes registered for this editor pane");
 		process.exit(1);
 	}
 	return {
@@ -1368,13 +1898,13 @@ async function getTargetPaneForStash() {
 async function runPush(rest, positionals) {
 	const rawContent = extractRawContent(rest, positionals);
 	if (rawContent === void 0 || rawContent.trim() === "") {
-		logger.error("Content is required for stash push");
-		logger.error("Usage: editprompt stash push -- \"your content\"");
+		logger$1.error("Content is required for stash push");
+		logger$1.error("Usage: editprompt stash push -- \"your content\"");
 		process.exit(1);
 	}
 	const { mux, targetPaneId } = await getTargetPaneForStash();
 	const key = await pushStash(mux, targetPaneId, rawContent);
-	logger.info("Stashed with key: {key}", { key });
+	logger$1.info("Stashed with key: {key}", { key });
 }
 async function runList() {
 	const { mux, targetPaneId } = await getTargetPaneForStash();
@@ -1385,8 +1915,8 @@ async function runApply(key) {
 	const { mux, targetPaneId } = await getTargetPaneForStash();
 	const content = getStashContent(mux, targetPaneId, key);
 	if (content === "") {
-		if (key) logger.error("No stash entry found with key: {key}", { key });
-		else logger.error("No stash entries found");
+		if (key) logger$1.error("No stash entry found with key: {key}", { key });
+		else logger$1.error("No stash entries found");
 		process.exit(1);
 	}
 	process.stdout.write(content);
@@ -1394,18 +1924,18 @@ async function runApply(key) {
 async function runDrop(key) {
 	const { mux, targetPaneId } = await getTargetPaneForStash();
 	if (!dropStash(mux, targetPaneId, key)) {
-		if (key) logger.error("No stash entry found with key: {key}", { key });
-		else logger.error("No stash entries found");
+		if (key) logger$1.error("No stash entry found with key: {key}", { key });
+		else logger$1.error("No stash entries found");
 		process.exit(1);
 	}
-	logger.info("Stash entry dropped");
+	logger$1.info("Stash entry dropped");
 }
 async function runPop(key) {
 	const { mux, targetPaneId } = await getTargetPaneForStash();
 	const content = getStashContent(mux, targetPaneId, key);
 	if (content === "") {
-		if (key) logger.error("No stash entry found with key: {key}", { key });
-		else logger.error("No stash entries found");
+		if (key) logger$1.error("No stash entry found with key: {key}", { key });
+		else logger$1.error("No stash entries found");
 		process.exit(1);
 	}
 	process.stdout.write(content);
@@ -1469,14 +1999,107 @@ const stashCommand = define({
 				await runPop(parseKeyOption(subArgs));
 				break;
 			default:
-				logger.error("Unknown subcommand '{subcommand}'", { subcommand });
-				logger.error("");
+				logger$1.error("Unknown subcommand '{subcommand}'", { subcommand });
+				logger$1.error("");
 				showHelp();
 				process.exit(1);
 		}
 	}
 });
 
+//#endregion
+//#region src/modes/toggle.ts
+const logger = getLogger(["editprompt", "toggle"]);
+const DEFAULT_EDITOR_PANE_ROWS = 12;
+function buildOpenEditorArgv(options) {
+	const invocation = options.invocation ?? {
+		execPath: process.execPath,
+		scriptPath: process.argv[1]
+	};
+	if (!invocation.scriptPath) throw new Error("Cannot determine the editprompt entrypoint");
+	const argv = [
+		invocation.execPath,
+		invocation.scriptPath,
+		"open",
+		"--mux",
+		options.mux,
+		"--target-pane",
+		options.targetPane
+	];
+	if (options.editor) argv.push("--editor", options.editor);
+	if (options.alwaysCopy) argv.push("--always-copy");
+	for (const env of options.env ?? []) argv.push("--env", env);
+	if (options.logFile) argv.push("--log-file", options.logFile);
+	if (options.quiet) argv.push("--quiet");
+	if (options.verbose) argv.push("--verbose");
+	return argv;
+}
+async function runToggleMode(options, herdrApi = herdr_exports) {
+	if (options.mux !== "herdr") throw new Error("toggle currently supports only the Herdr multiplexer");
+	if (!Number.isInteger(options.paneRows) || options.paneRows <= 0) throw new Error("--pane-rows must be a positive integer");
+	if (await herdrApi.resumeEditorPane(options.targetPane)) return;
+	const launchEnv = {};
+	if (process.env.NODE_NO_WARNINGS !== void 0) launchEnv.NODE_NO_WARNINGS = process.env.NODE_NO_WARNINGS;
+	const editorPaneId = await herdrApi.splitEditorPane(options.targetPane, options.paneRows, process.env.HERDR_ACTIVE_PANE_CWD, launchEnv);
+	try {
+		await herdrApi.runCommandInPane(editorPaneId, buildOpenEditorArgv(options));
+	} catch (error) {
+		try {
+			await herdrApi.closePane(editorPaneId);
+		} catch (closeError) {
+			logger.warn("Failed to close editor pane after launch failure: {error}", { error: closeError });
+		}
+		throw error;
+	}
+}
+const toggleCommand = define({
+	name: "toggle",
+	description: "Open or focus an editor pane",
+	args: {
+		mux: ARG_MUX,
+		"target-pane": ARG_TARGET_PANE_SINGLE,
+		"pane-rows": {
+			description: "Desired rows for the Herdr editor pane",
+			type: "number",
+			default: DEFAULT_EDITOR_PANE_ROWS
+		},
+		editor: ARG_EDITOR,
+		"always-copy": ARG_ALWAYS_COPY,
+		env: ARG_ENV,
+		"log-file": ARG_LOG_FILE,
+		quiet: ARG_QUIET,
+		verbose: ARG_VERBOSE
+	},
+	async run(ctx) {
+		const logFile = ctx.values["log-file"];
+		const quiet = Boolean(ctx.values.quiet);
+		const verbose = Boolean(ctx.values.verbose);
+		setupLogger({
+			quiet,
+			verbose,
+			logFile
+		});
+		const targetPane = validateTargetPane(ctx.values["target-pane"], "toggle");
+		const mux = validateMux(ctx.values.mux);
+		try {
+			await runToggleMode({
+				mux,
+				targetPane,
+				paneRows: Number(ctx.values["pane-rows"]),
+				alwaysCopy: Boolean(ctx.values["always-copy"]),
+				editor: ctx.values.editor,
+				env: ctx.values.env,
+				logFile,
+				quiet,
+				verbose
+			});
+		} catch (error) {
+			logger.error(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+	}
+});
+
 //#endregion
 //#region src/index.ts
 await cli(process.argv.slice(2), {
@@ -1505,6 +2128,7 @@ await cli(process.argv.slice(2), {
 		open: openCommand,
 		register: registerCommand,
 		resume: resumeCommand,
+		toggle: toggleCommand,
 		input: inputCommand,
 		press: pressCommand,
 		collect: collectCommand,