editprompt 1.4.1 → 1.6.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,12 +90,323 @@ function setupLogger(options = {}) {
 
 //#endregion
 //#region package.json
-var version = "1.4.1";
+var version = "1.6.0";
+
+//#endregion
+//#region src/config/constants.ts
+const TEMP_FILE_PREFIX = ".editprompt-";
+const TEMP_FILE_EXTENSION = ".md";
+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;
+
+//#endregion
+//#region src/utils/contentChunker.ts
+/**
+* Split content into chunks not exceeding maxBytes (UTF-8 byte count),
+* never breaking a Unicode code point across chunks.
+*
+* Content shorter than maxBytes is returned as a single chunk, so short
+* input keeps the previous behavior of being sent in one shot.
+*/
+function splitByByteSize(content, maxBytes) {
+	if (content === "") return [];
+	const chunks = [];
+	let current = "";
+	let currentBytes = 0;
+	for (const char of content) {
+		const charBytes = Buffer.byteLength(char, "utf8");
+		if (current !== "" && currentBytes + charBytes > maxBytes) {
+			chunks.push(current);
+			current = "";
+			currentBytes = 0;
+		}
+		current += char;
+		currentBytes += charBytes;
+	}
+	if (current !== "") chunks.push(current);
+	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$2,
+	clearEditorPaneId: () => clearEditorPaneId$2,
+	clearQuoteText: () => clearQuoteText$1,
+	closePane: () => closePane,
+	focusPane: () => focusPane$2,
+	getCurrentPaneId: () => getCurrentPaneId$2,
+	getEditorPaneId: () => getEditorPaneId$2,
+	getQuoteText: () => getQuoteText$1,
+	getStorageNamespace: () => getStorageNamespace,
+	getTargetPaneIds: () => getTargetPaneIds$2,
+	inputToHerdrPane: () => inputToHerdrPane,
+	isEditorPaneFromConf: () => isEditorPaneFromConf$1,
+	markAsEditorPane: () => markAsEditorPane$2,
+	resumeEditorPane: () => resumeEditorPane,
+	runCommandInPane: () => runCommandInPane,
+	saveEditorPaneId: () => saveEditorPaneId$2,
+	sendKeyToHerdrPane: () => sendKeyToHerdrPane,
+	splitEditorPane: () => splitEditorPane
+});
+const logger$13 = 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$2() {
+	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$2(paneId) {
+	try {
+		await sendRequest("pane.get", { pane_id: paneId });
+		return true;
+	} catch (error) {
+		logger$13.debug("checkPaneExists failed: {error}", { error });
+		return false;
+	}
+}
+async function focusPane$2(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(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).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$13.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$2(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$2(targetPaneId) {
+	const data = conf.get(targetPaneKey(targetPaneId));
+	if (typeof data === "object" && data !== null && "editorPaneId" in data) return String(data.editorPaneId);
+	return "";
+}
+async function clearEditorPaneId$2(targetPaneId, expectedEditorPaneId) {
+	const editorPaneId = await getEditorPaneId$2(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$2(editorPaneId, targetPaneIds) {
+	const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
+	conf.set(editorPaneKey(editorPaneId), { targetPaneIds: uniqueTargetPaneIds });
+	for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId$2(targetPaneId, editorPaneId);
+}
+async function getTargetPaneIds$2(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$2();
+	const editorPaneId = isEditorPaneFromConf$1(currentPaneId) ? currentPaneId : isEditorPaneFromConf$1(targetPaneId) ? targetPaneId : "";
+	if (editorPaneId) {
+		const targetPaneIds = await getTargetPaneIds$2(editorPaneId);
+		for (const paneId of targetPaneIds) if (await checkPaneExists$2(paneId)) {
+			await focusPane$2(paneId);
+			return true;
+		}
+		return false;
+	}
+	const registeredEditorPaneId = await getEditorPaneId$2(targetPaneId);
+	if (registeredEditorPaneId === "") return false;
+	if (!await checkPaneExists$2(registeredEditorPaneId)) {
+		await clearEditorPaneId$2(targetPaneId);
+		return false;
+	}
+	await focusPane$2(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/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;
@@ -157,18 +486,17 @@ async function sendKeyToTmuxPane(paneId, key, delay = 1e3) {
 }
 async function inputToTmuxPane(paneId, content) {
 	await execAsync$1(`tmux if-shell -t '${paneId}' '[ "#{pane_in_mode}" = "1" ]' "copy-mode -q -t '${paneId}'"`);
-	await execAsync$1(`tmux send-keys -t '${paneId}' -- '${content.replace(/'/g, "'\\''")}'`);
-	logger$11.debug("Content sent to tmux pane: {paneId}", { 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$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 {
@@ -176,26 +504,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) {
@@ -204,7 +532,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 "";
 	}
 }
@@ -214,7 +542,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) {
@@ -226,7 +554,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) {
@@ -238,7 +566,7 @@ async function getTargetPaneIds(editorPaneId) {
 		}
 		return [];
 	} catch (error) {
-		logger$10.debug("getTargetPaneIds failed: {error}", { error });
+		logger$11.debug("getTargetPaneIds failed: {error}", { error });
 		return [];
 	}
 }
@@ -246,7 +574,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;
 	}
 }
@@ -264,7 +592,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) {
@@ -273,7 +601,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 "";
 	}
 }
@@ -282,7 +610,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) {
@@ -290,8 +618,12 @@ async function sendKeyToWeztermPane(paneId, key, delay = 1e3) {
 	await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' $'${key}'`);
 }
 async function inputToWeztermPane(paneId, content) {
-	await execAsync(`wezterm cli send-text --no-paste --pane-id '${paneId}' -- '${content.replace(/'/g, "'\\''")}'`);
-	logger$10.debug("Content sent to wezterm pane: {paneId}", { paneId });
+	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$11.debug("Content sent to wezterm pane: {paneId} ({chunks} chunk(s))", {
+		paneId,
+		chunks: chunks.length
+	});
 }
 
 //#endregion
@@ -432,87 +764,36 @@ 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"
+];
 function isMuxType(value) {
-	return value === "tmux" || value === "wezterm";
+	return value === "tmux" || value === "wezterm" || value === "herdr";
 }
-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);
-}
-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 isHerdrEnvironment(env = process.env) {
+	return hasValue(env.HERDR_SOCKET_PATH) && (hasValue(env.HERDR_PANE_ID) || hasValue(env.HERDR_ACTIVE_PANE_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" : "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, or herdr; auto-detects Herdr, otherwise tmux)",
 	type: "string"
 };
 const ARG_TARGET_PANE_SINGLE = {
@@ -558,17 +839,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;
@@ -581,7 +868,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) => {
@@ -605,7 +892,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;
@@ -616,12 +903,12 @@ 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 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);
 	}
 }
@@ -648,10 +935,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") {
 			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);
 			}
 		}
@@ -661,11 +948,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;
@@ -678,7 +962,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();
@@ -687,19 +971,23 @@ 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 {
+			currentPaneId = await getCurrentPaneId$2();
+			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 targetPanes = await getTargetPaneIds$2(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 = [];
@@ -708,9 +996,12 @@ 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 {
+				content = await getQuoteText$1(targetPane);
+				await clearQuoteText$1(targetPane);
 			}
 			if (content.trim() !== "") quoteContents.push(content);
 		}
@@ -718,7 +1009,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);
 	}
 }
@@ -748,13 +1039,87 @@ 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 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 await focusPane$2(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();
@@ -763,44 +1128,51 @@ 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 {
+		currentPaneId = await getCurrentPaneId$2();
+		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 targetPanes = await getTargetPaneIds$2(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 {
 				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;
@@ -809,12 +1181,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);
 	}
 }
@@ -842,13 +1214,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();
@@ -856,12 +1228,6 @@ const inputCommand = define({
 	}
 });
 
-//#endregion
-//#region src/config/constants.ts
-const TEMP_FILE_PREFIX = ".editprompt-";
-const TEMP_FILE_EXTENSION = ".md";
-const DEFAULT_EDITOR = "vim";
-
 //#endregion
 //#region src/utils/envParser.ts
 /**
@@ -948,8 +1314,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 {}
@@ -957,16 +1324,21 @@ 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$2();
+		herdrEditorPaneId = currentPaneId;
+		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 {
@@ -975,12 +1347,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 {
@@ -990,6 +1362,9 @@ 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$2(targetPane, herdrEditorPaneId);
+		} catch {}
 	}
 }
 const openCommand = define({
@@ -1003,12 +1378,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({
@@ -1028,10 +1398,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;
@@ -1039,29 +1409,37 @@ 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$2();
+		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 {
-		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$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$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);
 	}
 }
@@ -1096,15 +1474,21 @@ 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 === "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;
@@ -1114,20 +1498,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);
 		}
@@ -1135,7 +1519,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
 			});
@@ -1186,10 +1570,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();
@@ -1198,32 +1582,37 @@ 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 {
+		currentPaneId = await getCurrentPaneId$2();
+		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 targetPanes = await getTargetPaneIds$2(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 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);
 	}
 }
@@ -1247,8 +1636,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);
@@ -1257,9 +1646,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();
@@ -1306,19 +1695,23 @@ 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 {
+		currentPaneId = await getCurrentPaneId$2();
+		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 targetPanes = await getTargetPaneIds$2(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 {
@@ -1329,13 +1722,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();
@@ -1346,8 +1739,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);
@@ -1355,18 +1748,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);
@@ -1430,14 +1823,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), {
@@ -1466,6 +1952,7 @@ await cli(process.argv.slice(2), {
 		open: openCommand,
 		register: registerCommand,
 		resume: resumeCommand,
+		toggle: toggleCommand,
 		input: inputCommand,
 		press: pressCommand,
 		collect: collectCommand,