@runloop/rl-cli 0.1.1 → 0.2.0

package/dist/commands/devbox/ssh.js

@@ -1,82 +1,24 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React from "react";
-import { Box, Text } from "ink";
+/**
+ * SSH into devbox command
+ */
+import { spawn } from "child_process";
 import { getClient } from "../../utils/client.js";
-import { Banner } from "../../components/Banner.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { SuccessMessage } from "../../components/SuccessMessage.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-import { createExecutor } from "../../utils/CommandExecutor.js";
-import { colors } from "../../utils/theme.js";
-import { getSSHKey, waitForReady, generateSSHConfig, checkSSHTools, } from "../../utils/ssh.js";
-const SSHDevboxUI = ({ devboxId, options }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const connectSSH = async () => {
-            try {
-                // Check if SSH tools are available
-                const sshToolsAvailable = await checkSSHTools();
-                if (!sshToolsAvailable) {
-                    throw new Error("SSH tools (ssh, scp, rsync, openssl) are not available on this system");
-                }
-                const client = getClient();
-                // Wait for devbox to be ready unless --no-wait is specified
-                if (!options.noWait) {
-                    console.log(`Waiting for devbox ${devboxId} to be ready...`);
-                    const isReady = await waitForReady(devboxId, options.timeout || 180, options.pollInterval || 3);
-                    if (!isReady) {
-                        throw new Error(`Devbox ${devboxId} is not ready. Please try again later.`);
-                    }
-                }
-                // Get devbox details to determine user
-                const devbox = await client.devboxes.retrieve(devboxId);
-                const user = devbox.launch_parameters?.user_parameters?.username || "user";
-                // Get SSH key
-                const sshInfo = await getSSHKey(devboxId);
-                if (!sshInfo) {
-                    throw new Error("Failed to create SSH key");
-                }
-                if (options.configOnly) {
-                    const config = generateSSHConfig(devboxId, user, sshInfo.keyfilePath, sshInfo.url);
-                    setResult({ config });
-                }
-                else {
-                    setResult({
-                        devboxId,
-                        user,
-                        keyfilePath: sshInfo.keyfilePath,
-                        url: sshInfo.url,
-                    });
-                }
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        connectSSH();
-    }, [devboxId, options]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Setting up SSH connection..." }), result && result.config && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.primary, children: "SSH Config:" }), _jsx(Text, { children: result.config })] })), result && !result.config && (_jsx(SuccessMessage, { message: "SSH connection ready", details: `Devbox: ${result.devboxId}\nUser: ${result.user}\nKey: ${result.keyfilePath}` })), error && (_jsx(ErrorMessage, { message: "Failed to setup SSH connection", error: error }))] }));
-};
-export async function sshDevbox(devboxId, options) {
-    const executor = createExecutor(options);
-    await executor.executeAction(async () => {
+import { output, outputError } from "../../utils/output.js";
+import { getSSHKey, waitForReady, generateSSHConfig, checkSSHTools, getProxyCommand, } from "../../utils/ssh.js";
+export async function sshDevbox(devboxId, options = {}) {
+    try {
         // Check if SSH tools are available
         const sshToolsAvailable = await checkSSHTools();
         if (!sshToolsAvailable) {
-            throw new Error("SSH tools (ssh, scp, rsync, openssl) are not available on this system");
+            outputError("SSH tools (ssh, scp, rsync, openssl) are not available on this system");
         }
-        const client = executor.getClient();
+        const client = getClient();
         // Wait for devbox to be ready unless --no-wait is specified
         if (!options.noWait) {
-            console.log(`Waiting for devbox ${devboxId} to be ready...`);
+            console.error(`Waiting for devbox ${devboxId} to be ready...`);
             const isReady = await waitForReady(devboxId, options.timeout || 180, options.pollInterval || 3);
             if (!isReady) {
-                throw new Error(`Devbox ${devboxId} is not ready. Please try again later.`);
+                outputError(`Devbox ${devboxId} is not ready. Please try again later.`);
             }
         }
         // Get devbox details to determine user
@@ -85,20 +27,45 @@ export async function sshDevbox(devboxId, options) {
         // Get SSH key
         const sshInfo = await getSSHKey(devboxId);
         if (!sshInfo) {
-            throw new Error("Failed to create SSH key");
+            outputError("Failed to create SSH key");
         }
         if (options.configOnly) {
-            return {
-                config: generateSSHConfig(devboxId, user, sshInfo.keyfilePath, sshInfo.url),
-            };
+            const config = generateSSHConfig(devboxId, user, sshInfo.keyfilePath, sshInfo.url);
+            output({ config }, { format: options.output, defaultFormat: "text" });
+            return;
         }
-        else {
-            return {
+        // If output format is specified, just return the connection info
+        if (options.output && options.output !== "text") {
+            output({
                 devboxId,
                 user,
                 keyfilePath: sshInfo.keyfilePath,
                 url: sshInfo.url,
-            };
+            }, { format: options.output, defaultFormat: "json" });
+            return;
         }
-    }, () => _jsx(SSHDevboxUI, { devboxId: devboxId, options: options }));
+        // Actually start SSH session
+        const proxyCommand = getProxyCommand();
+        const sshArgs = [
+            "-i",
+            sshInfo.keyfilePath,
+            "-o",
+            `ProxyCommand=${proxyCommand}`,
+            "-o",
+            "StrictHostKeyChecking=no",
+            `${user}@${sshInfo.url}`,
+        ];
+        const sshProcess = spawn("/usr/bin/ssh", sshArgs, {
+            stdio: "inherit",
+        });
+        sshProcess.on("close", (code) => {
+            process.exit(code || 0);
+        });
+        sshProcess.on("error", (err) => {
+            outputError("SSH connection failed", err);
+        });
+    }
+    catch (error) {
+        outputError("Failed to setup SSH connection", error);
+    }
 }

package/dist/commands/devbox/suspend.js

@@ -1,37 +1,15 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Suspend devbox command
+ */
 import { getClient } from "../../utils/client.js";
-import { Banner } from "../../components/Banner.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { SuccessMessage } from "../../components/SuccessMessage.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-import { createExecutor } from "../../utils/CommandExecutor.js";
-const SuspendDevboxUI = ({ devboxId }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const suspendDevbox = async () => {
-            try {
-                const client = getClient();
-                const devbox = await client.devboxes.suspend(devboxId);
-                setResult(devbox);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        suspendDevbox();
-    }, [devboxId]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Suspending devbox..." }), result && (_jsx(SuccessMessage, { message: "Devbox suspended", details: `ID: ${result.id}\nStatus: ${result.status}` })), error && (_jsx(ErrorMessage, { message: "Failed to suspend devbox", error: error }))] }));
-};
-export async function suspendDevbox(devboxId, options) {
-    const executor = createExecutor(options);
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
-        return client.devboxes.suspend(devboxId);
-    }, () => _jsx(SuspendDevboxUI, { devboxId: devboxId }));
+import { output, outputError } from "../../utils/output.js";
+export async function suspendDevbox(devboxId, options = {}) {
+    try {
+        const client = getClient();
+        const devbox = await client.devboxes.suspend(devboxId);
+        output(devbox, { format: options.output, defaultFormat: "json" });
+    }
+    catch (error) {
+        outputError("Failed to suspend devbox", error);
+    }
 }

package/dist/commands/devbox/tunnel.js

@@ -1,100 +1,43 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
+/**
+ * Create SSH tunnel to devbox command
+ */
+import { spawn } from "child_process";
 import { getClient } from "../../utils/client.js";
-import { Banner } from "../../components/Banner.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { SuccessMessage } from "../../components/SuccessMessage.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-import { createExecutor } from "../../utils/CommandExecutor.js";
+import { output, outputError } from "../../utils/output.js";
 import { getSSHKey, getProxyCommand, checkSSHTools } from "../../utils/ssh.js";
-import { exec } from "child_process";
-import { promisify } from "util";
-const execAsync = promisify(exec);
-const TunnelUI = ({ devboxId, ports }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const createTunnel = async () => {
-            try {
-                // Check if SSH tools are available
-                const sshToolsAvailable = await checkSSHTools();
-                if (!sshToolsAvailable) {
-                    throw new Error("SSH tools (ssh, openssl) are not available on this system");
-                }
-                if (!ports.includes(":")) {
-                    throw new Error("Ports must be specified as 'local:remote'");
-                }
-                const [localPort, remotePort] = ports.split(":");
-                const client = getClient();
-                // Get devbox details to determine user
-                const devbox = await client.devboxes.retrieve(devboxId);
-                const user = devbox.launch_parameters?.user_parameters?.username || "user";
-                // Get SSH key
-                const sshInfo = await getSSHKey(devboxId);
-                if (!sshInfo) {
-                    throw new Error("Failed to create SSH key");
-                }
-                const proxyCommand = getProxyCommand();
-                const tunnelCommand = [
-                    "/usr/bin/ssh",
-                    "-i",
-                    sshInfo.keyfilePath,
-                    "-o",
-                    `ProxyCommand=${proxyCommand}`,
-                    "-o",
-                    "StrictHostKeyChecking=no",
-                    "-N", // Do not execute a remote command
-                    "-L",
-                    `${localPort}:localhost:${remotePort}`,
-                    `${user}@${sshInfo.url}`,
-                ];
-                console.log(`Starting tunnel: local port ${localPort} -> remote port ${remotePort}`);
-                console.log("Press Ctrl+C to stop the tunnel.");
-                // Set up signal handler for graceful shutdown
-                const signalHandler = () => {
-                    console.log("\nStopping tunnel...");
-                    process.exit(0);
-                };
-                process.on("SIGINT", signalHandler);
-                const { stdout, stderr } = await execAsync(tunnelCommand.join(" "));
-                setResult({ localPort, remotePort, stdout, stderr });
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        createTunnel();
-    }, [devboxId, ports]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Creating SSH tunnel..." }), result && (_jsx(SuccessMessage, { message: "SSH tunnel created", details: `Local port: ${result.localPort}\nRemote port: ${result.remotePort}` })), error && (_jsx(ErrorMessage, { message: "Failed to create SSH tunnel", error: error }))] }));
-};
 export async function createTunnel(devboxId, options) {
-    const executor = createExecutor({ output: options.outputFormat });
-    await executor.executeAction(async () => {
+    try {
         // Check if SSH tools are available
         const sshToolsAvailable = await checkSSHTools();
         if (!sshToolsAvailable) {
-            throw new Error("SSH tools (ssh, openssl) are not available on this system");
+            outputError("SSH tools (ssh, openssl) are not available on this system");
         }
         if (!options.ports.includes(":")) {
-            throw new Error("Ports must be specified as 'local:remote'");
+            outputError("Ports must be specified as 'local:remote'");
         }
         const [localPort, remotePort] = options.ports.split(":");
-        const client = executor.getClient();
+        const client = getClient();
         // Get devbox details to determine user
         const devbox = await client.devboxes.retrieve(devboxId);
         const user = devbox.launch_parameters?.user_parameters?.username || "user";
         // Get SSH key
         const sshInfo = await getSSHKey(devboxId);
         if (!sshInfo) {
-            throw new Error("Failed to create SSH key");
+            outputError("Failed to create SSH key");
+        }
+        // If output format is specified, just return the tunnel info
+        if (options.output && options.output !== "text") {
+            output({
+                devboxId,
+                localPort,
+                remotePort,
+                user,
+                keyfilePath: sshInfo.keyfilePath,
+            }, { format: options.output, defaultFormat: "json" });
+            return;
         }
         const proxyCommand = getProxyCommand();
-        const tunnelCommand = [
-            "/usr/bin/ssh",
+        const tunnelArgs = [
             "-i",
             sshInfo.keyfilePath,
             "-o",
@@ -108,13 +51,18 @@ export async function createTunnel(devboxId, options) {
         ];
         console.log(`Starting tunnel: local port ${localPort} -> remote port ${remotePort}`);
         console.log("Press Ctrl+C to stop the tunnel.");
-        // Set up signal handler for graceful shutdown
-        const signalHandler = () => {
-            console.log("\nStopping tunnel...");
-            process.exit(0);
-        };
-        process.on("SIGINT", signalHandler);
-        const { stdout, stderr } = await execAsync(tunnelCommand.join(" "));
-        return { localPort, remotePort, stdout, stderr };
-    }, () => _jsx(TunnelUI, { devboxId: devboxId, ports: options.ports }));
+        const tunnelProcess = spawn("/usr/bin/ssh", tunnelArgs, {
+            stdio: "inherit",
+        });
+        tunnelProcess.on("close", (code) => {
+            console.log("\nTunnel closed.");
+            process.exit(code || 0);
+        });
+        tunnelProcess.on("error", (err) => {
+            outputError("Tunnel creation failed", err);
+        });
+    }
+    catch (error) {
+        outputError("Failed to create SSH tunnel", error);
+    }
 }

package/dist/commands/devbox/upload.js

@@ -1,40 +1,32 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
-import { render } from "ink";
+/**
+ * Upload file to devbox command
+ */
 import { createReadStream } from "fs";
 import { getClient } from "../../utils/client.js";
-import { Header } from "../../components/Header.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { SuccessMessage } from "../../components/SuccessMessage.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-const UploadFileUI = ({ id, file, targetPath }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [success, setSuccess] = React.useState(false);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const upload = async () => {
-            try {
-                const client = getClient();
-                const fileStream = createReadStream(file);
-                const filename = file.split("/").pop() || "uploaded-file";
-                await client.devboxes.uploadFile(id, {
-                    path: targetPath || filename,
-                    file: fileStream,
-                });
-                setSuccess(true);
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
+import { output, outputError } from "../../utils/output.js";
+export async function uploadFile(id, file, options = {}) {
+    try {
+        const client = getClient();
+        const fileStream = createReadStream(file);
+        const filename = file.split("/").pop() || "uploaded-file";
+        await client.devboxes.uploadFile(id, {
+            path: options.path || filename,
+            file: fileStream,
+        });
+        const result = {
+            file,
+            target: options.path || filename,
+            devboxId: id,
         };
-        upload();
-    }, []);
-    return (_jsxs(_Fragment, { children: [_jsx(Header, { title: "Upload File", subtitle: `Uploading to devbox: ${id}` }), loading && _jsx(SpinnerComponent, { message: "Uploading file..." }), success && (_jsx(SuccessMessage, { message: "File uploaded successfully!", details: `File: ${file}${targetPath ? `\nTarget: ${targetPath}` : ""}` })), error && _jsx(ErrorMessage, { message: "Failed to upload file", error: error })] }));
-};
-export async function uploadFile(id, file, options) {
-    const { waitUntilExit } = render(_jsx(UploadFileUI, { id: id, file: file, targetPath: options.path }));
-    await waitUntilExit();
+        // Default: just output the target path for easy scripting
+        if (!options.output || options.output === "text") {
+            console.log(options.path || filename);
+        }
+        else {
+            output(result, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to upload file", error);
+    }
 }

package/dist/commands/devbox/write.js

@@ -1,51 +1,36 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
-import { getClient } from "../../utils/client.js";
-import { Banner } from "../../components/Banner.js";
-import { SpinnerComponent } from "../../components/Spinner.js";
-import { SuccessMessage } from "../../components/SuccessMessage.js";
-import { ErrorMessage } from "../../components/ErrorMessage.js";
-import { createExecutor } from "../../utils/CommandExecutor.js";
+/**
+ * Write file to devbox command (using API)
+ */
 import { readFile } from "fs/promises";
-const WriteFileUI = ({ devboxId, inputPath, remotePath }) => {
-    const [loading, setLoading] = React.useState(true);
-    const [result, setResult] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
-        const writeFile = async () => {
-            try {
-                const client = getClient();
-                const contents = await readFile(inputPath, "utf-8");
-                await client.devboxes.writeFileContents(devboxId, {
-                    file_path: remotePath,
-                    contents,
-                });
-                setResult({ inputPath, remotePath, size: contents.length });
-            }
-            catch (err) {
-                setError(err);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        writeFile();
-    }, [devboxId, inputPath, remotePath]);
-    return (_jsxs(_Fragment, { children: [_jsx(Banner, {}), loading && _jsx(SpinnerComponent, { message: "Writing file to devbox..." }), result && (_jsx(SuccessMessage, { message: "File written successfully", details: `Local: ${result.inputPath}\nRemote: ${result.remotePath}\nSize: ${result.size} bytes` })), error && _jsx(ErrorMessage, { message: "Failed to write file", error: error })] }));
-};
-export async function writeFile(devboxId, options) {
-    const executor = createExecutor({ output: options.output });
-    await executor.executeAction(async () => {
-        const client = executor.getClient();
+import { getClient } from "../../utils/client.js";
+import { output, outputError } from "../../utils/output.js";
+export async function writeFile(devboxId, options = {}) {
+    if (!options.input) {
+        outputError("--input is required");
+    }
+    if (!options.remote) {
+        outputError("--remote is required");
+    }
+    try {
+        const client = getClient();
         const contents = await readFile(options.input, "utf-8");
         await client.devboxes.writeFileContents(devboxId, {
             file_path: options.remote,
             contents,
         });
-        return {
-            inputPath: options.input,
-            remotePath: options.remote,
-            size: contents.length,
-        };
-    }, () => (_jsx(WriteFileUI, { devboxId: devboxId, inputPath: options.input, remotePath: options.remote })));
+        // Default: just output the remote path for easy scripting
+        if (!options.output || options.output === "text") {
+            console.log(options.remote);
+        }
+        else {
+            output({
+                local: options.input,
+                remote: options.remote,
+                size: contents.length,
+            }, { format: options.output, defaultFormat: "json" });
+        }
+    }
+    catch (error) {
+        outputError("Failed to write file", error);
+    }
 }

package/dist/commands/mcp-install.js

@@ -26,7 +26,7 @@ function getRliPath() {
         const path = execSync(cmd, { encoding: "utf-8" }).trim().split("\n")[0];
         return path;
     }
-    catch (error) {
+    catch {
         // If rli not found in PATH, just use 'rli' and hope it works
         return "rli";
     }
@@ -48,7 +48,7 @@ export async function installMcpConfig() {
                     config.mcpServers = {};
                 }
             }
-            catch (error) {
+            catch {
                 console.error("❌ Error: Claude config file exists but is not valid JSON");
                 console.error("Please fix the file manually or delete it to create a new one");
                 process.exit(1);
@@ -103,7 +103,8 @@ export async function installMcpConfig() {
         console.log('\n💡 Tip: Make sure you\'ve run "rli auth" to configure your API key first!');
     }
     catch (error) {
-        console.error("\n❌ Error installing MCP configuration:", error.message);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("\n❌ Error installing MCP configuration:", errorMessage);
         console.error("\n💡 You can manually add this configuration to your Claude Desktop config:");
         console.error(`\nFile location: ${getClaudeConfigPath()}`);
         console.error("\nConfiguration to add:");

package/dist/commands/menu.js

@@ -1,70 +1,28 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
-import { render, useApp } from "ink";
-import { MainMenu } from "../components/MainMenu.js";
-import { runSSHSession } from "../utils/sshSession.js";
-// Import the UI components directly
-import { ListDevboxesUI } from "./devbox/list.js";
-import { ListBlueprintsUI } from "./blueprint/list.js";
-import { ListSnapshotsUI } from "./snapshot/list.js";
-import { Box } from "ink";
-const App = ({ onSSHRequest, initialScreen = "menu", focusDevboxId, }) => {
-    const { exit } = useApp();
-    const [currentScreen, setCurrentScreen] = React.useState(initialScreen);
-    const [, forceUpdate] = React.useReducer((x) => x + 1, 0);
-    const handleMenuSelect = (key) => {
-        setCurrentScreen(key);
-    };
-    const handleBack = () => {
-        setCurrentScreen("menu");
-    };
-    const handleExit = () => {
-        exit();
-    };
-    // Wrap everything in a full-height container
-    return (_jsxs(Box, { flexDirection: "column", minHeight: process.stdout.rows || 24, children: [currentScreen === "menu" && _jsx(MainMenu, { onSelect: handleMenuSelect }), currentScreen === "devboxes" && (_jsx(ListDevboxesUI, { onBack: handleBack, onExit: handleExit, onSSHRequest: onSSHRequest, focusDevboxId: focusDevboxId })), currentScreen === "blueprints" && (_jsx(ListBlueprintsUI, { onBack: handleBack, onExit: handleExit })), currentScreen === "snapshots" && (_jsx(ListSnapshotsUI, { onBack: handleBack, onExit: handleExit }))] }));
-};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { enterAlternateScreenBuffer, exitAlternateScreenBuffer, } from "../utils/screen.js";
+import { Router } from "../router/Router.js";
+import { NavigationProvider } from "../store/navigationStore.js";
+function AppInner() {
+    // NavigationProvider already handles initialScreen and initialParams
+    // No need for useEffect here - provider sets state on mount
+    return _jsx(Router, {});
+}
+function App({ initialScreen = "menu", focusDevboxId, }) {
+    return (_jsx(NavigationProvider, { initialScreen: initialScreen, initialParams: focusDevboxId ? { focusDevboxId } : {}, children: _jsx(AppInner, {}) }));
+}
 export async function runMainMenu(initialScreen = "menu", focusDevboxId) {
-    // Enter alternate screen buffer once at the start
-    process.stdout.write("\x1b[?1049h");
-    let sshSessionConfig = null;
-    let shouldContinue = true;
-    let currentInitialScreen = initialScreen;
-    let currentFocusDevboxId = focusDevboxId;
-    while (shouldContinue) {
-        sshSessionConfig = null;
-        try {
-            const { waitUntilExit } = render(_jsx(App, { onSSHRequest: (config) => {
-                    sshSessionConfig = config;
-                }, initialScreen: currentInitialScreen, focusDevboxId: currentFocusDevboxId }));
-            await waitUntilExit();
-            shouldContinue = false;
-        }
-        catch (error) {
-            console.error("Error in menu:", error);
-            shouldContinue = false;
-        }
-        // If SSH was requested, handle it now after Ink has exited
-        if (sshSessionConfig) {
-            // Exit alternate screen buffer for SSH
-            process.stdout.write("\x1b[?1049l");
-            const result = await runSSHSession(sshSessionConfig);
-            if (result.shouldRestart) {
-                console.clear();
-                console.log(`\nSSH session ended. Returning to menu...\n`);
-                await new Promise((resolve) => setTimeout(resolve, 500));
-                // Re-enter alternate screen buffer and return to devboxes list
-                process.stdout.write("\x1b[?1049h");
-                currentInitialScreen = "devboxes";
-                currentFocusDevboxId = result.returnToDevboxId;
-                shouldContinue = true;
-            }
-            else {
-                shouldContinue = false;
-            }
-        }
+    enterAlternateScreenBuffer();
+    try {
+        const { waitUntilExit } = render(_jsx(App, { initialScreen: initialScreen, focusDevboxId: focusDevboxId }, `app-${initialScreen}-${focusDevboxId}`), {
+            patchConsole: false,
+            exitOnCtrlC: false,
+        });
+        await waitUntilExit();
+    }
+    catch (error) {
+        console.error("Error in menu:", error);
     }
-    // Exit alternate screen buffer once at the end
-    process.stdout.write("\x1b[?1049l");
+    exitAlternateScreenBuffer();
     process.exit(0);
 }