@runloop/rl-cli 1.7.1 → 1.8.0

package/dist/screens/SettingsMenuScreen.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useNavigation } from "../store/navigationStore.js";
+import { SettingsMenu } from "../components/SettingsMenu.js";
+export function SettingsMenuScreen() {
+    const { navigate, goBack } = useNavigation();
+    const handleSelect = (key) => {
+        switch (key) {
+            case "network-policies":
+                navigate("network-policy-list");
+                break;
+            case "secrets":
+                navigate("secret-list");
+                break;
+            default:
+                // Fallback for any other screen names
+                navigate(key);
+        }
+    };
+    const handleBack = () => {
+        goBack();
+    };
+    return _jsx(SettingsMenu, { onSelect: handleSelect, onBack: handleBack });
+}

package/dist/services/benchmarkService.js

@@ -0,0 +1,73 @@
+/**
+ * Benchmark Service - Handles all benchmark-related API calls
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List benchmark runs with pagination
+ */
+export async function listBenchmarkRuns(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    const page = await client.benchmarkRuns.list(queryParams);
+    const benchmarkRuns = page.runs || [];
+    return {
+        benchmarkRuns,
+        totalCount: page.total_count || benchmarkRuns.length,
+        hasMore: page.has_more || false,
+    };
+}
+/**
+ * Get benchmark run by ID
+ */
+export async function getBenchmarkRun(id) {
+    const client = getClient();
+    return client.benchmarkRuns.retrieve(id);
+}
+/**
+ * List scenario runs with pagination
+ */
+export async function listScenarioRuns(options) {
+    const client = getClient();
+    // If we have a benchmark run ID, use the dedicated endpoint
+    if (options.benchmarkRunId) {
+        const queryParams = {
+            limit: options.limit,
+        };
+        if (options.startingAfter) {
+            queryParams.starting_after = options.startingAfter;
+        }
+        const page = await client.benchmarkRuns.listScenarioRuns(options.benchmarkRunId, queryParams);
+        const scenarioRuns = page.runs || [];
+        return {
+            scenarioRuns,
+            totalCount: page.total_count || scenarioRuns.length,
+            hasMore: page.has_more || false,
+        };
+    }
+    // Otherwise, list all scenario runs
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    const page = await client.scenarios.runs.list(queryParams);
+    const scenarioRuns = page.runs || [];
+    return {
+        scenarioRuns,
+        totalCount: page.total_count || scenarioRuns.length,
+        hasMore: page.has_more || false,
+    };
+}
+/**
+ * Get scenario run by ID
+ */
+export async function getScenarioRun(id) {
+    const client = getClient();
+    return client.scenarios.runs.retrieve(id);
+}

package/dist/store/benchmarkStore.js

@@ -0,0 +1,120 @@
+/**
+ * Benchmark Store - Manages benchmark run and scenario run state
+ */
+import { create } from "zustand";
+const MAX_CACHE_SIZE = 10;
+export const useBenchmarkStore = create((set, get) => ({
+    // Initial benchmark run state
+    benchmarkRuns: [],
+    benchmarkRunsLoading: false,
+    benchmarkRunsError: null,
+    benchmarkRunsTotalCount: 0,
+    benchmarkRunsHasMore: false,
+    benchmarkRunsCurrentPage: 0,
+    // Initial scenario run state
+    scenarioRuns: [],
+    scenarioRunsLoading: false,
+    scenarioRunsError: null,
+    scenarioRunsTotalCount: 0,
+    scenarioRunsHasMore: false,
+    scenarioRunsCurrentPage: 0,
+    // Filters
+    benchmarkRunIdFilter: undefined,
+    // Selection
+    selectedBenchmarkRunIndex: 0,
+    selectedScenarioRunIndex: 0,
+    // Caches
+    benchmarkRunPageCache: new Map(),
+    scenarioRunPageCache: new Map(),
+    // Benchmark Run Actions
+    setBenchmarkRuns: (runs) => set({ benchmarkRuns: runs }),
+    setBenchmarkRunsLoading: (loading) => set({ benchmarkRunsLoading: loading }),
+    setBenchmarkRunsError: (error) => set({ benchmarkRunsError: error }),
+    setBenchmarkRunsTotalCount: (count) => set({ benchmarkRunsTotalCount: count }),
+    setBenchmarkRunsHasMore: (hasMore) => set({ benchmarkRunsHasMore: hasMore }),
+    setBenchmarkRunsCurrentPage: (page) => set({ benchmarkRunsCurrentPage: page }),
+    setSelectedBenchmarkRunIndex: (index) => set({ selectedBenchmarkRunIndex: index }),
+    // Scenario Run Actions
+    setScenarioRuns: (runs) => set({ scenarioRuns: runs }),
+    setScenarioRunsLoading: (loading) => set({ scenarioRunsLoading: loading }),
+    setScenarioRunsError: (error) => set({ scenarioRunsError: error }),
+    setScenarioRunsTotalCount: (count) => set({ scenarioRunsTotalCount: count }),
+    setScenarioRunsHasMore: (hasMore) => set({ scenarioRunsHasMore: hasMore }),
+    setScenarioRunsCurrentPage: (page) => set({ scenarioRunsCurrentPage: page }),
+    setSelectedScenarioRunIndex: (index) => set({ selectedScenarioRunIndex: index }),
+    setBenchmarkRunIdFilter: (id) => set({ benchmarkRunIdFilter: id }),
+    // Cache management
+    cacheBenchmarkRunPage: (page, data) => {
+        const state = get();
+        const cache = state.benchmarkRunPageCache;
+        if (cache.size >= MAX_CACHE_SIZE) {
+            const oldestKey = cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                cache.delete(oldestKey);
+            }
+        }
+        const plainData = data.map((d) => JSON.parse(JSON.stringify(d)));
+        cache.set(page, plainData);
+        set({});
+    },
+    getCachedBenchmarkRunPage: (page) => {
+        return get().benchmarkRunPageCache.get(page);
+    },
+    cacheScenarioRunPage: (page, data) => {
+        const state = get();
+        const cache = state.scenarioRunPageCache;
+        if (cache.size >= MAX_CACHE_SIZE) {
+            const oldestKey = cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                cache.delete(oldestKey);
+            }
+        }
+        const plainData = data.map((d) => JSON.parse(JSON.stringify(d)));
+        cache.set(page, plainData);
+        set({});
+    },
+    getCachedScenarioRunPage: (page) => {
+        return get().scenarioRunPageCache.get(page);
+    },
+    clearCache: () => {
+        const state = get();
+        state.benchmarkRunPageCache.clear();
+        state.scenarioRunPageCache.clear();
+        set({
+            benchmarkRunPageCache: new Map(),
+            scenarioRunPageCache: new Map(),
+        });
+    },
+    clearAll: () => {
+        const state = get();
+        state.benchmarkRunPageCache.clear();
+        state.scenarioRunPageCache.clear();
+        set({
+            benchmarkRuns: [],
+            benchmarkRunsLoading: false,
+            benchmarkRunsError: null,
+            benchmarkRunsTotalCount: 0,
+            benchmarkRunsHasMore: false,
+            benchmarkRunsCurrentPage: 0,
+            scenarioRuns: [],
+            scenarioRunsLoading: false,
+            scenarioRunsError: null,
+            scenarioRunsTotalCount: 0,
+            scenarioRunsHasMore: false,
+            scenarioRunsCurrentPage: 0,
+            benchmarkRunIdFilter: undefined,
+            selectedBenchmarkRunIndex: 0,
+            selectedScenarioRunIndex: 0,
+            benchmarkRunPageCache: new Map(),
+            scenarioRunPageCache: new Map(),
+        });
+    },
+    getSelectedBenchmarkRun: () => {
+        const state = get();
+        return state.benchmarkRuns[state.selectedBenchmarkRunIndex];
+    },
+    getSelectedScenarioRun: () => {
+        const state = get();
+        return state.scenarioRuns[state.selectedScenarioRunIndex];
+    },
+}));

package/dist/store/betaFeatureStore.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Beta Feature Store - React context for managing beta feature flags
+ *
+ * Enable beta features by setting the environment variable:
+ *   export RL_CLI_BETA=1
+ *   export RL_CLI_BETA=true
+ */
+import React from "react";
+import { isBetaEnabled } from "../utils/config.js";
+const BetaFeatureContext = React.createContext(null);
+export function BetaFeatureProvider({ children }) {
+    // Read beta status once on mount (env vars don't change during runtime)
+    const betaEnabled = React.useMemo(() => isBetaEnabled(), []);
+    const isFeatureEnabled = React.useCallback((feature) => {
+        // Currently all beta features are gated by the same flag
+        // This can be extended to support per-feature flags in the future
+        switch (feature) {
+            case "benchmarks":
+                return betaEnabled;
+            default:
+                return false;
+        }
+    }, [betaEnabled]);
+    const value = React.useMemo(() => ({
+        isBetaEnabled: betaEnabled,
+        isFeatureEnabled,
+    }), [betaEnabled, isFeatureEnabled]);
+    return (_jsx(BetaFeatureContext.Provider, { value: value, children: children }));
+}
+/**
+ * Hook to access beta feature flags
+ */
+export function useBetaFeatures() {
+    const context = React.useContext(BetaFeatureContext);
+    if (!context) {
+        throw new Error("useBetaFeatures must be used within BetaFeatureProvider");
+    }
+    return context;
+}
+/**
+ * Hook to check if a specific beta feature is enabled
+ */
+export function useBetaFeature(feature) {
+    const { isFeatureEnabled } = useBetaFeatures();
+    return isFeatureEnabled(feature);
+}

package/dist/store/index.js

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

package/dist/utils/config.js

@@ -72,6 +72,14 @@ export function setDetectedTheme(theme) {
 export function clearDetectedTheme() {
     config.delete("detectedTheme");
 }
+/**
+ * Check if beta features are enabled via the RL_CLI_BETA environment variable.
+ * Set RL_CLI_BETA=1 or RL_CLI_BETA=true to enable beta features.
+ */
+export function isBetaEnabled() {
+    const betaValue = process.env.RL_CLI_BETA?.toLowerCase();
+    return betaValue === "1" || betaValue === "true";
+}
 /**
  * Returns the detailed error message for when the API key is not configured.
  * This message provides instructions on how to set up the API key.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runloop/rl-cli",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "Beautiful CLI for the Runloop platform",
   "type": "module",
   "bin": {