@runloop/rl-cli 0.1.2 → 0.3.0

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];
+    },
+}));

package/dist/utils/client.js

@@ -1,4 +1,5 @@
 import Runloop from "@runloop/api-client";
+import { VERSION } from "@runloop/api-client/version.js";
 import { getConfig } from "./config.js";
 /**
  * Get the base URL based on RUNLOOP_ENV environment variable
@@ -24,7 +25,8 @@ export function getClient() {
     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)
+        defaultHeaders: {
+            "User-Agent": `Runloop/JS ${VERSION} - CLI`,
+        },
     });
 }

package/dist/utils/config.js

@@ -1,9 +1,7 @@
 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";
+import { existsSync, statSync, mkdirSync, writeFileSync } from "fs";
 const config = new Conf({
     projectName: "runloop-cli",
 });
@@ -33,25 +31,6 @@ export function sshUrl() {
 export function getCacheDir() {
     return join(homedir(), ".cache", "rl-cli");
 }
-export 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");
@@ -59,104 +38,36 @@ export function shouldCheckForUpdates() {
         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);
+    const daysSinceUpdate = (Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60 * 24);
+    return daysSinceUpdate >= 1;
 }
-export function updateCheckCache(latestVersion) {
+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 });
     }
-    // Store the latest version in the cache file
-    writeFileSync(cacheFile, latestVersion);
+    // Touch the cache file
+    writeFileSync(cacheFile, "");
 }
-export function getCachedLatestVersion() {
-    const cacheDir = getCacheDir();
-    const cacheFile = join(cacheDir, "last_update_check");
-    if (!existsSync(cacheFile)) {
-        return null;
-    }
-    try {
-        return readFileSync(cacheFile, 'utf-8').trim();
-    }
-    catch {
-        return null;
+export function getThemePreference() {
+    // Check environment variable first, then fall back to stored config
+    const envTheme = process.env.RUNLOOP_THEME?.toLowerCase();
+    if (envTheme === "light" || envTheme === "dark" || envTheme === "auto") {
+        return envTheme;
     }
+    return config.get("theme") || "auto";
 }
-export async function checkForUpdates(force = false) {
-    const currentVersion = getCurrentVersion();
-    // Always show cached result if available and not forcing
-    if (!force && hasCachedUpdateInfo() && !shouldCheckForUpdates()) {
-        const cachedLatestVersion = getCachedLatestVersion();
-        if (cachedLatestVersion && cachedLatestVersion !== currentVersion) {
-            // Check if current version is older than cached latest
-            const isUpdateAvailable = compareVersions(cachedLatestVersion, currentVersion) > 0;
-            if (isUpdateAvailable) {
-                console.error(`\n🔄 Update available: ${currentVersion} → ${cachedLatestVersion}\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 with the latest version
-        updateCheckCache(latestVersion);
-    }
-    catch (error) {
-        if (force) {
-            console.error(`❌ Error checking for updates: ${error}\n`);
-        }
-        // Silently fail - don't interrupt the user's workflow
-    }
+export function setThemePreference(theme) {
+    config.set("theme", theme);
 }
-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;
+export function getDetectedTheme() {
+    return config.get("detectedTheme") || null;
+}
+export function setDetectedTheme(theme) {
+    config.set("detectedTheme", theme);
+}
+export function clearDetectedTheme() {
+    config.delete("detectedTheme");
 }

package/dist/utils/interactiveCommand.js

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