@runloop/rl-cli 0.1.2 → 0.3.0

package/dist/commands/devbox/ssh.js

@@ -1,82 +1,25 @@
-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 { processUtils } from "../../utils/processUtils.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 +28,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) => {
+            processUtils.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,44 @@
-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 { processUtils } from "../../utils/processUtils.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 +52,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.");
+            processUtils.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-http.js

@@ -2,12 +2,13 @@
 import { spawn } from "child_process";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
+import { processUtils } from "../utils/processUtils.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export async function startMcpHttpServer(port) {
     // Get the path to the compiled MCP HTTP server
     const serverPath = join(__dirname, "../mcp/server-http.js");
-    const env = { ...process.env };
+    const env = { ...processUtils.env };
     if (port) {
         env.PORT = port.toString();
     }
@@ -20,18 +21,18 @@ export async function startMcpHttpServer(port) {
     });
     serverProcess.on("error", (error) => {
         console.error("Failed to start MCP HTTP server:", error);
-        process.exit(1);
+        processUtils.exit(1);
     });
     serverProcess.on("exit", (code) => {
         if (code !== 0) {
             console.error(`MCP HTTP server exited with code ${code}`);
-            process.exit(code || 1);
+            processUtils.exit(code || 1);
         }
     });
     // Handle Ctrl+C
-    process.on("SIGINT", () => {
+    processUtils.on("SIGINT", () => {
         console.log("\nShutting down MCP HTTP server...");
         serverProcess.kill("SIGINT");
-        process.exit(0);
+        processUtils.exit(0);
     });
 }

package/dist/commands/mcp-install.js

@@ -3,13 +3,14 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { homedir, platform } from "os";
 import { join } from "path";
 import { execSync } from "child_process";
+import { processUtils } from "../utils/processUtils.js";
 function getClaudeConfigPath() {
     const plat = platform();
     if (plat === "darwin") {
         return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
     }
     else if (plat === "win32") {
-        const appData = process.env.APPDATA;
+        const appData = processUtils.env.APPDATA;
         if (!appData) {
             throw new Error("APPDATA environment variable not found");
         }
@@ -26,7 +27,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,10 +49,10 @@ 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);
+                processUtils.exit(1);
             }
         }
         else {
@@ -71,20 +72,20 @@ export async function installMcpConfig() {
             // Ask if they want to overwrite
             console.log("\n❓ Do you want to overwrite it? (y/N): ");
             // For non-interactive mode, just exit
-            if (process.stdin.isTTY) {
+            if (processUtils.stdin.isTTY) {
                 const response = await new Promise((resolve) => {
-                    process.stdin.once("data", (data) => {
+                    processUtils.stdin.on("data", (data) => {
                         resolve(data.toString().trim().toLowerCase());
                     });
                 });
                 if (response !== "y" && response !== "yes") {
                     console.log("\n✓ Keeping existing configuration");
-                    process.exit(0);
+                    processUtils.exit(0);
                 }
             }
             else {
                 console.log("\n✓ Keeping existing configuration (non-interactive mode)");
-                process.exit(0);
+                processUtils.exit(0);
             }
         }
         // Add runloop MCP server config
@@ -103,7 +104,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:");
@@ -115,6 +117,6 @@ export async function installMcpConfig() {
                 },
             },
         }, null, 2));
-        process.exit(1);
+        processUtils.exit(1);
     }
 }

package/dist/commands/mcp.js

@@ -2,6 +2,7 @@
 import { spawn } from "child_process";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
+import { processUtils } from "../utils/processUtils.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export async function startMcpServer() {
@@ -14,17 +15,17 @@ export async function startMcpServer() {
     });
     serverProcess.on("error", (error) => {
         console.error("Failed to start MCP server:", error);
-        process.exit(1);
+        processUtils.exit(1);
     });
     serverProcess.on("exit", (code) => {
         if (code !== 0) {
             console.error(`MCP server exited with code ${code}`);
-            process.exit(code || 1);
+            processUtils.exit(code || 1);
         }
     });
     // Handle Ctrl+C
-    process.on("SIGINT", () => {
+    processUtils.on("SIGINT", () => {
         serverProcess.kill("SIGINT");
-        process.exit(0);
+        processUtils.exit(0);
     });
 }