@runloop/rl-cli 0.1.1 → 0.2.0

package/dist/services/devboxService.js

@@ -0,0 +1,215 @@
+/**
+ * Devbox Service - Handles all devbox API calls
+ * Returns plain data objects with no SDK reference retention
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * Recursively truncate all strings in an object to prevent Yoga crashes
+ * CRITICAL: Must be applied to ALL data from API before storing/rendering
+ */
+function truncateStrings(obj, maxLength = 200) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (typeof obj === "string") {
+        return (obj.length > maxLength ? obj.substring(0, maxLength) : obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => truncateStrings(item, maxLength));
+    }
+    if (typeof obj === "object") {
+        const result = {};
+        for (const key in obj) {
+            if (Object.hasOwn(obj, key)) {
+                result[key] = truncateStrings(obj[key], maxLength);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+/**
+ * List devboxes with pagination
+ * CRITICAL: Creates defensive copies to break SDK reference chains
+ */
+export async function listDevboxes(options) {
+    // Check if aborted before making request
+    if (options.signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+    }
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    if (options.status) {
+        queryParams.status = options.status;
+    }
+    if (options.search) {
+        queryParams.name = options.search;
+    }
+    // Fetch ONE page only - never iterate
+    const pagePromise = client.devboxes.list(queryParams);
+    // Wrap in Promise.race to support abort
+    let page;
+    if (options.signal) {
+        const abortPromise = new Promise((_, reject) => {
+            options.signal.addEventListener("abort", () => {
+                reject(new DOMException("Aborted", "AbortError"));
+            });
+        });
+        try {
+            page = (await Promise.race([
+                pagePromise,
+                abortPromise,
+            ]));
+        }
+        catch (err) {
+            // Re-throw abort errors, convert others
+            if (err?.name === "AbortError") {
+                throw err;
+            }
+            throw err;
+        }
+    }
+    else {
+        page = (await pagePromise);
+    }
+    // Check again after await (in case abort happened during request)
+    if (options.signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+    }
+    // Extract data and create defensive copies immediately
+    const devboxes = [];
+    if (page.devboxes && Array.isArray(page.devboxes)) {
+        page.devboxes.forEach((d) => {
+            // CRITICAL: Recursively truncate ALL strings in the object to prevent Yoga crashes
+            // This catches nested fields like launch_parameters.user_parameters.username
+            const truncated = truncateStrings(d, 200);
+            devboxes.push(truncated);
+        });
+    }
+    const result = {
+        devboxes,
+        totalCount: page.total_count || devboxes.length,
+        hasMore: page.has_more || false,
+    };
+    return result;
+}
+/**
+ * Get a single devbox by ID
+ */
+export async function getDevbox(id) {
+    const client = getClient();
+    const devbox = await client.devboxes.retrieve(id);
+    // CRITICAL: Recursively truncate ALL strings in the object to prevent Yoga crashes
+    return truncateStrings(devbox, 200);
+}
+/**
+ * Delete a devbox (actually shuts it down)
+ */
+export async function deleteDevbox(id) {
+    const client = getClient();
+    await client.devboxes.shutdown(id);
+}
+/**
+ * Shutdown a devbox
+ */
+export async function shutdownDevbox(id) {
+    const client = getClient();
+    await client.devboxes.shutdown(id);
+}
+/**
+ * Suspend a devbox
+ */
+export async function suspendDevbox(id) {
+    const client = getClient();
+    await client.devboxes.suspend(id);
+}
+/**
+ * Resume a devbox
+ */
+export async function resumeDevbox(id) {
+    const client = getClient();
+    await client.devboxes.resume(id);
+}
+/**
+ * Upload file to devbox
+ */
+export async function uploadFile(id, filepath, remotePath) {
+    const client = getClient();
+    const fs = await import("fs");
+    const fileStream = fs.createReadStream(filepath);
+    await client.devboxes.uploadFile(id, {
+        file: fileStream,
+        path: remotePath,
+    });
+}
+/**
+ * Create snapshot of devbox
+ */
+export async function createSnapshot(id, name) {
+    const client = getClient();
+    const snapshot = await client.devboxes.snapshotDisk(id, { name });
+    return {
+        id: String(snapshot.id || "").substring(0, 100),
+        name: snapshot.name ? String(snapshot.name).substring(0, 200) : undefined,
+    };
+}
+/**
+ * Create SSH key for devbox
+ */
+export async function createSSHKey(id) {
+    const client = getClient();
+    const result = await client.devboxes.createSSHKey(id);
+    // Truncate keys if they're unexpectedly long (shouldn't happen, but safety)
+    return {
+        ssh_private_key: String(result.ssh_private_key || "").substring(0, 10000),
+        url: String(result.url || "").substring(0, 500),
+    };
+}
+/**
+ * Create tunnel to devbox
+ */
+export async function createTunnel(id, port) {
+    const client = getClient();
+    const tunnel = await client.devboxes.createTunnel(id, { port });
+    return {
+        url: String(tunnel.url || "").substring(0, 500),
+    };
+}
+/**
+ * Execute command in devbox
+ */
+export async function execCommand(id, command) {
+    const client = getClient();
+    const result = await client.devboxes.executeSync(id, { command });
+    // CRITICAL: Truncate output to prevent Yoga crashes
+    const MAX_OUTPUT_LENGTH = 10000; // Allow more for command output
+    let stdout = String(result.stdout || "");
+    let stderr = String(result.stderr || "");
+    if (stdout.length > MAX_OUTPUT_LENGTH) {
+        stdout =
+            stdout.substring(0, MAX_OUTPUT_LENGTH) + "\n... (output truncated)";
+    }
+    if (stderr.length > MAX_OUTPUT_LENGTH) {
+        stderr =
+            stderr.substring(0, MAX_OUTPUT_LENGTH) + "\n... (output truncated)";
+    }
+    return {
+        stdout,
+        stderr,
+        exit_code: result.exit_code || 0,
+    };
+}
+/**
+ * Get devbox logs
+ * Returns the raw logs array from the API response
+ */
+export async function getDevboxLogs(id) {
+    const client = getClient();
+    const response = await client.devboxes.logs.list(id);
+    // Return the logs array directly - formatting is handled by logFormatter
+    return response.logs || [];
+}

package/dist/services/snapshotService.js

@@ -0,0 +1,81 @@
+/**
+ * Snapshot Service - Handles all snapshot API calls
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List snapshots with pagination
+ */
+export async function listSnapshots(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    if (options.devboxId) {
+        queryParams.devbox_id = options.devboxId;
+    }
+    const pagePromise = client.devboxes.listDiskSnapshots(queryParams);
+    const page = (await pagePromise);
+    const snapshots = [];
+    if (page.snapshots && Array.isArray(page.snapshots)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        page.snapshots.forEach((s) => {
+            // CRITICAL: Truncate all strings to prevent Yoga crashes
+            const MAX_ID_LENGTH = 100;
+            const MAX_NAME_LENGTH = 200;
+            const MAX_STATUS_LENGTH = 50;
+            // Status is constructed/available in API response but not in type definition
+            const snapshotView = s;
+            snapshots.push({
+                id: String(snapshotView.id || "").substring(0, MAX_ID_LENGTH),
+                name: snapshotView.name
+                    ? String(snapshotView.name).substring(0, MAX_NAME_LENGTH)
+                    : undefined,
+                devbox_id: String(snapshotView.source_devbox_id || "").substring(0, MAX_ID_LENGTH),
+                status: snapshotView.status
+                    ? String(snapshotView.status).substring(0, MAX_STATUS_LENGTH)
+                    : "",
+                create_time_ms: snapshotView.create_time_ms,
+            });
+        });
+    }
+    const result = {
+        snapshots,
+        totalCount: page.total_count || snapshots.length,
+        hasMore: page.has_more || false,
+    };
+    return result;
+}
+/**
+ * Get snapshot status by ID
+ */
+export async function getSnapshotStatus(id) {
+    const client = getClient();
+    const status = await client.devboxes.diskSnapshots.queryStatus(id);
+    return status;
+}
+/**
+ * Create a snapshot
+ */
+export async function createSnapshot(devboxId, name) {
+    const client = getClient();
+    const snapshot = await client.devboxes.snapshotDisk(devboxId, {
+        name,
+    });
+    return {
+        id: snapshot.id,
+        name: snapshot.name || undefined,
+        devbox_id: snapshot.devbox_id || devboxId,
+        status: snapshot.status || "pending",
+        create_time_ms: snapshot.create_time_ms,
+    };
+}
+/**
+ * Delete a snapshot
+ */
+export async function deleteSnapshot(id) {
+    const client = getClient();
+    await client.devboxes.diskSnapshots.delete(id);
+}

package/dist/store/blueprintStore.js

@@ -0,0 +1,89 @@
+/**
+ * Blueprint Store - Manages blueprint list state, pagination, and caching
+ */
+import { create } from "zustand";
+const MAX_CACHE_SIZE = 10;
+export const useBlueprintStore = create((set, get) => ({
+    blueprints: [],
+    loading: false,
+    initialLoading: true,
+    error: null,
+    currentPage: 0,
+    pageSize: 10,
+    totalCount: 0,
+    hasMore: false,
+    pageCache: new Map(),
+    lastIdCache: new Map(),
+    searchQuery: "",
+    selectedIndex: 0,
+    setBlueprints: (blueprints) => set({ blueprints }),
+    setLoading: (loading) => set({ loading }),
+    setInitialLoading: (loading) => set({ initialLoading: loading }),
+    setError: (error) => set({ error }),
+    setCurrentPage: (page) => set({ currentPage: page }),
+    setPageSize: (size) => set({ pageSize: size }),
+    setTotalCount: (count) => set({ totalCount: count }),
+    setHasMore: (hasMore) => set({ hasMore }),
+    setSearchQuery: (query) => set({ searchQuery: query }),
+    setSelectedIndex: (index) => set({ selectedIndex: index }),
+    cachePageData: (page, data, lastId) => {
+        const state = get();
+        const pageCache = state.pageCache;
+        const lastIdCache = state.lastIdCache;
+        // Aggressive LRU eviction
+        if (pageCache.size >= MAX_CACHE_SIZE) {
+            const oldestKey = pageCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                pageCache.delete(oldestKey);
+                lastIdCache.delete(oldestKey);
+            }
+        }
+        // Create plain data objects to avoid SDK references
+        const plainData = data.map((b) => ({
+            id: b.id,
+            name: b.name,
+            status: b.status,
+            create_time_ms: b.create_time_ms,
+            build_status: b.build_status,
+            architecture: b.architecture,
+            resources: b.resources,
+        }));
+        pageCache.set(page, plainData);
+        lastIdCache.set(page, lastId);
+        set({});
+    },
+    getCachedPage: (page) => {
+        return get().pageCache.get(page);
+    },
+    clearCache: () => {
+        const state = get();
+        state.pageCache.clear();
+        state.lastIdCache.clear();
+        set({
+            pageCache: new Map(),
+            lastIdCache: new Map(),
+        });
+    },
+    clearAll: () => {
+        const state = get();
+        state.pageCache.clear();
+        state.lastIdCache.clear();
+        set({
+            blueprints: [],
+            loading: false,
+            initialLoading: true,
+            error: null,
+            currentPage: 0,
+            totalCount: 0,
+            hasMore: false,
+            pageCache: new Map(),
+            lastIdCache: new Map(),
+            searchQuery: "",
+            selectedIndex: 0,
+        });
+    },
+    getSelectedBlueprint: () => {
+        const state = get();
+        return state.blueprints[state.selectedIndex];
+    },
+}));

package/dist/store/devboxStore.js

@@ -0,0 +1,105 @@
+/**
+ * Devbox Store - Manages devbox list state, pagination, and caching
+ * Replaces useState/useRef from ListDevboxesUI
+ */
+import { create } from "zustand";
+const MAX_CACHE_SIZE = 10; // Limit cache to 10 pages
+export const useDevboxStore = create((set, get) => ({
+    // Initial state
+    devboxes: [],
+    loading: false,
+    initialLoading: true,
+    error: null,
+    currentPage: 0,
+    pageSize: 10,
+    totalCount: 0,
+    hasMore: false,
+    pageCache: new Map(),
+    lastIdCache: new Map(),
+    searchQuery: "",
+    statusFilter: undefined,
+    selectedIndex: 0,
+    // Actions
+    setDevboxes: (devboxes) => {
+        const state = get();
+        const maxIndex = devboxes.length > 0 ? devboxes.length - 1 : 0;
+        const clampedIndex = Math.max(0, Math.min(state.selectedIndex, maxIndex));
+        set({ devboxes, selectedIndex: clampedIndex });
+    },
+    setLoading: (loading) => set({ loading }),
+    setInitialLoading: (loading) => set({ initialLoading: loading }),
+    setError: (error) => set({ error }),
+    setCurrentPage: (page) => set({ currentPage: page }),
+    setPageSize: (size) => set({ pageSize: size }),
+    setTotalCount: (count) => set({ totalCount: count }),
+    setHasMore: (hasMore) => set({ hasMore }),
+    setSearchQuery: (query) => set({ searchQuery: query }),
+    setStatusFilter: (status) => set({ statusFilter: status }),
+    setSelectedIndex: (index) => {
+        const state = get();
+        const maxIndex = state.devboxes.length > 0 ? state.devboxes.length - 1 : 0;
+        const clampedIndex = Math.max(0, Math.min(index, maxIndex));
+        set({ selectedIndex: clampedIndex });
+    },
+    // Cache management with LRU eviction - FIXED: No shallow copies
+    cachePageData: (page, data, lastId) => {
+        const state = get();
+        const pageCache = state.pageCache;
+        const lastIdCache = state.lastIdCache;
+        // Aggressive LRU eviction: Remove oldest entries if at limit
+        if (pageCache.size >= MAX_CACHE_SIZE) {
+            const oldestKey = pageCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                pageCache.delete(oldestKey);
+                lastIdCache.delete(oldestKey);
+            }
+        }
+        // Deep copy all fields to avoid SDK references
+        const plainData = data.map((d) => {
+            // Create a deep copy using JSON serialization for safety
+            return JSON.parse(JSON.stringify(d));
+        });
+        pageCache.set(page, plainData);
+        lastIdCache.set(page, lastId);
+        // Trigger update without creating new Map
+        set({});
+    },
+    getCachedPage: (page) => {
+        return get().pageCache.get(page);
+    },
+    clearCache: () => {
+        const state = get();
+        // Explicitly clear all entries before reassigning
+        state.pageCache.clear();
+        state.lastIdCache.clear();
+        set({
+            pageCache: new Map(),
+            lastIdCache: new Map(),
+        });
+    },
+    // Aggressive memory cleanup
+    clearAll: () => {
+        const state = get();
+        // Clear existing structures first to release references
+        state.pageCache.clear();
+        state.lastIdCache.clear();
+        set({
+            devboxes: [],
+            loading: false,
+            initialLoading: true,
+            error: null,
+            currentPage: 0,
+            totalCount: 0,
+            hasMore: false,
+            pageCache: new Map(),
+            lastIdCache: new Map(),
+            searchQuery: "",
+            selectedIndex: 0,
+        });
+    },
+    // Getters
+    getSelectedDevbox: () => {
+        const state = get();
+        return state.devboxes[state.selectedIndex];
+    },
+}));

package/dist/store/index.js

@@ -0,0 +1,7 @@
+/**
+ * Root Store - Exports all stores for easy importing
+ */
+export { useNavigation, useNavigationStore, NavigationProvider, } from "./navigationStore.js";
+export { useDevboxStore } from "./devboxStore.js";
+export { useBlueprintStore } from "./blueprintStore.js";
+export { useSnapshotStore } from "./snapshotStore.js";

package/dist/store/navigationStore.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+const NavigationContext = React.createContext(null);
+export function NavigationProvider({ initialScreen = "menu", initialParams = {}, children, }) {
+    // Use a single state object to avoid timing issues
+    const [state, setState] = React.useState({
+        currentScreen: initialScreen,
+        params: initialParams,
+        history: [],
+    });
+    const navigate = React.useCallback((screen, newParams = {}) => {
+        setState((prev) => ({
+            currentScreen: screen,
+            params: newParams,
+            history: [
+                ...prev.history,
+                { screen: prev.currentScreen, params: prev.params },
+            ],
+        }));
+    }, []);
+    const push = React.useCallback((screen, newParams = {}) => {
+        setState((prev) => ({
+            currentScreen: screen,
+            params: newParams,
+            history: [
+                ...prev.history,
+                { screen: prev.currentScreen, params: prev.params },
+            ],
+        }));
+    }, []);
+    const replace = React.useCallback((screen, newParams = {}) => {
+        setState((prev) => ({
+            ...prev,
+            currentScreen: screen,
+            params: newParams,
+        }));
+    }, []);
+    const goBack = React.useCallback(() => {
+        setState((prev) => {
+            if (prev.history.length > 0) {
+                const newHistory = [...prev.history];
+                const previousScreen = newHistory.pop();
+                return {
+                    currentScreen: previousScreen.screen,
+                    params: previousScreen.params,
+                    history: newHistory,
+                };
+            }
+            else {
+                // If no history, go to menu
+                return {
+                    currentScreen: "menu",
+                    params: {},
+                    history: [],
+                };
+            }
+        });
+    }, []);
+    const reset = React.useCallback(() => {
+        setState({
+            currentScreen: "menu",
+            params: {},
+            history: [],
+        });
+    }, []);
+    const canGoBack = React.useCallback(() => state.history.length > 0, [state.history.length]);
+    const value = React.useMemo(() => ({
+        currentScreen: state.currentScreen,
+        params: state.params,
+        navigate,
+        push,
+        replace,
+        goBack,
+        reset,
+        canGoBack,
+    }), [
+        state.currentScreen,
+        state.params,
+        navigate,
+        push,
+        replace,
+        goBack,
+        reset,
+        canGoBack,
+    ]);
+    return (_jsx(NavigationContext.Provider, { value: value, children: children }));
+}
+export function useNavigation() {
+    const context = React.useContext(NavigationContext);
+    if (!context) {
+        throw new Error("useNavigation must be used within NavigationProvider");
+    }
+    return context;
+}
+export function useNavigationStore(selector) {
+    const context = useNavigation();
+    if (!selector) {
+        return context;
+    }
+    return selector(context);
+}

package/dist/store/snapshotStore.js

@@ -0,0 +1,87 @@
+/**
+ * Snapshot Store - Manages snapshot list state, pagination, and caching
+ */
+import { create } from "zustand";
+const MAX_CACHE_SIZE = 10;
+export const useSnapshotStore = create((set, get) => ({
+    snapshots: [],
+    loading: false,
+    initialLoading: true,
+    error: null,
+    currentPage: 0,
+    pageSize: 10,
+    totalCount: 0,
+    hasMore: false,
+    pageCache: new Map(),
+    lastIdCache: new Map(),
+    devboxIdFilter: undefined,
+    selectedIndex: 0,
+    setSnapshots: (snapshots) => set({ snapshots }),
+    setLoading: (loading) => set({ loading }),
+    setInitialLoading: (loading) => set({ initialLoading: loading }),
+    setError: (error) => set({ error }),
+    setCurrentPage: (page) => set({ currentPage: page }),
+    setPageSize: (size) => set({ pageSize: size }),
+    setTotalCount: (count) => set({ totalCount: count }),
+    setHasMore: (hasMore) => set({ hasMore }),
+    setDevboxIdFilter: (devboxId) => set({ devboxIdFilter: devboxId }),
+    setSelectedIndex: (index) => set({ selectedIndex: index }),
+    cachePageData: (page, data, lastId) => {
+        const state = get();
+        const pageCache = state.pageCache;
+        const lastIdCache = state.lastIdCache;
+        // Aggressive LRU eviction
+        if (pageCache.size >= MAX_CACHE_SIZE) {
+            const oldestKey = pageCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                pageCache.delete(oldestKey);
+                lastIdCache.delete(oldestKey);
+            }
+        }
+        // Create plain data objects to avoid SDK references
+        const plainData = data.map((s) => ({
+            id: s.id,
+            name: s.name,
+            devbox_id: s.devbox_id,
+            status: s.status,
+            create_time_ms: s.create_time_ms,
+        }));
+        pageCache.set(page, plainData);
+        lastIdCache.set(page, lastId);
+        set({});
+    },
+    getCachedPage: (page) => {
+        return get().pageCache.get(page);
+    },
+    clearCache: () => {
+        const state = get();
+        state.pageCache.clear();
+        state.lastIdCache.clear();
+        set({
+            pageCache: new Map(),
+            lastIdCache: new Map(),
+        });
+    },
+    clearAll: () => {
+        const state = get();
+        state.pageCache.clear();
+        state.lastIdCache.clear();
+        set({
+            snapshots: [],
+            loading: false,
+            initialLoading: true,
+            error: null,
+            currentPage: 0,
+            totalCount: 0,
+            hasMore: false,
+            pageCache: new Map(),
+            lastIdCache: new Map(),
+            devboxIdFilter: undefined,
+            selectedIndex: 0,
+        });
+    },
+    getSelectedSnapshot: () => {
+        const state = get();
+        return state.snapshots[state.selectedIndex];
+    },
+}));