@runloop/rl-cli 0.1.1 → 0.2.0

package/dist/mcp/server.js

@@ -2,7 +2,57 @@
 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";
+import Runloop from "@runloop/api-client";
+import Conf from "conf";
+let configInstance = null;
+function getConfigInstance() {
+    if (!configInstance) {
+        configInstance = new Conf({
+            projectName: "runloop-cli",
+        });
+    }
+    return configInstance;
+}
+function getConfig() {
+    // Check environment variable first
+    const envApiKey = process.env.RUNLOOP_API_KEY;
+    if (envApiKey) {
+        return { apiKey: envApiKey };
+    }
+    // Fall back to stored config
+    try {
+        const config = getConfigInstance();
+        const apiKey = config.get("apiKey");
+        return { apiKey };
+    }
+    catch (error) {
+        console.error("Warning: Failed to load config:", error);
+        return {};
+    }
+}
+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";
+    }
+}
+function getClient() {
+    const config = getConfig();
+    if (!config.apiKey) {
+        throw new Error("API key not configured. Please set RUNLOOP_API_KEY environment variable or 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)
+    });
+}
 // Define available tools for the MCP server
 const TOOLS = [
     {
@@ -386,12 +436,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 });
 // 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");
+    try {
+        console.error("[MCP] Starting Runloop MCP server...");
+        const transport = new StdioServerTransport();
+        console.error("[MCP] Created stdio transport");
+        await server.connect(transport);
+        // Log to stderr so it doesn't interfere with MCP protocol on stdout
+        console.error("[MCP] Server initialization complete, waiting for requests...");
+    }
+    catch (error) {
+        console.error("[MCP] Error in main():", error);
+        throw error;
+    }
 }
 main().catch((error) => {
-    console.error("Fatal error in main():", error);
+    console.error("[MCP] Fatal error in main():", error);
+    console.error("[MCP] Stack trace:", error instanceof Error ? error.stack : "N/A");
     process.exit(1);
 });

package/dist/router/Router.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Router - Manages screen navigation with clean mount/unmount lifecycle
+ * Replaces conditional rendering pattern from menu.tsx
+ */
+import React from "react";
+import { useNavigation } from "../store/navigationStore.js";
+import { useDevboxStore } from "../store/devboxStore.js";
+import { useBlueprintStore } from "../store/blueprintStore.js";
+import { useSnapshotStore } from "../store/snapshotStore.js";
+import { ErrorBoundary } from "../components/ErrorBoundary.js";
+// Import screen components
+import { MenuScreen } from "../screens/MenuScreen.js";
+import { DevboxListScreen } from "../screens/DevboxListScreen.js";
+import { DevboxDetailScreen } from "../screens/DevboxDetailScreen.js";
+import { DevboxActionsScreen } from "../screens/DevboxActionsScreen.js";
+import { DevboxCreateScreen } from "../screens/DevboxCreateScreen.js";
+import { BlueprintListScreen } from "../screens/BlueprintListScreen.js";
+import { SnapshotListScreen } from "../screens/SnapshotListScreen.js";
+import { SSHSessionScreen } from "../screens/SSHSessionScreen.js";
+/**
+ * Router component that renders the current screen
+ * Implements memory cleanup on route changes
+ *
+ * Uses React key prop to force complete unmount/remount on screen changes,
+ * which prevents Yoga WASM errors during transitions.
+ */
+export function Router() {
+    const { currentScreen, params } = useNavigation();
+    const prevScreenRef = React.useRef(null);
+    // Memory cleanup on route changes
+    React.useEffect(() => {
+        const prevScreen = prevScreenRef.current;
+        if (prevScreen && prevScreen !== currentScreen) {
+            // Immediate cleanup without delay - React's key-based remount handles timing
+            switch (prevScreen) {
+                case "devbox-list":
+                case "devbox-detail":
+                case "devbox-actions":
+                case "devbox-create":
+                    // Clear devbox data when leaving devbox screens
+                    // Keep cache if we're still in devbox context
+                    if (!currentScreen.startsWith("devbox")) {
+                        useDevboxStore.getState().clearAll();
+                    }
+                    break;
+                case "blueprint-list":
+                case "blueprint-detail":
+                    if (!currentScreen.startsWith("blueprint")) {
+                        useBlueprintStore.getState().clearAll();
+                    }
+                    break;
+                case "snapshot-list":
+                case "snapshot-detail":
+                    if (!currentScreen.startsWith("snapshot")) {
+                        useSnapshotStore.getState().clearAll();
+                    }
+                    break;
+            }
+        }
+        prevScreenRef.current = currentScreen;
+    }, [currentScreen]);
+    // CRITICAL: Use key prop to force React to completely unmount old component
+    // and mount new component, preventing race conditions during screen transitions.
+    // The key ensures React treats this as a completely new component tree.
+    // Wrap in ErrorBoundary to catch any Yoga WASM errors gracefully.
+    return (_jsxs(ErrorBoundary, { children: [currentScreen === "menu" && (_jsx(MenuScreen, { ...params }, currentScreen)), currentScreen === "devbox-list" && (_jsx(DevboxListScreen, { ...params }, currentScreen)), currentScreen === "devbox-detail" && (_jsx(DevboxDetailScreen, { ...params }, currentScreen)), currentScreen === "devbox-actions" && (_jsx(DevboxActionsScreen, { ...params }, currentScreen)), currentScreen === "devbox-create" && (_jsx(DevboxCreateScreen, { ...params }, currentScreen)), currentScreen === "blueprint-list" && (_jsx(BlueprintListScreen, { ...params }, currentScreen)), currentScreen === "blueprint-detail" && (_jsx(BlueprintListScreen, { ...params }, currentScreen)), currentScreen === "snapshot-list" && (_jsx(SnapshotListScreen, { ...params }, currentScreen)), currentScreen === "snapshot-detail" && (_jsx(SnapshotListScreen, { ...params }, currentScreen)), currentScreen === "ssh-session" && (_jsx(SSHSessionScreen, { ...params }, currentScreen))] }, `boundary-${currentScreen}`));
+}

package/dist/router/types.js

@@ -0,0 +1 @@
+export {};

package/dist/screens/BlueprintListScreen.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useNavigation } from "../store/navigationStore.js";
+import { ListBlueprintsUI } from "../commands/blueprint/list.js";
+export function BlueprintListScreen() {
+    const { goBack } = useNavigation();
+    return _jsx(ListBlueprintsUI, { onBack: goBack, onExit: goBack });
+}

package/dist/screens/DevboxActionsScreen.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * DevboxActionsScreen - Pure UI component for devbox actions
+ * Refactored from components/DevboxActionsMenu.tsx
+ */
+import React from "react";
+import { useNavigation } from "../store/navigationStore.js";
+import { useDevboxStore } from "../store/devboxStore.js";
+import { DevboxActionsMenu } from "../components/DevboxActionsMenu.js";
+export function DevboxActionsScreen({ devboxId, operation, }) {
+    const { goBack } = useNavigation();
+    const devboxes = useDevboxStore((state) => state.devboxes);
+    // Find devbox in store
+    const devbox = devboxes.find((d) => d.id === devboxId);
+    // Navigate back if devbox not found - must be in useEffect, not during render
+    React.useEffect(() => {
+        if (!devbox) {
+            goBack();
+        }
+    }, [devbox, goBack]);
+    if (!devbox) {
+        return null;
+    }
+    return (_jsx(DevboxActionsMenu, { devbox: devbox, onBack: goBack, initialOperation: operation }));
+}

package/dist/screens/DevboxCreateScreen.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useNavigation } from "../store/navigationStore.js";
+import { DevboxCreatePage } from "../components/DevboxCreatePage.js";
+export function DevboxCreateScreen() {
+    const { goBack } = useNavigation();
+    const handleCreate = () => {
+        // After creation, go back to list (which will refresh)
+        goBack();
+    };
+    return _jsx(DevboxCreatePage, { onBack: goBack, onCreate: handleCreate });
+}

package/dist/screens/DevboxDetailScreen.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * DevboxDetailScreen - Pure UI component for devbox details
+ * Refactored from components/DevboxDetailPage.tsx
+ */
+import React from "react";
+import { useNavigation } from "../store/navigationStore.js";
+import { useDevboxStore } from "../store/devboxStore.js";
+import { DevboxDetailPage } from "../components/DevboxDetailPage.js";
+import { getDevbox } from "../services/devboxService.js";
+import { SpinnerComponent } from "../components/Spinner.js";
+import { ErrorMessage } from "../components/ErrorMessage.js";
+import { Breadcrumb } from "../components/Breadcrumb.js";
+export function DevboxDetailScreen({ devboxId }) {
+    const { goBack } = useNavigation();
+    const devboxes = useDevboxStore((state) => state.devboxes);
+    const setDevboxesInStore = useDevboxStore((state) => state.setDevboxes);
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const [fetchedDevbox, setFetchedDevbox] = React.useState(null);
+    // Find devbox in store first
+    const devboxFromStore = devboxes.find((d) => d.id === devboxId);
+    // Fetch devbox from API if not in store
+    React.useEffect(() => {
+        if (!devboxFromStore && devboxId && !loading && !fetchedDevbox) {
+            setLoading(true);
+            setError(null);
+            getDevbox(devboxId)
+                .then((devbox) => {
+                setFetchedDevbox(devbox);
+                // Cache it in store for future access
+                setDevboxesInStore([devbox]);
+                setLoading(false);
+            })
+                .catch((err) => {
+                setError(err);
+                setLoading(false);
+            });
+        }
+    }, [devboxFromStore, devboxId, loading, fetchedDevbox, setDevboxesInStore]);
+    // Use devbox from store or fetched devbox
+    const devbox = devboxFromStore || fetchedDevbox;
+    // Show loading state while fetching
+    if (loading) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Devboxes" }, { label: "Loading...", active: true }] }), _jsx(SpinnerComponent, { message: "Loading devbox details..." })] }));
+    }
+    // Show error state if fetch failed
+    if (error) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Devboxes" }, { label: "Error", active: true }] }), _jsx(ErrorMessage, { message: "Failed to load devbox details", error: error })] }));
+    }
+    // Show error if no devbox found and not loading
+    if (!devbox && !loading) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Devboxes" }, { label: "Not Found", active: true }] }), _jsx(ErrorMessage, { message: `Devbox ${devboxId || "unknown"} not found`, error: new Error("Devbox not found in cache and could not be fetched") })] }));
+    }
+    // At this point devbox is guaranteed to exist (loading check above handles the null case)
+    if (!devbox) {
+        return null; // TypeScript guard - should never reach here
+    }
+    return _jsx(DevboxDetailPage, { devbox: devbox, onBack: goBack });
+}

package/dist/screens/DevboxListScreen.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * DevboxListScreen - Pure UI component using devboxStore
+ * Simplified version for now - wraps existing component
+ */
+import React from "react";
+import { useNavigation } from "../store/navigationStore.js";
+import { ListDevboxesUI } from "../commands/devbox/list.js";
+export function DevboxListScreen({ status, focusDevboxId, }) {
+    const { goBack, navigate } = useNavigation();
+    // If focusDevboxId is provided, navigate directly to detail screen
+    // instead of letting ListDevboxesUI handle it internally
+    React.useEffect(() => {
+        if (focusDevboxId) {
+            navigate("devbox-detail", { devboxId: focusDevboxId });
+        }
+    }, [focusDevboxId, navigate]);
+    // Navigation callback to handle detail view via Router
+    const handleNavigateToDetail = React.useCallback((devboxId) => {
+        navigate("devbox-detail", { devboxId });
+    }, [navigate]);
+    return (_jsx(ListDevboxesUI, { status: status, onBack: goBack, onExit: goBack, onNavigateToDetail: handleNavigateToDetail }));
+}

package/dist/screens/LogsSessionScreen.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * LogsSessionScreen - Logs viewer using custom InteractiveSpawn
+ * Runs the CLI logs command as a subprocess within the Ink UI without exiting
+ */
+import React from "react";
+import { Box, Text } from "ink";
+import { InteractiveSpawn } from "../components/InteractiveSpawn.js";
+import { useNavigation, } from "../store/navigationStore.js";
+import { Breadcrumb } from "../components/Breadcrumb.js";
+import { colors } from "../utils/theme.js";
+import figures from "figures";
+import { useExitOnCtrlC } from "../hooks/useExitOnCtrlC.js";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+export function LogsSessionScreen() {
+    const { params, navigate } = useNavigation();
+    // Handle Ctrl+C to exit (before logs command runs or on error)
+    useExitOnCtrlC();
+    // Extract params
+    const devboxId = params.devboxId;
+    const devboxName = params.devboxName || params.devboxId || "devbox";
+    const returnScreen = params.returnScreen || "devbox-list";
+    const returnParams = params.returnParams || {};
+    // Get the path to the CLI executable
+    const cliPath = React.useMemo(() => {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // When compiled, this file is in dist/screens/, so go up one level to dist/cli.js
+        return join(__dirname, "../cli.js");
+    }, []);
+    // Validate required params
+    if (!devboxId) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Logs", active: true }] }), _jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsxs(Text, { color: colors.error, children: [figures.cross, " Missing devbox ID. Returning..."] }) })] }));
+    }
+    // Build CLI command args
+    const cliArgs = React.useMemo(() => ["devbox", "logs", devboxId], [devboxId]);
+    return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "Logs", active: true }] }), _jsxs(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [_jsxs(Text, { color: colors.primary, bold: true, children: [figures.info, " Viewing logs for ", devboxName, "..."] }), _jsx(Text, { color: colors.textDim, dimColor: true, children: "Press Ctrl+C to exit" })] }), _jsx(InteractiveSpawn, { command: "node", args: [cliPath, ...cliArgs], onExit: (_code) => {
+                    // Navigate back to previous screen when logs command exits
+                    setTimeout(() => {
+                        navigate(returnScreen, returnParams || {});
+                    }, 100);
+                }, onError: (_error) => {
+                    // On error, navigate back as well
+                    setTimeout(() => {
+                        navigate(returnScreen, returnParams || {});
+                    }, 100);
+                } })] }));
+}

package/dist/screens/MenuScreen.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useNavigation } from "../store/navigationStore.js";
+import { MainMenu } from "../components/MainMenu.js";
+export function MenuScreen() {
+    const { navigate } = useNavigation();
+    const handleSelect = (key) => {
+        switch (key) {
+            case "devboxes":
+                navigate("devbox-list");
+                break;
+            case "blueprints":
+                navigate("blueprint-list");
+                break;
+            case "snapshots":
+                navigate("snapshot-list");
+                break;
+            default:
+                // Fallback for any other screen names
+                navigate(key);
+        }
+    };
+    return _jsx(MainMenu, { onSelect: handleSelect });
+}

package/dist/screens/SSHSessionScreen.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * SSHSessionScreen - SSH session using custom InteractiveSpawn
+ * Runs SSH as a subprocess within the Ink UI without exiting
+ */
+import React from "react";
+import { Box, Text } from "ink";
+import { InteractiveSpawn } from "../components/InteractiveSpawn.js";
+import { useNavigation, } from "../store/navigationStore.js";
+import { Breadcrumb } from "../components/Breadcrumb.js";
+import { colors } from "../utils/theme.js";
+import figures from "figures";
+export function SSHSessionScreen() {
+    const { params, replace } = useNavigation();
+    // NOTE: Do NOT use useExitOnCtrlC here - SSH handles Ctrl+C itself
+    // Using useInput would conflict with the subprocess's terminal control
+    // Extract SSH config from params
+    const keyPath = params.keyPath;
+    const proxyCommand = params.proxyCommand;
+    const sshUser = params.sshUser;
+    const url = params.url;
+    const devboxName = params.devboxName || params.devboxId || "devbox";
+    const returnScreen = params.returnScreen || "devbox-list";
+    const returnParams = params.returnParams || {};
+    // Validate required params
+    if (!keyPath || !proxyCommand || !sshUser || !url) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "SSH Session", active: true }] }), _jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsxs(Text, { color: colors.error, children: [figures.cross, " Missing SSH configuration. Returning..."] }) })] }));
+    }
+    // Build SSH command args
+    // The proxy command needs to be passed as a single value in the -o option
+    const sshArgs = React.useMemo(() => [
+        "-t", // Force pseudo-terminal allocation for proper input handling
+        "-i",
+        keyPath,
+        "-o",
+        `ProxyCommand=${proxyCommand}`,
+        "-o",
+        "StrictHostKeyChecking=no",
+        "-o",
+        "UserKnownHostsFile=/dev/null",
+        `${sshUser}@${url}`,
+    ], [keyPath, proxyCommand, sshUser, url]);
+    return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [{ label: "SSH Session", active: true }] }), _jsxs(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [_jsxs(Text, { color: colors.primary, bold: true, children: [figures.play, " Connecting to ", devboxName, "..."] }), _jsx(Text, { color: colors.textDim, dimColor: true, children: "Press Ctrl+C or type exit to disconnect" })] }), _jsx(InteractiveSpawn, { command: "ssh", args: sshArgs, onExit: (_code) => {
+                    // Replace current screen (don't add SSH to history stack)
+                    // Using replace() instead of navigate() prevents "escape goes back to SSH" bug
+                    setTimeout(() => {
+                        replace(returnScreen, returnParams || {});
+                    }, 100);
+                }, onError: (_error) => {
+                    // On error, replace current screen as well
+                    setTimeout(() => {
+                        replace(returnScreen, returnParams || {});
+                    }, 100);
+                } })] }));
+}

package/dist/screens/SnapshotListScreen.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useNavigation } from "../store/navigationStore.js";
+import { ListSnapshotsUI } from "../commands/snapshot/list.js";
+export function SnapshotListScreen() {
+    const { goBack } = useNavigation();
+    return _jsx(ListSnapshotsUI, { onBack: goBack, onExit: goBack });
+}

package/dist/services/blueprintService.js

@@ -0,0 +1,105 @@
+/**
+ * Blueprint Service - Handles all blueprint API calls
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List blueprints with pagination
+ */
+export async function listBlueprints(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    if (options.search) {
+        queryParams.name = options.search;
+    }
+    const pagePromise = client.blueprints.list(queryParams);
+    const page = (await pagePromise);
+    const blueprints = [];
+    if (page.blueprints && Array.isArray(page.blueprints)) {
+        page.blueprints.forEach((b) => {
+            // CRITICAL: Truncate all strings to prevent Yoga crashes
+            const MAX_ID_LENGTH = 100;
+            const MAX_NAME_LENGTH = 200;
+            const MAX_STATUS_LENGTH = 50;
+            const MAX_ARCH_LENGTH = 50;
+            const MAX_RESOURCES_LENGTH = 100;
+            // Extract architecture and resources from launch_parameters
+            const architecture = b.parameters?.launch_parameters?.architecture;
+            const resources = b.parameters?.launch_parameters?.resource_size_request;
+            blueprints.push({
+                id: String(b.id || "").substring(0, MAX_ID_LENGTH),
+                name: String(b.name || "").substring(0, MAX_NAME_LENGTH),
+                status: String(b.status || "").substring(0, MAX_STATUS_LENGTH),
+                create_time_ms: b.create_time_ms,
+                build_status: b.status
+                    ? String(b.status).substring(0, MAX_STATUS_LENGTH)
+                    : undefined,
+                architecture: architecture
+                    ? String(architecture).substring(0, MAX_ARCH_LENGTH)
+                    : undefined,
+                resources: resources
+                    ? String(resources).substring(0, MAX_RESOURCES_LENGTH)
+                    : undefined,
+            });
+        });
+    }
+    const result = {
+        blueprints,
+        totalCount: page.total_count || blueprints.length,
+        hasMore: page.has_more || false,
+    };
+    return result;
+}
+/**
+ * Get a single blueprint by ID
+ */
+export async function getBlueprint(id) {
+    const client = getClient();
+    const blueprint = await client.blueprints.retrieve(id);
+    return {
+        id: blueprint.id,
+        name: blueprint.name,
+        status: blueprint.status,
+        create_time_ms: blueprint.create_time_ms,
+        build_status: blueprint.build_status,
+        architecture: blueprint.architecture,
+        resources: blueprint.resources,
+    };
+}
+/**
+ * Get blueprint logs
+ */
+export async function getBlueprintLogs(id) {
+    const client = getClient();
+    const response = await client.blueprints.logs(id);
+    // CRITICAL: Truncate all strings to prevent Yoga crashes
+    const MAX_MESSAGE_LENGTH = 1000;
+    const MAX_LEVEL_LENGTH = 20;
+    const logs = [];
+    if (response.logs && Array.isArray(response.logs)) {
+        response.logs.forEach((log) => {
+            // Truncate message and escape newlines
+            let message = String(log.message || "");
+            if (message.length > MAX_MESSAGE_LENGTH) {
+                message = message.substring(0, MAX_MESSAGE_LENGTH) + "...";
+            }
+            message = message
+                .replace(/\r\n/g, "\\n")
+                .replace(/\n/g, "\\n")
+                .replace(/\r/g, "\\r")
+                .replace(/\t/g, "\\t");
+            logs.push({
+                timestamp: log.timestamp,
+                message,
+                level: log.level
+                    ? String(log.level).substring(0, MAX_LEVEL_LENGTH)
+                    : undefined,
+            });
+        });
+    }
+    return logs;
+}