editprompt 1.6.0 → 1.8.1

package/README.md

@@ -22,7 +22,7 @@ A CLI tool that lets you write prompts for CLI tools using your favorite text ed
 ## ✨ Features
 
 - 🖊️ **Editor Integration**: Use your preferred text editor to write prompts
-- 🖥️ **Multiplexer Support**: Send prompts directly to tmux, WezTerm, or Herdr sessions
+- 🖥️ **Multiplexer Support**: Send prompts directly to tmux, WezTerm, Herdr, or Rex sessions
 - 🖥️ **Universal Terminal Support**: Works with any terminal via clipboard - no multiplexer required
 - 📤 **Send Without Closing**: Iterate on prompts without closing your editor
 - 📋 **Quote Buffering**: Collect text selections and send them as quoted replies
@@ -187,6 +187,92 @@ Run the binding from a target pane. editprompt opens a regular bottom split for
 
 Inside a Herdr pane, editprompt automatically selects the Herdr backend when `HERDR_SOCKET_PATH` and a pane ID are available. An explicit `--mux` option or `EDITPROMPT_MUX` value takes precedence, so the binding above keeps `--mux herdr` to make its intent clear.
 
+### Rex Integration
+
+[Rex](https://www.superlogical.com/rex/docs) is configured in Lua, and its configuration file can both run commands and build layouts, so the binding does the splitting and editprompt only opens the editor. Add this to `~/.config/rex/init.lua`:
+
+```lua
+-- Height of the editor pane, in rows. new_split takes a fraction, so it is
+-- derived from the target pane's current height; a fixed fraction would make
+-- the editor grow with the window. PANE_CHROME_ROWS is what a pane spends on
+-- its header and border, which hold no text.
+local EDITOR_ROWS = 12
+local PANE_CHROME_ROWS = 3
+
+local function editor_ratio(block_id)
+  local size = rex.block.call("com.superlogical.terminal", "size", { block_id = block_id })
+  local rows = size and size.rows
+  if not rows or rows <= 1 then
+    return 0.8
+  end
+  -- Never let the editor take more than half, for a pane too short to spare the
+  -- rows, and stay inside the fraction new_split accepts.
+  return math.max(0.5, math.min(0.9, 1 - (EDITOR_ROWS + PANE_CHROME_ROWS) / rows))
+end
+
+-- Start the editor in the directory the target pane last reported. A shell that
+-- uses OSC 7, such as nushell, reports it as a file:// URL.
+local function pane_cwd(block_id)
+  local result = rex.block.call("com.superlogical.terminal", "pwd", { block_id = block_id })
+  local pwd = result and result.pwd
+  if not pwd then
+    return nil
+  end
+  return (pwd:gsub("^file://[^/]*", ""))
+end
+
+rex.bind("alt+q", function(ctx)
+  -- Focus an editor pane that is already open, or, when pressed from the editor
+  -- pane, go back to the target pane.
+  local resumed, err = rex.exec({
+    "editprompt", "resume", "--mux", "rex", "--target-pane", ctx.block_id,
+  })
+  if not resumed then
+    -- The command never ran at all, which is not the same as having no editor
+    -- pane to go back to. Say so rather than opening a split that would fail
+    -- the same way.
+    rex.log("error", "editprompt could not be run: " .. tostring(err))
+    return true
+  end
+  if resumed.ok then
+    return true
+  end
+
+  rex.session.new_split{
+    anchor_id = ctx.block_id,
+    direction = "vertical",
+    side = "after",
+    ratio = editor_ratio(ctx.block_id),
+    focus = true,
+    layout = rex.layout.block{
+      flavor = "com.superlogical.terminal.shell",
+      options = {
+        command = {
+          "editprompt", "open", "--mux", "rex",
+          "--target-pane", ctx.block_id, "--editor", "nvim", "--always-copy",
+        },
+        cwd = pane_cwd(ctx.block_id),
+      },
+    },
+  }
+  return true
+end)
+```
+
+Reload it with `rex config reload`; Rex does not watch the file for changes. `rex config check` reports mistakes without applying them.
+
+`ratio` is the share the `before` part keeps, which here is the target pane, so a larger value leaves the editor less room. `direction = "vertical"` stacks the panes and `side = "after"` puts the new one below. `EDITOR_ROWS` is the knob worth tuning: it keeps the editor the same height whatever the window's size, the way `--pane-rows` does for Herdr.
+
+**Turn off the app's "Autobalance Splits" setting.** With it on, Rex equalises every pane as soon as a block is created, which discards the `ratio` the binding asked for and leaves the editor half the window. Setting the border afterwards with `session.resize_pane` does not help either: the equalisation lands after it. `focus` defaults to false, so the binding asks for it explicitly. The pane closes once the editor exits, which is Rex's default for a terminal started with a `command`; it stays open after a quick failure instead, so a startup error remains readable.
+
+editprompt locates the `rex` CLI through `REX_BIN_DIR`, which Rex sets in every terminal it opens, and falls back to the PATH. That matters because the login shell can rebuild PATH and drop the directory Rex added. On NixOS and nix-darwin it does, and the fix Rex documents for that runs in interactive shells only, which a terminal started from `init.lua` is not.
+
+`rex.exec` runs in the Rex server's environment rather than a shell's, so give `editprompt` an absolute path there if the server's PATH does not include it.
+
+Name the editor with `--editor`. A terminal Rex starts gets the login shell's environment, not the interactive one, so `$EDITOR` is whatever that environment sets rather than what your prompt uses — on nix-darwin, for instance, it is `nano`.
+
+Inside a Rex pane, editprompt automatically selects the Rex backend when `REX_BLOCK` is set. Running tmux inside a Rex pane sets both, and Rex wins, so pass `--mux tmux` or set `EDITPROMPT_MUX` for that case.
+
 ### Editor Integration (Send Without Closing)
 
 While editprompt is running, you can send content to the target pane or clipboard without closing the editor. This allows you to iterate quickly on your prompts.
@@ -205,7 +291,7 @@ editprompt input --auto-send -- "your content here"
 editprompt input --auto-send --send-key "C-m" -- "your content here"
 # Customize the key to send after content (tmux format example)
 # WezTerm example: --send-key "\r"
-# Herdr example: --send-key "enter"
+# Herdr and Rex example: --send-key "enter"
 ```
 
 This sends the content to the target pane (or clipboard) while keeping your editor open, so you can continue editing and send multiple times.
@@ -217,6 +303,7 @@ This sends the content to the target pane (or clipboard) while keeping your edit
   - tmux format: `Enter` (default), `C-a`, etc.
   - WezTerm format: `\r` (default), `\x01`, etc.
   - Herdr format: `enter` (default), `ctrl+a`, etc.
+  - Rex format: `enter` (default), `ctrl+a`, etc.
 
 #### Neovim Integration
 
@@ -236,7 +323,7 @@ editprompt press -- Up
 editprompt press -- C-m    # Enter
 editprompt press -- C-c    # Ctrl+C
 
-# Herdr examples
+# Herdr and Rex examples
 editprompt press -- enter
 editprompt press -- ctrl+c
 
@@ -252,12 +339,12 @@ editprompt press --delay 500 -- Tab
 
 **Key notation** depends on your multiplexer:
 
-| Key           | tmux          | WezTerm             | Herdr         |
-| ------------- | ------------- | ------------------- | ------------- |
-| Enter         | `C-m`         | `\r`                | `enter`       |
-| Tab           | `Tab`         | `\t`                | `tab`         |
-| Escape        | `Escape`      | `\x1b`              | `esc`         |
-| Arrow Up/Down | `Up` / `Down` | `\x1b[A` / `\x1b[B` | `up` / `down` |
+| Key           | tmux          | WezTerm             | Herdr         | Rex           |
+| ------------- | ------------- | ------------------- | ------------- | ------------- |
+| Enter         | `C-m`         | `\r`                | `enter`       | `enter`       |
+| Tab           | `Tab`         | `\t`                | `tab`         | `tab`         |
+| Escape        | `Escape`      | `\x1b`              | `esc`         | `escape`      |
+| Arrow Up/Down | `Up` / `Down` | `\x1b[A` / `\x1b[B` | `up` / `down` | `up` / `down` |
 
 ### Quote Workflow Setup
 
@@ -327,6 +414,22 @@ editprompt collect --mux herdr --target-pane "$HERDR_PANE_ID" -- "selected text"
 
 This can be called from a script or editor integration that has access to the selected text. Herdr quote buffers are stored in editprompt's configuration, associated with the target pane.
 
+#### Collecting Quotes in Rex
+
+Pass selected text as an argument together with the target block ID:
+
+```bash
+editprompt collect --mux rex --target-pane "$REX_BLOCK" -- "selected text"
+```
+
+From `init.lua`, call it with `rex.exec`, which takes an argv table so the text needs no quoting:
+
+```lua
+rex.exec({ "editprompt", "collect", "--mux", "rex", "--target-pane", ctx.block_id, "--", text })
+```
+
+As with Herdr, Rex quote buffers live in editprompt's configuration, associated with the target pane.
+
 #### Capturing Collected Quotes
 
 Run this command from within your editor pane to retrieve all collected quotes:

package/dist/index.js

@@ -7,10 +7,10 @@ import { createConnection } from "node:net";
 import Conf from "conf";
 import { exec, spawn } from "node:child_process";
 import { promisify } from "node:util";
+import { join } from "node:path";
 import clipboardy from "clipboardy";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
 
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -90,7 +90,7 @@ function setupLogger(options = {}) {
 
 //#endregion
 //#region package.json
-var version = "1.6.0";
+var version = "1.8.1";
 
 //#endregion
 //#region src/config/constants.ts
@@ -102,6 +102,9 @@ 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;
+const REX_CONTROL_LIMIT_BYTES = 64 * 1024;
+const REX_SEND_CHUNK_BYTES = REX_CONTROL_LIMIT_BYTES / 8;
 
 //#endregion
 //#region src/utils/contentChunker.ts
@@ -139,28 +142,28 @@ const conf = new Conf({ projectName });
 //#endregion
 //#region src/modules/herdr.ts
 var herdr_exports = /* @__PURE__ */ __exportAll({
-	appendToQuoteText: () => appendToQuoteText$1,
+	appendToQuoteText: () => appendToQuoteText$2,
 	calculateEditorSplitRatio: () => calculateEditorSplitRatio,
-	checkPaneExists: () => checkPaneExists$2,
-	clearEditorPaneId: () => clearEditorPaneId$2,
-	clearQuoteText: () => clearQuoteText$1,
+	checkPaneExists: () => checkPaneExists$4,
+	clearEditorPaneId: () => clearEditorPaneId$4,
+	clearQuoteText: () => clearQuoteText$2,
 	closePane: () => closePane,
-	focusPane: () => focusPane$2,
-	getCurrentPaneId: () => getCurrentPaneId$2,
-	getEditorPaneId: () => getEditorPaneId$2,
-	getQuoteText: () => getQuoteText$1,
+	focusPane: () => focusPane$4,
+	getCurrentPaneId: () => getCurrentPaneId$4,
+	getEditorPaneId: () => getEditorPaneId$4,
+	getQuoteText: () => getQuoteText$2,
 	getStorageNamespace: () => getStorageNamespace,
-	getTargetPaneIds: () => getTargetPaneIds$2,
+	getTargetPaneIds: () => getTargetPaneIds$4,
 	inputToHerdrPane: () => inputToHerdrPane,
-	isEditorPaneFromConf: () => isEditorPaneFromConf$1,
-	markAsEditorPane: () => markAsEditorPane$2,
-	resumeEditorPane: () => resumeEditorPane,
+	isEditorPaneFromConf: () => isEditorPaneFromConf$2,
+	markAsEditorPane: () => markAsEditorPane$4,
+	resumeEditorPane: () => resumeEditorPane$1,
 	runCommandInPane: () => runCommandInPane,
-	saveEditorPaneId: () => saveEditorPaneId$2,
+	saveEditorPaneId: () => saveEditorPaneId$4,
 	sendKeyToHerdrPane: () => sendKeyToHerdrPane,
 	splitEditorPane: () => splitEditorPane
 });
-const logger$13 = getLogger(["editprompt", "herdr"]);
+const logger$15 = getLogger(["editprompt", "herdr"]);
 const HERDR_REQUEST_TIMEOUT_MS = 6e3;
 let requestSequence = 0;
 function getSocketPath() {
@@ -241,27 +244,27 @@ async function sendRequest(method, params) {
 function getStorageNamespace() {
 	return `herdr.session_${createHash("sha256").update(getSocketPath()).digest("hex").slice(0, 16)}`;
 }
-function targetPaneKey(paneId) {
+function targetPaneKey$1(paneId) {
 	return `${getStorageNamespace()}.targetPane.pane_${paneId}`;
 }
-function editorPaneKey(paneId) {
+function editorPaneKey$1(paneId) {
 	return `${getStorageNamespace()}.editorPane.pane_${paneId}`;
 }
-async function getCurrentPaneId$2() {
+async function getCurrentPaneId$4() {
 	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) {
+async function checkPaneExists$4(paneId) {
 	try {
 		await sendRequest("pane.get", { pane_id: paneId });
 		return true;
 	} catch (error) {
-		logger$13.debug("checkPaneExists failed: {error}", { error });
+		logger$15.debug("checkPaneExists failed: {error}", { error });
 		return false;
 	}
 }
-async function focusPane$2(paneId) {
+async function focusPane$4(paneId) {
 	await sendRequest("pane.focus", { pane_id: paneId });
 }
 function calculateEditorSplitRatio(paneHeight, editorPaneRows) {
@@ -284,14 +287,14 @@ async function splitEditorPane(targetPaneId, editorPaneRows, cwd, env = {}) {
 	if (typeof editorPaneId !== "string" || editorPaneId === "") throw new Error("Herdr pane.split did not return the new pane ID");
 	return editorPaneId;
 }
-function quoteShellWord(value) {
+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).join(" ")}`,
+		text: `exec ${argv.map(quoteShellWord$1).join(" ")}`,
 		keys: ["Enter"]
 	});
 }
@@ -304,7 +307,7 @@ async function inputToHerdrPane(paneId, content) {
 		pane_id: paneId,
 		text: chunk
 	});
-	logger$13.debug("Content sent to Herdr pane: {paneId} ({chunkCount} chunks)", {
+	logger$15.debug("Content sent to Herdr pane: {paneId} ({chunkCount} chunks)", {
 		paneId,
 		chunkCount: chunks.length
 	});
@@ -316,6 +319,264 @@ async function sendKeyToHerdrPane(paneId, key, delay = 1e3) {
 		keys: [key]
 	});
 }
+async function saveEditorPaneId$4(targetPaneId, editorPaneId) {
+	const data = conf.get(targetPaneKey$1(targetPaneId));
+	const existing = typeof data === "object" && data !== null ? data : {};
+	conf.set(targetPaneKey$1(targetPaneId), {
+		...existing,
+		editorPaneId
+	});
+}
+async function getEditorPaneId$4(targetPaneId) {
+	const data = conf.get(targetPaneKey$1(targetPaneId));
+	if (typeof data === "object" && data !== null && "editorPaneId" in data) return String(data.editorPaneId);
+	return "";
+}
+async function clearEditorPaneId$4(targetPaneId, expectedEditorPaneId) {
+	const editorPaneId = await getEditorPaneId$4(targetPaneId);
+	if (expectedEditorPaneId && editorPaneId !== expectedEditorPaneId) {
+		conf.delete(editorPaneKey$1(expectedEditorPaneId));
+		return;
+	}
+	const data = conf.get(targetPaneKey$1(targetPaneId));
+	if (typeof data === "object" && data !== null && "editorPaneId" in data) {
+		const { editorPaneId: _, ...remaining } = data;
+		if (Object.keys(remaining).length === 0) conf.delete(targetPaneKey$1(targetPaneId));
+		else conf.set(targetPaneKey$1(targetPaneId), remaining);
+	}
+	if (editorPaneId) conf.delete(editorPaneKey$1(editorPaneId));
+}
+async function markAsEditorPane$4(editorPaneId, targetPaneIds) {
+	const uniqueTargetPaneIds = [...new Set(targetPaneIds)];
+	conf.set(editorPaneKey$1(editorPaneId), { targetPaneIds: uniqueTargetPaneIds });
+	for (const targetPaneId of uniqueTargetPaneIds) await saveEditorPaneId$4(targetPaneId, editorPaneId);
+}
+async function getTargetPaneIds$4(editorPaneId) {
+	const data = conf.get(editorPaneKey$1(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$2(paneId) {
+	return conf.has(editorPaneKey$1(paneId));
+}
+async function resumeEditorPane$1(targetPaneId) {
+	const currentPaneId = await getCurrentPaneId$4();
+	const editorPaneId = isEditorPaneFromConf$2(currentPaneId) ? currentPaneId : isEditorPaneFromConf$2(targetPaneId) ? targetPaneId : "";
+	if (editorPaneId) {
+		const targetPaneIds = await getTargetPaneIds$4(editorPaneId);
+		for (const paneId of targetPaneIds) if (await checkPaneExists$4(paneId)) {
+			await focusPane$4(paneId);
+			return true;
+		}
+		return false;
+	}
+	const registeredEditorPaneId = await getEditorPaneId$4(targetPaneId);
+	if (registeredEditorPaneId === "") return false;
+	if (!await checkPaneExists$4(registeredEditorPaneId)) {
+		await clearEditorPaneId$4(targetPaneId);
+		return false;
+	}
+	await focusPane$4(registeredEditorPaneId);
+	return true;
+}
+async function appendToQuoteText$2(paneId, content) {
+	const data = conf.get(targetPaneKey$1(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$1(paneId), {
+		...existing,
+		quote_text: quoteText
+	});
+}
+async function getQuoteText$2(paneId) {
+	const data = conf.get(targetPaneKey$1(paneId));
+	if (typeof data === "object" && data !== null && "quote_text" in data) return String(data.quote_text);
+	return "";
+}
+async function clearQuoteText$2(paneId) {
+	const data = conf.get(targetPaneKey$1(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$1(paneId));
+		else conf.set(targetPaneKey$1(paneId), remaining);
+	}
+}
+
+//#endregion
+//#region src/modules/niwaterm.ts
+const execAsync$2 = promisify(exec);
+const logger$14 = 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$3() {
+	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$14.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$3(paneId) {
+	try {
+		await execAsync$2(`niwa tab var list -t ${quoteShellWord(paneId)}`);
+		return true;
+	} catch (error) {
+		logger$14.debug("checkPaneExists failed: {error}", { error });
+		return false;
+	}
+}
+async function focusPane$3(paneId) {
+	await execAsync$2(`niwa tab focus -t ${quoteShellWord(paneId)}`);
+}
+async function saveEditorPaneId$3(targetPaneId, editorPaneId) {
+	await setTabVar(targetPaneId, VAR_EDITOR_PANE, editorPaneId);
+}
+async function clearEditorPaneId$3(targetPaneId) {
+	await setTabVar(targetPaneId, VAR_EDITOR_PANE, "");
+}
+async function getEditorPaneId$3(targetPaneId) {
+	return getTabVar(targetPaneId, VAR_EDITOR_PANE);
+}
+async function markAsEditorPane$3(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$3(targetPaneId, editorPaneId);
+}
+async function getTargetPaneIds$3(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$14.debug("Content sent to niwaterm pane: {paneId} ({chunks} chunk(s))", {
+		paneId,
+		chunks: chunks.length
+	});
+}
+
+//#endregion
+//#region src/modules/rex.ts
+const logger$13 = getLogger(["editprompt", "rex"]);
+const REX_COMMAND = "rex";
+const REX_GLOBAL_ARGS = ["--autostart=false"];
+function rexCommand() {
+	const binDir = process.env.REX_BIN_DIR?.trim();
+	return binDir ? join(binDir, REX_COMMAND) : REX_COMMAND;
+}
+function targetPaneKey(paneId) {
+	return `rex.targetPane.pane_${paneId}`;
+}
+function editorPaneKey(paneId) {
+	return `rex.editorPane.pane_${paneId}`;
+}
+function rexArgs(args) {
+	return [...REX_GLOBAL_ARGS, ...args];
+}
+function runRex(args, input) {
+	const command = rexCommand();
+	const argv = rexArgs(args);
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, argv, { stdio: [
+			input === void 0 ? "ignore" : "pipe",
+			"pipe",
+			"pipe"
+		] });
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.setEncoding("utf8");
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr?.setEncoding("utf8");
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => {
+			reject(/* @__PURE__ */ new Error(`Failed to run rex: ${error.message}`));
+		});
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolve(stdout);
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`rex ${argv.join(" ")} exited with ${code}: ${stderr.trim()}`));
+		});
+		if (input !== void 0) {
+			if (!child.stdin) {
+				reject(/* @__PURE__ */ new Error("rex was started without a standard input to write to"));
+				return;
+			}
+			child.stdin.on("error", (error) => {
+				reject(/* @__PURE__ */ new Error(`Failed to write to rex: ${error.message}`));
+			});
+			child.stdin.end(input);
+		}
+	});
+}
+async function getCurrentPaneId$2() {
+	const paneId = process.env.REX_BLOCK?.trim();
+	if (!paneId) throw new Error("REX_BLOCK is not set");
+	return paneId;
+}
+async function checkPaneExists$2(paneId) {
+	try {
+		await runRex([
+			"block",
+			"inspect",
+			paneId,
+			"--json"
+		]);
+		return true;
+	} catch (error) {
+		logger$13.debug("checkPaneExists failed: {error}", { error });
+		return false;
+	}
+}
+async function focusPane$2(paneId) {
+	await runRex([
+		"block",
+		"focus",
+		paneId
+	]);
+}
 async function saveEditorPaneId$2(targetPaneId, editorPaneId) {
 	const data = conf.get(targetPaneKey(targetPaneId));
 	const existing = typeof data === "object" && data !== null ? data : {};
@@ -329,12 +590,8 @@ async function getEditorPaneId$2(targetPaneId) {
 	if (typeof data === "object" && data !== null && "editorPaneId" in data) return String(data.editorPaneId);
 	return "";
 }
-async function clearEditorPaneId$2(targetPaneId, expectedEditorPaneId) {
+async function clearEditorPaneId$2(targetPaneId) {
 	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;
@@ -402,6 +659,27 @@ async function clearQuoteText$1(paneId) {
 		else conf.set(targetPaneKey(paneId), remaining);
 	}
 }
+async function inputToRexPane(paneId, content) {
+	const chunks = splitByByteSize(content, REX_SEND_CHUNK_BYTES);
+	for (const chunk of chunks) await runRex([
+		"send",
+		"-b",
+		paneId
+	], chunk);
+	logger$13.debug("Content sent to Rex pane: {paneId} ({chunks} chunk(s))", {
+		paneId,
+		chunks: chunks.length
+	});
+}
+async function sendKeyToRexPane(paneId, key, delay = 1e3) {
+	await new Promise((resolve) => setTimeout(resolve, delay));
+	await runRex([
+		"send-key",
+		"-b",
+		paneId,
+		key
+	]);
+}
 
 //#endregion
 //#region src/modules/tmux.ts
@@ -768,10 +1046,12 @@ function processQuoteText(text, options) {
 const SUPPORTED_MUXES = [
 	"tmux",
 	"wezterm",
-	"herdr"
+	"herdr",
+	"niwaterm",
+	"rex"
 ];
 function isMuxType(value) {
-	return value === "tmux" || value === "wezterm" || value === "herdr";
+	return value === "tmux" || value === "wezterm" || value === "herdr" || value === "niwaterm" || value === "rex";
 }
 function hasValue(value) {
 	return typeof value === "string" && value.trim() !== "";
@@ -779,8 +1059,14 @@ function hasValue(value) {
 function isHerdrEnvironment(env = process.env) {
 	return hasValue(env.HERDR_SOCKET_PATH) && (hasValue(env.HERDR_PANE_ID) || hasValue(env.HERDR_ACTIVE_PANE_ID));
 }
+function isNiwatermEnvironment(env = process.env) {
+	return hasValue(env.NIWATERM_TAB_ID);
+}
+function isRexEnvironment(env = process.env) {
+	return hasValue(env.REX_BLOCK);
+}
 function resolveMux(explicitMux, env = process.env) {
-	const muxValue = explicitMux || env.EDITPROMPT_MUX || (isHerdrEnvironment(env) ? "herdr" : "tmux");
+	const muxValue = explicitMux || env.EDITPROMPT_MUX || (isHerdrEnvironment(env) ? "herdr" : isNiwatermEnvironment(env) ? "niwaterm" : isRexEnvironment(env) ? "rex" : "tmux");
 	if (!isMuxType(muxValue)) {
 		const displayValue = typeof muxValue === "string" ? muxValue : `<${typeof muxValue}>`;
 		throw new Error(`Invalid multiplexer type '${displayValue}'. Supported values: ${SUPPORTED_MUXES.join(", ")}`);
@@ -793,7 +1079,7 @@ function resolveMux(explicitMux, env = process.env) {
 const logger$10 = getLogger(["editprompt"]);
 const ARG_MUX = {
 	short: "m",
-	description: "Multiplexer type (tmux, wezterm, or herdr; auto-detects Herdr, otherwise tmux)",
+	description: "Multiplexer type (tmux, wezterm, herdr, niwaterm, or rex; auto-detects Herdr, niwaterm and Rex, otherwise tmux)",
 	type: "string"
 };
 const ARG_TARGET_PANE_SINGLE = {
@@ -905,7 +1191,9 @@ async function runCollectMode(mux, targetPaneId, rawContent, outputs = ["buffer"
 		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 await appendToQuoteText$1(targetPaneId, processedText);
+		else if (mux === "niwaterm") await appendToQuoteVariable$1(targetPaneId, processedText);
+		else if (mux === "rex") await appendToQuoteText$1(targetPaneId, processedText);
+		else await appendToQuoteText$2(targetPaneId, processedText);
 		else if (output === "stdout") process.stdout.write(processedText);
 	} catch (error) {
 		logger$9.error(`${error instanceof Error ? error.message : "Unknown error"}`);
@@ -935,7 +1223,7 @@ const collectCommand = define({
 		const outputs = normalizeCollectOutputs(ctx.values.output);
 		const withQuote = !ctx.values["no-quote"];
 		let rawContent;
-		if (mux === "wezterm" || mux === "herdr") {
+		if (mux === "wezterm" || mux === "herdr" || mux === "niwaterm" || mux === "rex") {
 			rawContent = extractRawContent(ctx.rest, ctx.positionals);
 			if (rawContent === void 0) {
 				logger$9.error(`Text content is required for collect mode with ${mux}. Use: editprompt collect --mux ${mux} --target-pane <id> -- "<text>"`);
@@ -974,9 +1262,15 @@ async function runDumpMode() {
 		} else if (config.mux === "wezterm") {
 			currentPaneId = await getCurrentPaneId();
 			isEditor = isEditorPaneFromConf(currentPaneId);
-		} else {
+		} else if (config.mux === "niwaterm") {
+			currentPaneId = await getCurrentPaneId$3();
+			isEditor = await isEditorPane$1(currentPaneId);
+		} else if (config.mux === "rex") {
 			currentPaneId = await getCurrentPaneId$2();
 			isEditor = isEditorPaneFromConf$1(currentPaneId);
+		} else {
+			currentPaneId = await getCurrentPaneId$4();
+			isEditor = isEditorPaneFromConf$2(currentPaneId);
 		}
 		if (!isEditor) {
 			logger$8.error("Current pane is not an editor pane");
@@ -985,7 +1279,9 @@ async function runDumpMode() {
 		let targetPanes;
 		if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
 		else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
-		else targetPanes = await getTargetPaneIds$2(currentPaneId);
+		else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$3(currentPaneId);
+		else if (config.mux === "rex") targetPanes = await getTargetPaneIds$2(currentPaneId);
+		else targetPanes = await getTargetPaneIds$4(currentPaneId);
 		if (targetPanes.length === 0) {
 			logger$8.error("No target panes registered for this editor pane");
 			process.exit(1);
@@ -999,9 +1295,15 @@ async function runDumpMode() {
 			} else if (config.mux === "wezterm") {
 				content = await getQuoteText(targetPane);
 				await clearQuoteText(targetPane);
-			} else {
+			} else if (config.mux === "niwaterm") {
+				content = await getQuoteVariableContent$1(targetPane);
+				await clearQuoteVariable$1(targetPane);
+			} else if (config.mux === "rex") {
 				content = await getQuoteText$1(targetPane);
 				await clearQuoteText$1(targetPane);
+			} else {
+				content = await getQuoteText$2(targetPane);
+				await clearQuoteText$2(targetPane);
 			}
 			if (content.trim() !== "") quoteContents.push(content);
 		}
@@ -1048,13 +1350,17 @@ async function copyToClipboard(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 if (mux === "rex") await inputToRexPane(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);
+	else if (mux === "niwaterm") await focusPane$3(firstSuccessPane);
+	else if (mux === "rex") await focusPane$2(firstSuccessPane);
+	else await focusPane$4(firstSuccessPane);
 }
 async function handleContentDelivery(content, mux, targetPanes) {
 	if (!content) return {
@@ -1131,9 +1437,15 @@ async function runInputMode(rawContent, autoSend, sendKey, sendKeyDelay) {
 	} else if (config.mux === "wezterm") {
 		currentPaneId = await getCurrentPaneId();
 		isEditor = isEditorPaneFromConf(currentPaneId);
-	} else {
+	} else if (config.mux === "niwaterm") {
+		currentPaneId = await getCurrentPaneId$3();
+		isEditor = await isEditorPane$1(currentPaneId);
+	} else if (config.mux === "rex") {
 		currentPaneId = await getCurrentPaneId$2();
 		isEditor = isEditorPaneFromConf$1(currentPaneId);
+	} else {
+		currentPaneId = await getCurrentPaneId$4();
+		isEditor = isEditorPaneFromConf$2(currentPaneId);
 	}
 	if (!isEditor) {
 		logger$6.error("Current pane is not an editor pane");
@@ -1142,13 +1454,15 @@ async function runInputMode(rawContent, autoSend, sendKey, sendKeyDelay) {
 	let targetPanes;
 	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
 	else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
-	else targetPanes = await getTargetPaneIds$2(currentPaneId);
+	else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$3(currentPaneId);
+	else if (config.mux === "rex") targetPanes = await getTargetPaneIds$2(currentPaneId);
+	else targetPanes = await getTargetPaneIds$4(currentPaneId);
 	if (targetPanes.length === 0) {
 		logger$6.error("No target panes registered for this editor pane");
 		process.exit(1);
 	}
 	if (autoSend) {
-		const key = sendKey || (config.mux === "wezterm" ? "\\r" : config.mux === "herdr" ? "enter" : "C-m");
+		const key = sendKey || (config.mux === "wezterm" ? "\\r" : config.mux === "herdr" || config.mux === "rex" ? "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 {
@@ -1158,6 +1472,12 @@ async function runInputMode(rawContent, autoSend, sendKey, sendKeyDelay) {
 			} 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 if (config.mux === "rex") {
+				await inputToRexPane(targetPane, content);
+				await sendKeyToRexPane(targetPane, key, delay);
 			} else {
 				await inputToTmuxPane(targetPane, content);
 				await sendKeyToTmuxPane(targetPane, key, delay);
@@ -1325,8 +1645,16 @@ async function runOpenEditorMode(options) {
 		await markAsEditorPane(currentPaneId, options.targetPanes);
 	} catch {}
 	else if (options.targetPanes.length > 0 && options.mux === "herdr") try {
-		const currentPaneId = await getCurrentPaneId$2();
+		const currentPaneId = await getCurrentPaneId$4();
 		herdrEditorPaneId = currentPaneId;
+		await markAsEditorPane$4(currentPaneId, options.targetPanes);
+	} catch {}
+	else if (options.targetPanes.length > 0 && options.mux === "niwaterm") try {
+		const currentPaneId = await getCurrentPaneId$3();
+		await markAsEditorPane$3(currentPaneId, options.targetPanes);
+	} catch {}
+	else if (options.targetPanes.length > 0 && options.mux === "rex") try {
+		const currentPaneId = await getCurrentPaneId$2();
 		await markAsEditorPane$2(currentPaneId, options.targetPanes);
 	} catch {}
 	try {
@@ -1363,7 +1691,13 @@ async function runOpenEditorMode(options) {
 			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);
+			for (const targetPane of options.targetPanes) await clearEditorPaneId$4(targetPane, herdrEditorPaneId);
+		} catch {}
+		else if (options.targetPanes.length > 0 && options.mux === "niwaterm") try {
+			for (const targetPane of options.targetPanes) await clearEditorPaneId$3(targetPane);
+		} catch {}
+		else if (options.targetPanes.length > 0 && options.mux === "rex") try {
+			for (const targetPane of options.targetPanes) await clearEditorPaneId$2(targetPane);
 		} catch {}
 	}
 }
@@ -1419,6 +1753,18 @@ async function runRegisterMode(options) {
 			process.exit(1);
 		}
 	} else if (options.mux === "herdr") {
+		editorPaneId = await getCurrentPaneId$4();
+		if (!isEditorPaneFromConf$2(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$3();
+		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 if (options.mux === "rex") {
 		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.");
@@ -1432,11 +1778,15 @@ async function runRegisterMode(options) {
 		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);
+		else if (options.mux === "herdr") existingPanes = await getTargetPaneIds$4(editorPaneId);
+		else if (options.mux === "niwaterm") existingPanes = await getTargetPaneIds$3(editorPaneId);
+		else if (options.mux === "rex") 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);
-		else if (options.mux === "herdr") await markAsEditorPane$2(editorPaneId, mergedTargetPanes);
+		else if (options.mux === "herdr") await markAsEditorPane$4(editorPaneId, mergedTargetPanes);
+		else if (options.mux === "niwaterm") await markAsEditorPane$3(editorPaneId, mergedTargetPanes);
+		else if (options.mux === "rex") await markAsEditorPane$2(editorPaneId, mergedTargetPanes);
 		logger$4.info(`Editor pane ${editorPaneId} registered with target panes: ${mergedTargetPanes.join(", ")}`);
 	} catch (error) {
 		logger$4.error(`${error instanceof Error ? error.message : "Unknown error"}`);
@@ -1477,11 +1827,61 @@ const registerCommand = define({
 const logger$3 = getLogger(["editprompt", "resume"]);
 async function runResumeMode(targetPane, mux) {
 	if (mux === "herdr") try {
-		process.exit(await resumeEditorPane(targetPane) ? 0 : 1);
+		process.exit(await resumeEditorPane$1(targetPane) ? 0 : 1);
 	} catch (error) {
 		logger$3.debug("Herdr resume failed: {error}", { error });
 		process.exit(1);
 	}
+	if (mux === "rex") try {
+		process.exit(await resumeEditorPane(targetPane) ? 0 : 1);
+	} catch (error) {
+		logger$3.debug("Rex resume failed: {error}", { error });
+		process.exit(1);
+	}
+	if (mux === "niwaterm") {
+		const currentPaneId = await getCurrentPaneId$3();
+		if (await isEditorPane$1(currentPaneId)) {
+			logger$3.debug("Current pane is an editor pane");
+			const originalTargetPaneIds = await getTargetPaneIds$3(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$3(paneId)) {
+				await focusPane$3(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$3(targetPane);
+		logger$3.debug("niwaterm editorPaneId: {editorPaneId}", { editorPaneId });
+		if (editorPaneId === "") {
+			logger$3.debug("Editor pane ID not found");
+			process.exit(1);
+		}
+		if (!await checkPaneExists$3(editorPaneId)) {
+			logger$3.debug("Editor pane does not exist");
+			await clearEditorPaneId$3(targetPane);
+			process.exit(1);
+		}
+		try {
+			await focusPane$3(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)) {
@@ -1585,9 +1985,15 @@ async function runPressMode(key, delay = 0) {
 	} else if (config.mux === "wezterm") {
 		currentPaneId = await getCurrentPaneId();
 		isEditor = isEditorPaneFromConf(currentPaneId);
-	} else {
+	} else if (config.mux === "niwaterm") {
+		currentPaneId = await getCurrentPaneId$3();
+		isEditor = await isEditorPane$1(currentPaneId);
+	} else if (config.mux === "rex") {
 		currentPaneId = await getCurrentPaneId$2();
 		isEditor = isEditorPaneFromConf$1(currentPaneId);
+	} else {
+		currentPaneId = await getCurrentPaneId$4();
+		isEditor = isEditorPaneFromConf$2(currentPaneId);
 	}
 	if (!isEditor) {
 		logger$2.error("Current pane is not an editor pane");
@@ -1596,7 +2002,9 @@ async function runPressMode(key, delay = 0) {
 	let targetPanes;
 	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
 	else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
-	else targetPanes = await getTargetPaneIds$2(currentPaneId);
+	else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$3(currentPaneId);
+	else if (config.mux === "rex") targetPanes = await getTargetPaneIds$2(currentPaneId);
+	else targetPanes = await getTargetPaneIds$4(currentPaneId);
 	if (targetPanes.length === 0) {
 		logger$2.error("No target panes registered for this editor pane");
 		process.exit(1);
@@ -1605,6 +2013,8 @@ async function runPressMode(key, delay = 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 if (config.mux === "rex") await sendKeyToRexPane(targetPane, key, delay);
 		else await sendKeyToTmuxPane(targetPane, key, delay);
 		successCount++;
 	} catch (error) {
@@ -1698,9 +2108,15 @@ async function getTargetPaneForStash() {
 	} else if (config.mux === "wezterm") {
 		currentPaneId = await getCurrentPaneId();
 		isEditor = isEditorPaneFromConf(currentPaneId);
-	} else {
+	} else if (config.mux === "niwaterm") {
+		currentPaneId = await getCurrentPaneId$3();
+		isEditor = await isEditorPane$1(currentPaneId);
+	} else if (config.mux === "rex") {
 		currentPaneId = await getCurrentPaneId$2();
 		isEditor = isEditorPaneFromConf$1(currentPaneId);
+	} else {
+		currentPaneId = await getCurrentPaneId$4();
+		isEditor = isEditorPaneFromConf$2(currentPaneId);
 	}
 	if (!isEditor) {
 		logger$1.error("Current pane is not an editor pane");
@@ -1709,7 +2125,9 @@ async function getTargetPaneForStash() {
 	let targetPanes;
 	if (config.mux === "tmux") targetPanes = await getTargetPaneIds$1(currentPaneId);
 	else if (config.mux === "wezterm") targetPanes = await getTargetPaneIds(currentPaneId);
-	else targetPanes = await getTargetPaneIds$2(currentPaneId);
+	else if (config.mux === "niwaterm") targetPanes = await getTargetPaneIds$3(currentPaneId);
+	else if (config.mux === "rex") targetPanes = await getTargetPaneIds$2(currentPaneId);
+	else targetPanes = await getTargetPaneIds$4(currentPaneId);
 	if (targetPanes.length === 0) {
 		logger$1.error("No target panes registered for this editor pane");
 		process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editprompt",
-  "version": "1.6.0",
+  "version": "1.8.1",
   "description": "A CLI tool that lets you write prompts for CLI tools using your favorite text editor",
   "keywords": [
     "cli",