thaddeus 1.0.26 → 1.0.28

package/src/utils/swarm/It2SetupPrompt.js

@@ -0,0 +1,386 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import React, { useEffect, useState } from 'react';
+import { Select } from '../../components/CustomSelect/index.js';
+import { Pane } from '../../components/design-system/Pane.js';
+import { Spinner } from '../../components/Spinner.js';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- enter to proceed through setup steps
+import { Box, Text, useInput } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import { detectPythonPackageManager, getPythonApiInstructions, installIt2, markIt2SetupComplete, setPreferTmuxOverIterm2, verifyIt2Setup } from './backends/it2Setup.js';
+export function It2SetupPrompt(t0) {
+    const $ = _c(44);
+    const { onDone, tmuxAvailable } = t0;
+    const [step, setStep] = useState("initial");
+    const [packageManager, setPackageManager] = useState(null);
+    const [error, setError] = useState(null);
+    const exitState = useExitOnCtrlCDWithKeybindings();
+    let t1;
+    let t2;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+        t1 = () => {
+            detectPythonPackageManager().then(pm => {
+                setPackageManager(pm);
+            });
+        };
+        t2 = [];
+        $[0] = t1;
+        $[1] = t2;
+    }
+    else {
+        t1 = $[0];
+        t2 = $[1];
+    }
+    useEffect(t1, t2);
+    let t3;
+    if ($[2] !== onDone) {
+        t3 = () => {
+            onDone("cancelled");
+        };
+        $[2] = onDone;
+        $[3] = t3;
+    }
+    else {
+        t3 = $[3];
+    }
+    const handleCancel = t3;
+    const t4 = step !== "installing" && step !== "verifying";
+    let t5;
+    if ($[4] !== t4) {
+        t5 = {
+            context: "Confirmation",
+            isActive: t4
+        };
+        $[4] = t4;
+        $[5] = t5;
+    }
+    else {
+        t5 = $[5];
+    }
+    useKeybinding("confirm:no", handleCancel, t5);
+    let t6;
+    if ($[6] !== onDone || $[7] !== step) {
+        t6 = (_input, key) => {
+            if (step === "api-instructions" && key.return) {
+                setStep("verifying");
+                verifyIt2Setup().then(result => {
+                    if (result.success) {
+                        markIt2SetupComplete();
+                        setStep("success");
+                        setTimeout(onDone, 1500, "installed");
+                    }
+                    else {
+                        setError(result.error || "Verification failed");
+                        setStep("failed");
+                    }
+                });
+            }
+        };
+        $[6] = onDone;
+        $[7] = step;
+        $[8] = t6;
+    }
+    else {
+        t6 = $[8];
+    }
+    useInput(t6);
+    let t7;
+    if ($[9] !== packageManager) {
+        t7 = async function handleInstall() {
+            if (!packageManager) {
+                setError("No Python package manager found (uvx, pipx, or pip)");
+                setStep("failed");
+                return;
+            }
+            setStep("installing");
+            const result_0 = await installIt2(packageManager);
+            if (result_0.success) {
+                setStep("api-instructions");
+            }
+            else {
+                setError(result_0.error || "Installation failed");
+                setStep("install-failed");
+            }
+        };
+        $[9] = packageManager;
+        $[10] = t7;
+    }
+    else {
+        t7 = $[10];
+    }
+    const handleInstall = t7;
+    let t8;
+    if ($[11] !== onDone) {
+        t8 = function handleUseTmux() {
+            setPreferTmuxOverIterm2(true);
+            onDone("use-tmux");
+        };
+        $[11] = onDone;
+        $[12] = t8;
+    }
+    else {
+        t8 = $[12];
+    }
+    const handleUseTmux = t8;
+    let T0;
+    let T1;
+    let t10;
+    let t11;
+    let t12;
+    let t13;
+    let t14;
+    let t9;
+    if ($[13] !== error || $[14] !== handleInstall || $[15] !== handleUseTmux || $[16] !== onDone || $[17] !== packageManager || $[18] !== step || $[19] !== tmuxAvailable) {
+        const renderContent = () => {
+            switch (step) {
+                case "initial":
+                    {
+                        return renderInitialPrompt();
+                    }
+                case "installing":
+                    {
+                        return renderInstalling();
+                    }
+                case "install-failed":
+                    {
+                        return renderInstallFailed();
+                    }
+                case "api-instructions":
+                    {
+                        return renderApiInstructions();
+                    }
+                case "verifying":
+                    {
+                        return renderVerifying();
+                    }
+                case "success":
+                    {
+                        return renderSuccess();
+                    }
+                case "failed":
+                    {
+                        return renderFailed();
+                    }
+                default:
+                    {
+                        return null;
+                    }
+            }
+        };
+        function renderInitialPrompt() {
+            const options = [{
+                    label: "Install it2 now",
+                    value: "install",
+                    description: packageManager ? `Uses ${packageManager} to install the it2 CLI tool` : "Requires Python (uvx, pipx, or pip)"
+                }];
+            if (tmuxAvailable) {
+                options.push({
+                    label: "Use tmux instead",
+                    value: "tmux",
+                    description: "Opens teammates in a separate tmux session"
+                });
+            }
+            options.push({
+                label: "Cancel",
+                value: "cancel",
+                description: "Skip teammate spawning for now"
+            });
+            return _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Text, { children: ["To use native iTerm2 split panes for teammates, you need the", " ", _jsx(Text, { bold: true, children: "it2" }), " CLI tool."] }), _jsx(Text, { dimColor: true, children: "This enables teammates to appear as split panes within your current window." }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: options, onChange: value => {
+                                bb61: switch (value) {
+                                    case "install":
+                                        {
+                                            handleInstall();
+                                            break bb61;
+                                        }
+                                    case "tmux":
+                                        {
+                                            handleUseTmux();
+                                            break bb61;
+                                        }
+                                    case "cancel":
+                                        {
+                                            onDone("cancelled");
+                                        }
+                                }
+                            }, onCancel: () => onDone("cancelled") }) })] });
+        }
+        function renderInstalling() {
+            return _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { children: [_jsx(Spinner, {}), _jsxs(Text, { children: [" Installing it2 using ", packageManager, "\u2026"] })] }), _jsx(Text, { dimColor: true, children: "This may take a moment." })] });
+        }
+        function renderInstallFailed() {
+            const options_0 = [{
+                    label: "Try again",
+                    value: "retry",
+                    description: "Retry the installation"
+                }];
+            if (tmuxAvailable) {
+                options_0.push({
+                    label: "Use tmux instead",
+                    value: "tmux",
+                    description: "Falls back to tmux for teammate panes"
+                });
+            }
+            options_0.push({
+                label: "Cancel",
+                value: "cancel",
+                description: "Skip teammate spawning for now"
+            });
+            return _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { color: "error", children: "Installation failed" }), error && _jsx(Text, { dimColor: true, children: error }), _jsxs(Text, { dimColor: true, children: ["You can try installing manually:", " ", packageManager === "uvx" ? "uv tool install it2" : packageManager === "pipx" ? "pipx install it2" : "pip install --user it2"] }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: options_0, onChange: value_0 => {
+                                bb89: switch (value_0) {
+                                    case "retry":
+                                        {
+                                            handleInstall();
+                                            break bb89;
+                                        }
+                                    case "tmux":
+                                        {
+                                            handleUseTmux();
+                                            break bb89;
+                                        }
+                                    case "cancel":
+                                        {
+                                            onDone("cancelled");
+                                        }
+                                }
+                            }, onCancel: () => onDone("cancelled") }) })] });
+        }
+        function renderApiInstructions() {
+            const instructions = getPythonApiInstructions();
+            return _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { color: "success", children: "\u2713 it2 installed successfully" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: instructions.map(_temp) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter when ready to verify\u2026" }) })] });
+        }
+        function renderVerifying() {
+            return _jsxs(Box, { children: [_jsx(Spinner, {}), _jsx(Text, { children: " Verifying it2 can communicate with iTerm2\u2026" })] });
+        }
+        function renderSuccess() {
+            return _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "success", children: "\u2713 iTerm2 split pane support is ready" }), _jsx(Text, { dimColor: true, children: "Teammates will now appear as split panes." })] });
+        }
+        function renderFailed() {
+            const options_1 = [{
+                    label: "Try again",
+                    value: "retry",
+                    description: "Verify the connection again"
+                }];
+            if (tmuxAvailable) {
+                options_1.push({
+                    label: "Use tmux instead",
+                    value: "tmux",
+                    description: "Falls back to tmux for teammate panes"
+                });
+            }
+            options_1.push({
+                label: "Cancel",
+                value: "cancel",
+                description: "Skip teammate spawning for now"
+            });
+            return _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { color: "error", children: "Verification failed" }), error && _jsx(Text, { dimColor: true, children: error }), _jsx(Text, { children: "Make sure:" }), _jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsx(Text, { children: "\u00B7 Python API is enabled in iTerm2 preferences" }), _jsx(Text, { children: "\u00B7 You may need to restart iTerm2 after enabling" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: options_1, onChange: value_1 => {
+                                bb115: switch (value_1) {
+                                    case "retry":
+                                        {
+                                            setStep("verifying");
+                                            verifyIt2Setup().then(result_1 => {
+                                                if (result_1.success) {
+                                                    markIt2SetupComplete();
+                                                    setStep("success");
+                                                    setTimeout(onDone, 1500, "installed");
+                                                }
+                                                else {
+                                                    setError(result_1.error || "Verification failed");
+                                                    setStep("failed");
+                                                }
+                                            });
+                                            break bb115;
+                                        }
+                                    case "tmux":
+                                        {
+                                            handleUseTmux();
+                                            break bb115;
+                                        }
+                                    case "cancel":
+                                        {
+                                            onDone("cancelled");
+                                        }
+                                }
+                            }, onCancel: () => onDone("cancelled") }) })] });
+        }
+        T1 = Pane;
+        t14 = "permission";
+        T0 = Box;
+        t9 = "column";
+        t10 = 1;
+        t11 = 1;
+        if ($[28] === Symbol.for("react.memo_cache_sentinel")) {
+            t12 = _jsx(Text, { bold: true, color: "permission", children: "iTerm2 Split Pane Setup" });
+            $[28] = t12;
+        }
+        else {
+            t12 = $[28];
+        }
+        t13 = renderContent();
+        $[13] = error;
+        $[14] = handleInstall;
+        $[15] = handleUseTmux;
+        $[16] = onDone;
+        $[17] = packageManager;
+        $[18] = step;
+        $[19] = tmuxAvailable;
+        $[20] = T0;
+        $[21] = T1;
+        $[22] = t10;
+        $[23] = t11;
+        $[24] = t12;
+        $[25] = t13;
+        $[26] = t14;
+        $[27] = t9;
+    }
+    else {
+        T0 = $[20];
+        T1 = $[21];
+        t10 = $[22];
+        t11 = $[23];
+        t12 = $[24];
+        t13 = $[25];
+        t14 = $[26];
+        t9 = $[27];
+    }
+    let t15;
+    if ($[29] !== exitState || $[30] !== step) {
+        t15 = step !== "installing" && step !== "verifying" && step !== "success" && _jsx(Text, { dimColor: true, italic: true, children: exitState.pending ? _jsxs(_Fragment, { children: ["Press ", exitState.keyName, " again to exit"] }) : _jsx(_Fragment, { children: "Esc to cancel" }) });
+        $[29] = exitState;
+        $[30] = step;
+        $[31] = t15;
+    }
+    else {
+        t15 = $[31];
+    }
+    let t16;
+    if ($[32] !== T0 || $[33] !== t10 || $[34] !== t11 || $[35] !== t12 || $[36] !== t13 || $[37] !== t15 || $[38] !== t9) {
+        t16 = _jsxs(T0, { flexDirection: t9, gap: t10, paddingBottom: t11, children: [t12, t13, t15] });
+        $[32] = T0;
+        $[33] = t10;
+        $[34] = t11;
+        $[35] = t12;
+        $[36] = t13;
+        $[37] = t15;
+        $[38] = t9;
+        $[39] = t16;
+    }
+    else {
+        t16 = $[39];
+    }
+    let t17;
+    if ($[40] !== T1 || $[41] !== t14 || $[42] !== t16) {
+        t17 = _jsx(T1, { color: t14, children: t16 });
+        $[40] = T1;
+        $[41] = t14;
+        $[42] = t16;
+        $[43] = t17;
+    }
+    else {
+        t17 = $[43];
+    }
+    return t17;
+}
+function _temp(line, i) {
+    return _jsx(Text, { children: line }, i);
+}

package/src/utils/swarm/backends/ITermBackend.js

@@ -0,0 +1,276 @@
+import { logForDebugging } from '../../../utils/debug.js';
+import { execFileNoThrow } from '../../../utils/execFileNoThrow.js';
+import { IT2_COMMAND, isInITerm2, isIt2CliAvailable } from './detection.js';
+import { registerITermBackend } from './registry.js';
+// Track session IDs for teammates
+const teammateSessionIds = [];
+// Track whether the first pane has been used
+let firstPaneUsed = false;
+// Lock mechanism to prevent race conditions when spawning teammates in parallel
+let paneCreationLock = Promise.resolve();
+/**
+ * Acquires a lock for pane creation, ensuring sequential execution.
+ * Returns a release function that must be called when done.
+ */
+function acquirePaneCreationLock() {
+    let release;
+    const newLock = new Promise(resolve => {
+        release = resolve;
+    });
+    const previousLock = paneCreationLock;
+    paneCreationLock = newLock;
+    return previousLock.then(() => release);
+}
+/**
+ * Runs an it2 CLI command and returns the result.
+ */
+function runIt2(args) {
+    return execFileNoThrow(IT2_COMMAND, args);
+}
+/**
+ * Parses the session ID from `it2 session split` output.
+ * Format: "Created new pane: <session-id>"
+ *
+ * NOTE: This UUID is only valid when splitting from a specific session
+ * using the -s flag. When splitting from the "active" session, the UUID
+ * may not be accessible if the split happened in a different window.
+ */
+function parseSplitOutput(output) {
+    const match = output.match(/Created new pane:\s*(.+)/);
+    if (match && match[1]) {
+        return match[1].trim();
+    }
+    return '';
+}
+/**
+ * Gets the leader's session ID from ITERM_SESSION_ID env var.
+ * Format: "wXtYpZ:UUID" - we extract the UUID part after the colon.
+ * Returns null if not in iTerm2 or env var not set.
+ */
+function getLeaderSessionId() {
+    const itermSessionId = process.env.ITERM_SESSION_ID;
+    if (!itermSessionId) {
+        return null;
+    }
+    const colonIndex = itermSessionId.indexOf(':');
+    if (colonIndex === -1) {
+        return null;
+    }
+    return itermSessionId.slice(colonIndex + 1);
+}
+/**
+ * ITermBackend implements pane management using iTerm2's native split panes
+ * via the it2 CLI tool.
+ */
+export class ITermBackend {
+    type = 'iterm2';
+    displayName = 'iTerm2';
+    supportsHideShow = false;
+    /**
+     * Checks if iTerm2 backend is available (in iTerm2 with it2 CLI installed).
+     */
+    async isAvailable() {
+        const inITerm2 = isInITerm2();
+        logForDebugging(`[ITermBackend] isAvailable check: inITerm2=${inITerm2}`);
+        if (!inITerm2) {
+            logForDebugging('[ITermBackend] isAvailable: false (not in iTerm2)');
+            return false;
+        }
+        const it2Available = await isIt2CliAvailable();
+        logForDebugging(`[ITermBackend] isAvailable: ${it2Available} (it2 CLI ${it2Available ? 'found' : 'not found'})`);
+        return it2Available;
+    }
+    /**
+     * Checks if we're currently running inside iTerm2.
+     */
+    async isRunningInside() {
+        const result = isInITerm2();
+        logForDebugging(`[ITermBackend] isRunningInside: ${result}`);
+        return result;
+    }
+    /**
+     * Creates a new teammate pane in the swarm view.
+     * Uses a lock to prevent race conditions when multiple teammates are spawned in parallel.
+     */
+    async createTeammatePaneInSwarmView(name, color) {
+        logForDebugging(`[ITermBackend] createTeammatePaneInSwarmView called for ${name} with color ${color}`);
+        const releaseLock = await acquirePaneCreationLock();
+        try {
+            // Layout: Leader on left, teammates stacked vertically on the right
+            // - First teammate: vertical split (-v) from leader's session
+            // - Subsequent teammates: horizontal split from last teammate's session
+            //
+            // We explicitly target the session to split from using -s flag to ensure
+            // correct layout even if user clicks on different panes.
+            //
+            // At-fault recovery: If a targeted teammate session is dead (user closed
+            // the pane via Cmd+W / X, or process crashed), prune it and retry with
+            // the next-to-last. Cheaper than a proactive 'it2 session list' on every spawn.
+            // Bounded at O(N+1) iterations: each continue shrinks teammateSessionIds by 1;
+            // when empty → firstPaneUsed resets → next iteration has no target → throws.
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const isFirstTeammate = !firstPaneUsed;
+                logForDebugging(`[ITermBackend] Creating pane: isFirstTeammate=${isFirstTeammate}, existingPanes=${teammateSessionIds.length}`);
+                let splitArgs;
+                let targetedTeammateId;
+                if (isFirstTeammate) {
+                    // Split from leader's session (extracted from ITERM_SESSION_ID env var)
+                    const leaderSessionId = getLeaderSessionId();
+                    if (leaderSessionId) {
+                        splitArgs = ['session', 'split', '-v', '-s', leaderSessionId];
+                        logForDebugging(`[ITermBackend] First split from leader session: ${leaderSessionId}`);
+                    }
+                    else {
+                        // Fallback to active session if we can't get leader's ID
+                        splitArgs = ['session', 'split', '-v'];
+                        logForDebugging('[ITermBackend] First split from active session (no leader ID)');
+                    }
+                }
+                else {
+                    // Split from the last teammate's session to stack vertically
+                    targetedTeammateId = teammateSessionIds[teammateSessionIds.length - 1];
+                    if (targetedTeammateId) {
+                        splitArgs = ['session', 'split', '-s', targetedTeammateId];
+                        logForDebugging(`[ITermBackend] Subsequent split from teammate session: ${targetedTeammateId}`);
+                    }
+                    else {
+                        // Fallback to active session
+                        splitArgs = ['session', 'split'];
+                        logForDebugging('[ITermBackend] Subsequent split from active session (no teammate ID)');
+                    }
+                }
+                const splitResult = await runIt2(splitArgs);
+                if (splitResult.code !== 0) {
+                    // If we targeted a teammate session, confirm it's actually dead before
+                    // pruning — 'session list' distinguishes dead-target from systemic
+                    // failure (Python API off, it2 removed, transient socket error).
+                    // Pruning on systemic failure would drain all live IDs → state corrupted.
+                    if (targetedTeammateId) {
+                        const listResult = await runIt2(['session', 'list']);
+                        if (listResult.code === 0 &&
+                            !listResult.stdout.includes(targetedTeammateId)) {
+                            // Confirmed dead — prune and retry with next-to-last (or leader).
+                            logForDebugging(`[ITermBackend] Split failed targeting dead session ${targetedTeammateId}, pruning and retrying: ${splitResult.stderr}`);
+                            const idx = teammateSessionIds.indexOf(targetedTeammateId);
+                            if (idx !== -1) {
+                                teammateSessionIds.splice(idx, 1);
+                            }
+                            if (teammateSessionIds.length === 0) {
+                                firstPaneUsed = false;
+                            }
+                            continue;
+                        }
+                        // Target is alive or we can't tell — don't corrupt state, surface the error.
+                    }
+                    throw new Error(`Failed to create iTerm2 split pane: ${splitResult.stderr}`);
+                }
+                if (isFirstTeammate) {
+                    firstPaneUsed = true;
+                }
+                // Parse the session ID from split output
+                // This works because we're splitting from a specific session (-s flag),
+                // so the new pane is in the same window and the UUID is valid.
+                const paneId = parseSplitOutput(splitResult.stdout);
+                if (!paneId) {
+                    throw new Error(`Failed to parse session ID from split output: ${splitResult.stdout}`);
+                }
+                logForDebugging(`[ITermBackend] Created teammate pane for ${name}: ${paneId}`);
+                teammateSessionIds.push(paneId);
+                // Set pane color and title
+                // Skip color and title for now - each it2 call is slow (Python process + API)
+                // The pane is functional without these cosmetic features
+                // TODO: Consider batching these or making them async/fire-and-forget
+                return { paneId, isFirstTeammate };
+            }
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    /**
+     * Sends a command to a specific pane.
+     */
+    async sendCommandToPane(paneId, command, _useExternalSession) {
+        // Use it2 session run to execute command (adds newline automatically)
+        // Always use -s flag to target specific session - this ensures the command
+        // goes to the right pane even if user switches windows
+        const args = paneId
+            ? ['session', 'run', '-s', paneId, command]
+            : ['session', 'run', command];
+        const result = await runIt2(args);
+        if (result.code !== 0) {
+            throw new Error(`Failed to send command to iTerm2 pane ${paneId}: ${result.stderr}`);
+        }
+    }
+    /**
+     * No-op for iTerm2 - tab colors would require escape sequences but we skip
+     * them for performance (each it2 call is slow).
+     */
+    async setPaneBorderColor(_paneId, _color, _useExternalSession) {
+        // Skip for performance - each it2 call spawns a Python process
+    }
+    /**
+     * No-op for iTerm2 - titles would require escape sequences but we skip
+     * them for performance (each it2 call is slow).
+     */
+    async setPaneTitle(_paneId, _name, _color, _useExternalSession) {
+        // Skip for performance - each it2 call spawns a Python process
+    }
+    /**
+     * No-op for iTerm2 - pane titles are shown in tabs automatically.
+     */
+    async enablePaneBorderStatus(_windowTarget, _useExternalSession) {
+        // iTerm2 doesn't have the concept of pane border status like tmux
+        // Titles are shown in tabs automatically
+    }
+    /**
+     * No-op for iTerm2 - pane balancing is handled automatically.
+     */
+    async rebalancePanes(_windowTarget, _hasLeader) {
+        // iTerm2 handles pane balancing automatically
+        logForDebugging('[ITermBackend] Pane rebalancing not implemented for iTerm2');
+    }
+    /**
+     * Kills/closes a specific pane using the it2 CLI.
+     * Also removes the pane from tracked session IDs so subsequent spawns
+     * don't try to split from a dead session.
+     */
+    async killPane(paneId, _useExternalSession) {
+        // -f (force) is required: without it, iTerm2 respects the "Confirm before
+        // closing" preference and either shows a dialog or refuses when the session
+        // still has a running process (the shell always is). tmux kill-pane has no
+        // such prompt, which is why this was only broken for iTerm2.
+        const result = await runIt2(['session', 'close', '-f', '-s', paneId]);
+        // Clean up module state regardless of close result — even if the pane is
+        // already gone (e.g., user closed it manually), removing the stale ID is correct.
+        const idx = teammateSessionIds.indexOf(paneId);
+        if (idx !== -1) {
+            teammateSessionIds.splice(idx, 1);
+        }
+        if (teammateSessionIds.length === 0) {
+            firstPaneUsed = false;
+        }
+        return result.code === 0;
+    }
+    /**
+     * Stub for hiding a pane - not supported in iTerm2 backend.
+     * iTerm2 doesn't have a direct equivalent to tmux's break-pane.
+     */
+    async hidePane(_paneId, _useExternalSession) {
+        logForDebugging('[ITermBackend] hidePane not supported in iTerm2');
+        return false;
+    }
+    /**
+     * Stub for showing a hidden pane - not supported in iTerm2 backend.
+     * iTerm2 doesn't have a direct equivalent to tmux's join-pane.
+     */
+    async showPane(_paneId, _targetWindowOrPane, _useExternalSession) {
+        logForDebugging('[ITermBackend] showPane not supported in iTerm2');
+        return false;
+    }
+}
+// Register the backend with the registry when this module is imported.
+// This side effect is intentional - the registry needs backends to self-register to avoid circular dependencies.
+// eslint-disable-next-line custom-rules/no-top-level-side-effects
+registerITermBackend(ITermBackend);