@runloop/rl-cli 1.7.1 → 1.9.0

package/dist/screens/SecretListScreen.js

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

package/dist/screens/SettingsMenuScreen.js

@@ -0,0 +1,26 @@
+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 "gateway-configs":
+                navigate("gateway-config-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/screens/SnapshotDetailScreen.js

@@ -79,6 +79,12 @@ export function SnapshotDetailScreen({ snapshotId, }) {
         basicFields.push({
             label: "Source Devbox",
             value: _jsx(Text, { color: colors.idColor, children: snapshot.devbox_id }),
+            action: {
+                type: "navigate",
+                screen: "devbox-detail",
+                params: { devboxId: snapshot.devbox_id },
+                hint: "View Devbox",
+            },
         });
     }
     if (snapshot.disk_size_bytes) {

package/dist/services/agentService.js

@@ -0,0 +1,42 @@
+/**
+ * Agent Service - Handles API calls for agents
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List agents with pagination
+ * Can filter to only return public agents for benchmark jobs
+ */
+export async function listAgents(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit || 50,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    // Use API filter for public agents
+    if (options.publicOnly) {
+        queryParams.is_public = true;
+    }
+    const page = await client.agents.list(queryParams);
+    const agents = [];
+    // Collect agents from the cursor page
+    for await (const agent of page) {
+        agents.push(agent);
+        if (options.limit && agents.length >= options.limit) {
+            break;
+        }
+    }
+    return {
+        agents,
+        totalCount: agents.length,
+        hasMore: false, // Cursor pagination doesn't give us this directly
+    };
+}
+/**
+ * Get agent by ID
+ */
+export async function getAgent(id) {
+    const client = getClient();
+    return client.agents.retrieve(id);
+}

package/dist/services/benchmarkJobService.js

@@ -0,0 +1,122 @@
+/**
+ * Benchmark Job Service - Handles API calls for benchmark jobs
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List benchmark jobs with pagination
+ */
+export async function listBenchmarkJobs(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    if (options.name) {
+        queryParams.name = options.name;
+    }
+    const page = await client.benchmarkJobs.list(queryParams);
+    const jobs = page.jobs || [];
+    return {
+        jobs,
+        totalCount: page.total_count || jobs.length,
+        hasMore: page.has_more || false,
+    };
+}
+/**
+ * Get benchmark job by ID
+ */
+export async function getBenchmarkJob(id) {
+    const client = getClient();
+    return client.benchmarkJobs.retrieve(id);
+}
+/**
+ * Create a benchmark job with either benchmark definition spec or scenario definition spec
+ */
+export async function createBenchmarkJob(options) {
+    const client = getClient();
+    // Validate that either benchmarkId or scenarioIds is provided
+    if (!options.benchmarkId && !options.scenarioIds) {
+        throw new Error("Either benchmarkId or scenarioIds must be provided");
+    }
+    if (options.benchmarkId && options.scenarioIds) {
+        throw new Error("Cannot specify both benchmarkId and scenarioIds");
+    }
+    // Build agent configs in API format
+    // Use the same agent config type for both spec types
+    const agentConfigs = options.agentConfigs.map((agent) => {
+        const config = {
+            name: agent.name,
+            type: "job_agent",
+        };
+        if (agent.agentId) {
+            config.agent_id = agent.agentId;
+        }
+        if (agent.modelName) {
+            config.model_name = agent.modelName;
+        }
+        if (agent.timeoutSeconds) {
+            config.timeout_seconds = agent.timeoutSeconds;
+        }
+        if (agent.kwargs && Object.keys(agent.kwargs).length > 0) {
+            config.kwargs = agent.kwargs;
+        }
+        if ((agent.environmentVariables &&
+            Object.keys(agent.environmentVariables).length > 0) ||
+            (agent.secrets && Object.keys(agent.secrets).length > 0)) {
+            config.agent_environment = {};
+            if (agent.environmentVariables &&
+                Object.keys(agent.environmentVariables).length > 0) {
+                config.agent_environment.environment_variables =
+                    agent.environmentVariables;
+            }
+            if (agent.secrets && Object.keys(agent.secrets).length > 0) {
+                config.agent_environment.secrets = agent.secrets;
+            }
+        }
+        return config;
+    });
+    // Build orchestrator config if provided
+    let orchestratorConfig;
+    if (options.orchestratorConfig) {
+        orchestratorConfig = {};
+        if (options.orchestratorConfig.nAttempts !== undefined) {
+            orchestratorConfig.n_attempts = options.orchestratorConfig.nAttempts;
+        }
+        if (options.orchestratorConfig.nConcurrentTrials !== undefined) {
+            orchestratorConfig.n_concurrent_trials =
+                options.orchestratorConfig.nConcurrentTrials;
+        }
+        if (options.orchestratorConfig.quiet !== undefined) {
+            orchestratorConfig.quiet = options.orchestratorConfig.quiet;
+        }
+        if (options.orchestratorConfig.timeoutMultiplier !== undefined) {
+            orchestratorConfig.timeout_multiplier =
+                options.orchestratorConfig.timeoutMultiplier;
+        }
+    }
+    // Build the appropriate spec based on what's provided
+    let spec;
+    if (options.benchmarkId) {
+        spec = {
+            type: "benchmark",
+            benchmark_id: options.benchmarkId,
+            agent_configs: agentConfigs,
+            orchestrator_config: orchestratorConfig,
+        };
+    }
+    else if (options.scenarioIds) {
+        spec = {
+            type: "scenarios",
+            scenario_ids: options.scenarioIds,
+            agent_configs: agentConfigs,
+            orchestrator_config: orchestratorConfig,
+        };
+    }
+    const createParams = {
+        name: options.name,
+        spec,
+    };
+    return client.benchmarkJobs.create(createParams);
+}

package/dist/services/benchmarkService.js

@@ -0,0 +1,120 @@
+/**
+ * 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);
+}
+/**
+ * List benchmark definitions with pagination
+ */
+export async function listBenchmarks(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    if (options.search) {
+        queryParams.search = options.search;
+    }
+    const page = await client.benchmarks.list(queryParams);
+    const benchmarks = page.benchmarks || [];
+    return {
+        benchmarks,
+        totalCount: page.total_count || benchmarks.length,
+        hasMore: page.has_more || false,
+    };
+}
+/**
+ * Get benchmark definition by ID
+ */
+export async function getBenchmark(id) {
+    const client = getClient();
+    return client.benchmarks.retrieve(id);
+}
+/**
+ * Create/start a benchmark run with selected benchmarks
+ */
+export async function createBenchmarkRun(benchmarkIds, options) {
+    const client = getClient();
+    const createParams = {
+        benchmark_ids: benchmarkIds,
+    };
+    if (options?.name) {
+        createParams.name = options.name;
+    }
+    if (options?.metadata) {
+        createParams.metadata = options.metadata;
+    }
+    // Use type assertion since the API client types may not be fully defined
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return client.benchmarkRuns.create(createParams);
+}

package/dist/services/gatewayConfigService.js

@@ -0,0 +1,114 @@
+/**
+ * Gateway Config Service - Handles all gateway config API calls
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List gateway configs with pagination
+ */
+export async function listGatewayConfigs(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.gatewayConfigs.list(queryParams);
+    const page = (await pagePromise);
+    const gatewayConfigs = [];
+    if (page.gateway_configs && Array.isArray(page.gateway_configs)) {
+        page.gateway_configs.forEach((g) => {
+            // CRITICAL: Truncate all strings to prevent Yoga crashes
+            const MAX_ID_LENGTH = 100;
+            const MAX_NAME_LENGTH = 200;
+            const MAX_DESC_LENGTH = 500;
+            const MAX_ENDPOINT_LENGTH = 500;
+            gatewayConfigs.push({
+                id: String(g.id || "").substring(0, MAX_ID_LENGTH),
+                name: String(g.name || "").substring(0, MAX_NAME_LENGTH),
+                description: g.description
+                    ? String(g.description).substring(0, MAX_DESC_LENGTH)
+                    : undefined,
+                endpoint: String(g.endpoint || "").substring(0, MAX_ENDPOINT_LENGTH),
+                create_time_ms: g.create_time_ms,
+                auth_mechanism: {
+                    type: g.auth_mechanism.type,
+                    key: g.auth_mechanism.key ?? undefined,
+                },
+                account_id: g.account_id ?? undefined,
+            });
+        });
+    }
+    const result = {
+        gatewayConfigs,
+        totalCount: page.total_count || gatewayConfigs.length,
+        hasMore: page.has_more || false,
+    };
+    return result;
+}
+/**
+ * Get a single gateway config by ID
+ */
+export async function getGatewayConfig(id) {
+    const client = getClient();
+    const config = await client.gatewayConfigs.retrieve(id);
+    return {
+        id: config.id,
+        name: config.name,
+        description: config.description ?? undefined,
+        endpoint: config.endpoint,
+        create_time_ms: config.create_time_ms,
+        auth_mechanism: {
+            type: config.auth_mechanism.type,
+            key: config.auth_mechanism.key ?? undefined,
+        },
+        account_id: config.account_id ?? undefined,
+    };
+}
+/**
+ * Delete a gateway config
+ */
+export async function deleteGatewayConfig(id) {
+    const client = getClient();
+    await client.gatewayConfigs.delete(id);
+}
+export async function createGatewayConfig(params) {
+    const client = getClient();
+    const config = await client.gatewayConfigs.create({
+        name: params.name,
+        endpoint: params.endpoint,
+        auth_mechanism: params.auth_mechanism,
+        description: params.description,
+    });
+    return {
+        id: config.id,
+        name: config.name,
+        description: config.description ?? undefined,
+        endpoint: config.endpoint,
+        create_time_ms: config.create_time_ms,
+        auth_mechanism: {
+            type: config.auth_mechanism.type,
+            key: config.auth_mechanism.key ?? undefined,
+        },
+        account_id: config.account_id ?? undefined,
+    };
+}
+export async function updateGatewayConfig(id, params) {
+    const client = getClient();
+    const config = await client.gatewayConfigs.update(id, params);
+    return {
+        id: config.id,
+        name: config.name,
+        description: config.description ?? undefined,
+        endpoint: config.endpoint,
+        create_time_ms: config.create_time_ms,
+        auth_mechanism: {
+            type: config.auth_mechanism.type,
+            key: config.auth_mechanism.key ?? undefined,
+        },
+        account_id: config.account_id ?? undefined,
+    };
+}

package/dist/services/scenarioService.js

@@ -0,0 +1,34 @@
+/**
+ * Scenario Service - Handles all scenario-related API calls
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List scenarios with pagination
+ */
+export async function listScenarios(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    // Use name filter instead of search
+    if (options.search) {
+        queryParams.name = options.search;
+    }
+    const page = await client.scenarios.list(queryParams);
+    const scenarios = page.scenarios || [];
+    return {
+        scenarios,
+        totalCount: page.total_count || scenarios.length,
+        hasMore: page.has_more || false,
+    };
+}
+/**
+ * Get scenario by ID
+ */
+export async function getScenario(id) {
+    const client = getClient();
+    return client.scenarios.retrieve(id);
+}

package/dist/store/benchmarkJobStore.js

@@ -0,0 +1,66 @@
+/**
+ * Benchmark Job Store - Manages benchmark job state
+ */
+import { create } from "zustand";
+const MAX_CACHE_SIZE = 10;
+export const useBenchmarkJobStore = create((set, get) => ({
+    // Initial state
+    benchmarkJobs: [],
+    benchmarkJobsLoading: false,
+    benchmarkJobsError: null,
+    benchmarkJobsTotalCount: 0,
+    benchmarkJobsHasMore: false,
+    benchmarkJobsCurrentPage: 0,
+    // Selection
+    selectedBenchmarkJobIndex: 0,
+    // Cache
+    benchmarkJobPageCache: new Map(),
+    // Actions
+    setBenchmarkJobs: (jobs) => set({ benchmarkJobs: jobs }),
+    setBenchmarkJobsLoading: (loading) => set({ benchmarkJobsLoading: loading }),
+    setBenchmarkJobsError: (error) => set({ benchmarkJobsError: error }),
+    setBenchmarkJobsTotalCount: (count) => set({ benchmarkJobsTotalCount: count }),
+    setBenchmarkJobsHasMore: (hasMore) => set({ benchmarkJobsHasMore: hasMore }),
+    setBenchmarkJobsCurrentPage: (page) => set({ benchmarkJobsCurrentPage: page }),
+    setSelectedBenchmarkJobIndex: (index) => set({ selectedBenchmarkJobIndex: index }),
+    // Cache management
+    cacheBenchmarkJobPage: (page, data) => {
+        const state = get();
+        const cache = state.benchmarkJobPageCache;
+        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({});
+    },
+    getCachedBenchmarkJobPage: (page) => {
+        return get().benchmarkJobPageCache.get(page);
+    },
+    clearCache: () => {
+        const state = get();
+        state.benchmarkJobPageCache.clear();
+        set({ benchmarkJobPageCache: new Map() });
+    },
+    clearAll: () => {
+        const state = get();
+        state.benchmarkJobPageCache.clear();
+        set({
+            benchmarkJobs: [],
+            benchmarkJobsLoading: false,
+            benchmarkJobsError: null,
+            benchmarkJobsTotalCount: 0,
+            benchmarkJobsHasMore: false,
+            benchmarkJobsCurrentPage: 0,
+            selectedBenchmarkJobIndex: 0,
+            benchmarkJobPageCache: new Map(),
+        });
+    },
+    getSelectedBenchmarkJob: () => {
+        const state = get();
+        return state.benchmarkJobs[state.selectedBenchmarkJobIndex];
+    },
+}));