@runloop/rl-cli 0.0.3 → 0.1.1

package/dist/mcp/server.js

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { getClient } from "../utils/client.js";
+// Define available tools for the MCP server
+const TOOLS = [
+    {
+        name: "list_devboxes",
+        description: "List all devboxes with optional filtering by status",
+        inputSchema: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    description: "Filter by status (running, provisioning, suspended, etc.)",
+                    enum: [
+                        "running",
+                        "provisioning",
+                        "initializing",
+                        "suspended",
+                        "shutdown",
+                        "failure",
+                    ],
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of devboxes to return",
+                },
+            },
+        },
+    },
+    {
+        name: "get_devbox",
+        description: "Get detailed information about a specific devbox by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "string",
+                    description: "The devbox ID",
+                },
+            },
+            required: ["id"],
+        },
+    },
+    {
+        name: "create_devbox",
+        description: "Create a new devbox with specified configuration",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Name for the devbox",
+                },
+                blueprint_id: {
+                    type: "string",
+                    description: "Blueprint ID to use as template",
+                },
+                snapshot_id: {
+                    type: "string",
+                    description: "Snapshot ID to restore from",
+                },
+                entrypoint: {
+                    type: "string",
+                    description: "Entrypoint script to run on startup",
+                },
+                environment_variables: {
+                    type: "object",
+                    description: "Environment variables as key-value pairs",
+                },
+                resource_size: {
+                    type: "string",
+                    description: "Resource size (SMALL, MEDIUM, LARGE, XLARGE)",
+                    enum: ["SMALL", "MEDIUM", "LARGE", "XLARGE"],
+                },
+                keep_alive_seconds: {
+                    type: "number",
+                    description: "Keep alive time in seconds",
+                },
+            },
+        },
+    },
+    {
+        name: "execute_command",
+        description: "Execute a command on a devbox and get the result",
+        inputSchema: {
+            type: "object",
+            properties: {
+                devbox_id: {
+                    type: "string",
+                    description: "The devbox ID to execute the command on",
+                },
+                command: {
+                    type: "string",
+                    description: "The command to execute",
+                },
+            },
+            required: ["devbox_id", "command"],
+        },
+    },
+    {
+        name: "shutdown_devbox",
+        description: "Shutdown a devbox by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "string",
+                    description: "The devbox ID to shutdown",
+                },
+            },
+            required: ["id"],
+        },
+    },
+    {
+        name: "suspend_devbox",
+        description: "Suspend a devbox by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "string",
+                    description: "The devbox ID to suspend",
+                },
+            },
+            required: ["id"],
+        },
+    },
+    {
+        name: "resume_devbox",
+        description: "Resume a suspended devbox by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "string",
+                    description: "The devbox ID to resume",
+                },
+            },
+            required: ["id"],
+        },
+    },
+    {
+        name: "list_blueprints",
+        description: "List all available blueprints",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Maximum number of blueprints to return",
+                },
+            },
+        },
+    },
+    {
+        name: "list_snapshots",
+        description: "List all snapshots",
+        inputSchema: {
+            type: "object",
+            properties: {
+                devbox_id: {
+                    type: "string",
+                    description: "Filter snapshots by devbox ID",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of snapshots to return",
+                },
+            },
+        },
+    },
+    {
+        name: "create_snapshot",
+        description: "Create a snapshot of a devbox",
+        inputSchema: {
+            type: "object",
+            properties: {
+                devbox_id: {
+                    type: "string",
+                    description: "The devbox ID to snapshot",
+                },
+                name: {
+                    type: "string",
+                    description: "Name for the snapshot",
+                },
+            },
+            required: ["devbox_id"],
+        },
+    },
+];
+// Create the MCP server
+const server = new Server({
+    name: "runloop-mcp-server",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Handle tool listing
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: TOOLS,
+    };
+});
+// Handle tool execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const client = getClient();
+        if (!args) {
+            throw new Error("Missing arguments");
+        }
+        switch (name) {
+            case "list_devboxes": {
+                const result = await client.devboxes.list({
+                    status: args.status,
+                    limit: args.limit,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_devbox": {
+                const result = await client.devboxes.retrieve(args.id);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "create_devbox": {
+                const createParams = {};
+                if (args.name)
+                    createParams.name = args.name;
+                if (args.blueprint_id)
+                    createParams.blueprint_id = args.blueprint_id;
+                if (args.snapshot_id)
+                    createParams.snapshot_id = args.snapshot_id;
+                if (args.entrypoint)
+                    createParams.entrypoint = args.entrypoint;
+                if (args.environment_variables)
+                    createParams.environment_variables = args.environment_variables;
+                if (args.resource_size) {
+                    createParams.launch_parameters = {
+                        resource_size_request: args.resource_size,
+                    };
+                }
+                if (args.keep_alive_seconds) {
+                    if (!createParams.launch_parameters)
+                        createParams.launch_parameters = {};
+                    createParams.launch_parameters.keep_alive_time_seconds =
+                        args.keep_alive_seconds;
+                }
+                const result = await client.devboxes.create(createParams);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "execute_command": {
+                const result = await client.devboxes.executeSync(args.devbox_id, {
+                    command: args.command,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "shutdown_devbox": {
+                const result = await client.devboxes.shutdown(args.id);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "suspend_devbox": {
+                const result = await client.devboxes.suspend(args.id);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "resume_devbox": {
+                const result = await client.devboxes.resume(args.id);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "list_blueprints": {
+                const result = await client.blueprints.list({
+                    limit: args.limit,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "list_snapshots": {
+                const params = {};
+                if (args.devbox_id)
+                    params.devbox_id = args.devbox_id;
+                const allSnapshots = [];
+                let count = 0;
+                const limit = args.limit || 100;
+                for await (const snapshot of client.devboxes.listDiskSnapshots(params)) {
+                    allSnapshots.push(snapshot);
+                    count++;
+                    if (count >= limit)
+                        break;
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(allSnapshots, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "create_snapshot": {
+                const params = {};
+                if (args.name)
+                    params.name = args.name;
+                const result = await client.devboxes.snapshotDisk(args.devbox_id, params);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Log to stderr so it doesn't interfere with MCP protocol on stdout
+    console.error("Runloop MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/utils/CommandExecutor.js

@@ -2,14 +2,18 @@
  * Shared class for executing commands with different output formats
  * Reduces code duplication across all command files
  */
-import { render } from 'ink';
-import { getClient } from './client.js';
-import { shouldUseNonInteractiveOutput, outputList, outputResult } from './output.js';
-import YAML from 'yaml';
+import { render } from "ink";
+import { getClient } from "./client.js";
+import { shouldUseNonInteractiveOutput, outputList, outputResult, } from "./output.js";
+import YAML from "yaml";
 export class CommandExecutor {
     options;
     constructor(options = {}) {
         this.options = options;
+        // Set default output format to json if none specified
+        if (!this.options.output) {
+            this.options.output = "json";
+        }
     }
     /**
      * Execute a list command with automatic format handling
@@ -29,12 +33,12 @@ export class CommandExecutor {
         }
         // Interactive mode
         // Enter alternate screen buffer
-        process.stdout.write('\x1b[?1049h');
+        process.stdout.write("\x1b[?1049h");
         console.clear();
         const { waitUntilExit } = render(renderUI());
         await waitUntilExit();
         // Exit alternate screen buffer
-        process.stdout.write('\x1b[?1049l');
+        process.stdout.write("\x1b[?1049l");
     }
     /**
      * Execute a create/action command with automatic format handling
@@ -52,12 +56,12 @@ export class CommandExecutor {
         }
         // Interactive mode
         // Enter alternate screen buffer
-        process.stdout.write('\x1b[?1049h');
+        process.stdout.write("\x1b[?1049h");
         console.clear();
         const { waitUntilExit } = render(renderUI());
         await waitUntilExit();
         // Exit alternate screen buffer
-        process.stdout.write('\x1b[?1049l');
+        process.stdout.write("\x1b[?1049l");
     }
     /**
      * Execute a delete command with automatic format handling
@@ -66,7 +70,7 @@ export class CommandExecutor {
         if (shouldUseNonInteractiveOutput(this.options)) {
             try {
                 await performDelete();
-                outputResult({ id, status: 'deleted' }, this.options);
+                outputResult({ id, status: "deleted" }, this.options);
             }
             catch (err) {
                 this.handleError(err);
@@ -75,11 +79,11 @@ export class CommandExecutor {
         }
         // Interactive mode
         // Enter alternate screen buffer
-        process.stdout.write('\x1b[?1049h');
+        process.stdout.write("\x1b[?1049h");
         const { waitUntilExit } = render(renderUI());
         await waitUntilExit();
         // Exit alternate screen buffer
-        process.stdout.write('\x1b[?1049l');
+        process.stdout.write("\x1b[?1049l");
     }
     /**
      * Fetch items from an async iterator with optional filtering and limits
@@ -104,7 +108,7 @@ export class CommandExecutor {
      * Handle errors consistently across all commands
      */
     handleError(error) {
-        if (this.options.output === 'yaml') {
+        if (this.options.output === "yaml") {
             console.error(YAML.stringify({ error: error.message }));
         }
         else {

package/dist/utils/client.js

@@ -1,5 +1,5 @@
-import Runloop from '@runloop/api-client';
-import { getConfig } from './config.js';
+import Runloop from "@runloop/api-client";
+import { getConfig } from "./config.js";
 /**
  * Get the base URL based on RUNLOOP_ENV environment variable
  * - dev: https://api.runloop.pro
@@ -8,17 +8,17 @@ import { getConfig } from './config.js';
 function getBaseUrl() {
     const env = process.env.RUNLOOP_ENV?.toLowerCase();
     switch (env) {
-        case 'dev':
-            return 'https://api.runloop.pro';
-        case 'prod':
+        case "dev":
+            return "https://api.runloop.pro";
+        case "prod":
         default:
-            return 'https://api.runloop.ai';
+            return "https://api.runloop.ai";
     }
 }
 export function getClient() {
     const config = getConfig();
     if (!config.apiKey) {
-        throw new Error('API key not configured. Run: rln auth');
+        throw new Error("API key not configured. Run: rli auth");
     }
     const baseURL = getBaseUrl();
     return new Runloop({

package/dist/utils/config.js

@@ -1,17 +1,143 @@
-import Conf from 'conf';
+import Conf from "conf";
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, statSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
 const config = new Conf({
-    projectName: 'runloop-cli',
+    projectName: "runloop-cli",
 });
 export function getConfig() {
     // Check environment variable first, then fall back to stored config
-    const apiKey = process.env.RUNLOOP_API_KEY || config.get('apiKey');
+    const apiKey = process.env.RUNLOOP_API_KEY || config.get("apiKey");
     return {
         apiKey,
     };
 }
 export function setApiKey(apiKey) {
-    config.set('apiKey', apiKey);
+    config.set("apiKey", apiKey);
 }
 export function clearConfig() {
     config.clear();
 }
+export function baseUrl() {
+    return process.env.RUNLOOP_ENV === "dev"
+        ? "https://api.runloop.pro"
+        : "https://api.runloop.ai";
+}
+export function sshUrl() {
+    return process.env.RUNLOOP_ENV === "dev"
+        ? "ssh.runloop.pro:443"
+        : "ssh.runloop.ai:443";
+}
+export function getCacheDir() {
+    return join(homedir(), ".cache", "rl-cli");
+}
+function getCurrentVersion() {
+    try {
+        // First try environment variable (when installed via npm)
+        if (process.env.npm_package_version) {
+            return process.env.npm_package_version;
+        }
+        // Fall back to reading package.json directly
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // When running from dist/, we need to go up two levels to find package.json
+        const packageJsonPath = join(__dirname, "../../package.json");
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return packageJson.version;
+    }
+    catch (error) {
+        // Ultimate fallback
+        return "0.1.0";
+    }
+}
+export function shouldCheckForUpdates() {
+    const cacheDir = getCacheDir();
+    const cacheFile = join(cacheDir, "last_update_check");
+    if (!existsSync(cacheFile)) {
+        return true;
+    }
+    const stats = statSync(cacheFile);
+    const hoursSinceUpdate = (Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60);
+    return hoursSinceUpdate >= 6;
+}
+export function hasCachedUpdateInfo() {
+    const cacheDir = getCacheDir();
+    const cacheFile = join(cacheDir, "last_update_check");
+    return existsSync(cacheFile);
+}
+export function updateCheckCache() {
+    const cacheDir = getCacheDir();
+    const cacheFile = join(cacheDir, "last_update_check");
+    // Create cache directory if it doesn't exist
+    if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, { recursive: true });
+    }
+    // Touch the cache file
+    writeFileSync(cacheFile, "");
+}
+export async function checkForUpdates(force = false) {
+    const currentVersion = getCurrentVersion();
+    // Always show cached result if available and not forcing
+    if (!force && hasCachedUpdateInfo() && !shouldCheckForUpdates()) {
+        // Show cached update info (we know there's an update available)
+        console.error(`\n🔄 Update available: ${currentVersion} → 0.1.0\n` +
+            `   Run: npm install -g @runloop/rl-cli@latest\n\n`);
+        return;
+    }
+    // Only fetch from npm if cache is expired or forcing
+    if (!force && !shouldCheckForUpdates()) {
+        return;
+    }
+    try {
+        const response = await fetch("https://registry.npmjs.org/@runloop/rl-cli/latest");
+        if (!response.ok) {
+            if (force) {
+                console.error("❌ Failed to check for updates\n");
+            }
+            return; // Silently fail if we can't check
+        }
+        const data = await response.json();
+        const latestVersion = data.version;
+        if (force) {
+            console.error(`Current version: ${currentVersion}\n`);
+            console.error(`Latest version: ${latestVersion}\n`);
+        }
+        if (latestVersion && latestVersion !== currentVersion) {
+            // Check if current version is older than latest
+            const isUpdateAvailable = compareVersions(latestVersion, currentVersion) > 0;
+            if (isUpdateAvailable) {
+                console.error(`\n🔄 Update available: ${currentVersion} → ${latestVersion}\n` +
+                    `   Run: npm install -g @runloop/rl-cli@latest\n\n`);
+            }
+            else if (force) {
+                console.error("✅ You're running the latest version!\n");
+            }
+        }
+        else if (force) {
+            console.error("✅ You're running the latest version!\n");
+        }
+        // Update the cache to indicate we've checked
+        updateCheckCache();
+    }
+    catch (error) {
+        if (force) {
+            console.error(`❌ Error checking for updates: ${error}\n`);
+        }
+        // Silently fail - don't interrupt the user's workflow
+    }
+}
+function compareVersions(version1, version2) {
+    const v1parts = version1.split('.').map(Number);
+    const v2parts = version2.split('.').map(Number);
+    for (let i = 0; i < Math.max(v1parts.length, v2parts.length); i++) {
+        const v1part = v1parts[i] || 0;
+        const v2part = v2parts[i] || 0;
+        if (v1part > v2part)
+            return 1;
+        if (v1part < v2part)
+            return -1;
+    }
+    return 0;
+}

package/dist/utils/interactiveCommand.js

@@ -3,12 +3,12 @@
  */
 export async function runInteractiveCommand(command) {
     // Enter alternate screen buffer
-    process.stdout.write('\x1b[?1049h');
+    process.stdout.write("\x1b[?1049h");
     try {
         await command();
     }
     finally {
         // Exit alternate screen buffer
-        process.stdout.write('\x1b[?1049l');
+        process.stdout.write("\x1b[?1049l");
     }
 }