@runloop/rl-cli 0.0.2 → 0.1.0

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
@@ -28,9 +32,13 @@ export class CommandExecutor {
             return;
         }
         // Interactive mode
+        // Enter alternate screen buffer
+        process.stdout.write("\x1b[?1049h");
         console.clear();
         const { waitUntilExit } = render(renderUI());
         await waitUntilExit();
+        // Exit alternate screen buffer
+        process.stdout.write("\x1b[?1049l");
     }
     /**
      * Execute a create/action command with automatic format handling
@@ -47,9 +55,13 @@ export class CommandExecutor {
             return;
         }
         // Interactive mode
+        // Enter alternate screen buffer
+        process.stdout.write("\x1b[?1049h");
         console.clear();
         const { waitUntilExit } = render(renderUI());
         await waitUntilExit();
+        // Exit alternate screen buffer
+        process.stdout.write("\x1b[?1049l");
     }
     /**
      * Execute a delete command with automatic format handling
@@ -58,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);
@@ -66,8 +78,12 @@ export class CommandExecutor {
             return;
         }
         // Interactive mode
+        // Enter alternate screen buffer
+        process.stdout.write("\x1b[?1049h");
         const { waitUntilExit } = render(renderUI());
         await waitUntilExit();
+        // Exit alternate screen buffer
+        process.stdout.write("\x1b[?1049l");
     }
     /**
      * Fetch items from an async iterator with optional filtering and limits
@@ -92,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,12 +1,29 @@
-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
+ * - prod or unset: https://api.runloop.ai (default)
+ */
+function getBaseUrl() {
+    const env = process.env.RUNLOOP_ENV?.toLowerCase();
+    switch (env) {
+        case "dev":
+            return "https://api.runloop.pro";
+        case "prod":
+        default:
+            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({
         bearerToken: config.apiKey,
+        baseURL,
         timeout: 10000, // 10 seconds instead of default 30 seconds
         maxRetries: 2, // 2 retries instead of default 5 (only for retryable errors)
     });

package/dist/utils/config.js

@@ -1,17 +1,53 @@
-import Conf from 'conf';
+import Conf from "conf";
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, statSync, mkdirSync, writeFileSync } from "fs";
 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");
+}
+export function shouldCheckForUpdates() {
+    const cacheDir = getCacheDir();
+    const cacheFile = join(cacheDir, "last_update_check");
+    if (!existsSync(cacheFile)) {
+        return true;
+    }
+    const stats = statSync(cacheFile);
+    const daysSinceUpdate = (Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60 * 24);
+    return daysSinceUpdate >= 1;
+}
+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, "");
+}

package/dist/utils/interactiveCommand.js

@@ -0,0 +1,14 @@
+/**
+ * Wrapper for interactive commands that need alternate screen buffer management
+ */
+export async function runInteractiveCommand(command) {
+    // Enter alternate screen buffer
+    process.stdout.write("\x1b[?1049h");
+    try {
+        await command();
+    }
+    finally {
+        // Exit alternate screen buffer
+        process.stdout.write("\x1b[?1049l");
+    }
+}

package/dist/utils/output.js

@@ -1,31 +1,31 @@
 /**
  * Utility for handling different output formats across CLI commands
  */
-import YAML from 'yaml';
+import YAML from "yaml";
 /**
  * Check if the command should use non-interactive output
  */
 export function shouldUseNonInteractiveOutput(options) {
-    return !!options.output;
+    return !!options.output && options.output !== "interactive";
 }
 /**
  * Output data in the specified format
  */
-export function outputData(data, format = 'json') {
-    if (format === 'json') {
+export function outputData(data, format = "json") {
+    if (format === "json") {
         console.log(JSON.stringify(data, null, 2));
         return;
     }
-    if (format === 'yaml') {
+    if (format === "yaml") {
         console.log(YAML.stringify(data));
         return;
     }
-    if (format === 'text') {
+    if (format === "text") {
         // Simple text output
         if (Array.isArray(data)) {
             // For lists of complex objects, just output IDs
             data.forEach((item) => {
-                if (typeof item === 'object' && item !== null && 'id' in item) {
+                if (typeof item === "object" && item !== null && "id" in item) {
                     console.log(item.id);
                 }
                 else {
@@ -45,7 +45,7 @@ export function outputData(data, format = 'json') {
  * Format a single item as text output
  */
 function formatTextOutput(item) {
-    if (typeof item === 'string') {
+    if (typeof item === "string") {
         return item;
     }
     // For objects, create a simple key: value format
@@ -55,7 +55,7 @@ function formatTextOutput(item) {
             lines.push(`${key}: ${value}`);
         }
     }
-    return lines.join('\n');
+    return lines.join("\n");
 }
 /**
  * Output a single result (for create, delete, etc)
@@ -83,10 +83,10 @@ export function outputList(items, options) {
  */
 export function outputError(error, options) {
     if (shouldUseNonInteractiveOutput(options)) {
-        if (options.output === 'json') {
+        if (options.output === "json") {
             console.error(JSON.stringify({ error: error.message }, null, 2));
         }
-        else if (options.output === 'yaml') {
+        else if (options.output === "yaml") {
             console.error(YAML.stringify({ error: error.message }));
         }
         else {
@@ -101,14 +101,14 @@ export function outputError(error, options) {
  * Validate output format option
  */
 export function validateOutputFormat(format) {
-    if (!format || format === 'text') {
-        return 'text';
+    if (!format || format === "text") {
+        return "text";
     }
-    if (format === 'json') {
-        return 'json';
+    if (format === "json") {
+        return "json";
     }
-    if (format === 'yaml') {
-        return 'yaml';
+    if (format === "yaml") {
+        return "yaml";
     }
     console.error(`Unknown output format: ${format}. Valid options: text, json, yaml`);
     process.exit(1);