@runloop/rl-cli 1.8.0 → 1.9.0

package/dist/screens/BenchmarkRunListScreen.js

@@ -82,6 +82,12 @@ export function BenchmarkRunListScreen() {
             color: colors.info,
             icon: figures.arrowRight,
         },
+        {
+            key: "create_job",
+            label: "Create Job",
+            color: colors.success,
+            icon: figures.play,
+        },
     ], []);
     // Build columns
     const columns = React.useMemo(() => [
@@ -150,6 +156,9 @@ export function BenchmarkRunListScreen() {
                         benchmarkRunId: selectedRun.id,
                     });
                 }
+                else if (operationKey === "create_job") {
+                    navigate("benchmark-job-create");
+                }
             }
             else if (input === "v" && selectedRun) {
                 setShowPopup(false);
@@ -163,6 +172,10 @@ export function BenchmarkRunListScreen() {
                     benchmarkRunId: selectedRun.id,
                 });
             }
+            else if (input === "j") {
+                setShowPopup(false);
+                navigate("benchmark-job-create");
+            }
             else if (key.escape || input === "q") {
                 setShowPopup(false);
                 setSelectedOperation(0);
@@ -200,6 +213,10 @@ export function BenchmarkRunListScreen() {
             setShowPopup(true);
             setSelectedOperation(0);
         }
+        else if (input === "j") {
+            // Quick shortcut to create a new job
+            navigate("benchmark-job-create");
+        }
         else if (input === "/") {
             search.enterSearchMode();
         }
@@ -240,7 +257,9 @@ export function BenchmarkRunListScreen() {
                             ? "v"
                             : op.key === "view_scenarios"
                                 ? "s"
-                                : "",
+                                : op.key === "create_job"
+                                    ? "j"
+                                    : "",
                     })), selectedOperation: selectedOperation, onClose: () => setShowPopup(false) }) })), _jsx(NavigationTips, { showArrows: true, tips: [
                     {
                         icon: `${figures.arrowLeft}${figures.arrowRight}`,
@@ -248,6 +267,7 @@ export function BenchmarkRunListScreen() {
                         condition: hasMore || hasPrev,
                     },
                     { key: "Enter", label: "Details" },
+                    { key: "j", label: "New Job" },
                     { key: "a", label: "Actions" },
                     { key: "/", label: "Search" },
                     { key: "Esc", label: "Back" },

package/dist/screens/BlueprintDetailScreen.js

@@ -351,5 +351,9 @@ export function BlueprintDetailScreen({ blueprintId, }) {
         });
         return lines;
     };
-    return (_jsx(ResourceDetailPage, { resource: blueprint, resourceType: "Blueprints", getDisplayName: (bp) => bp.name || bp.id, getId: (bp) => bp.id, getStatus: (bp) => bp.status, detailSections: detailSections, operations: operations, onOperation: handleOperation, onBack: goBack, buildDetailLines: buildDetailLines, pollResource: blueprint.status === "building" ? pollBlueprint : undefined }));
+    return (_jsx(ResourceDetailPage, { resource: blueprint, resourceType: "Blueprints", getDisplayName: (bp) => bp.name || bp.id, getId: (bp) => bp.id, getStatus: (bp) => bp.status, detailSections: detailSections, operations: operations, onOperation: handleOperation, onBack: goBack, buildDetailLines: buildDetailLines, pollResource: blueprint.status === "queued" ||
+            blueprint.status === "provisioning" ||
+            blueprint.status === "building"
+            ? pollBlueprint
+            : undefined }));
 }

package/dist/screens/DevboxCreateScreen.js

@@ -2,10 +2,10 @@ 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, navigate } = useNavigation();
+    const { goBack, navigate, params } = useNavigation();
     const handleCreate = (devbox) => {
         // After creation, navigate to the devbox detail page
         navigate("devbox-detail", { devboxId: devbox.id });
     };
-    return _jsx(DevboxCreatePage, { onBack: goBack, onCreate: handleCreate });
+    return (_jsx(DevboxCreatePage, { onBack: goBack, onCreate: handleCreate, initialBlueprintId: params.blueprintId, initialSnapshotId: params.snapshotId }));
 }

package/dist/screens/GatewayConfigDetailScreen.js

@@ -0,0 +1,236 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * GatewayConfigDetailScreen - Detail page for gateway configs
+ * Uses the generic ResourceDetailPage component
+ */
+import React from "react";
+import { Text } from "ink";
+import figures from "figures";
+import { useNavigation } from "../store/navigationStore.js";
+import { useGatewayConfigStore, } from "../store/gatewayConfigStore.js";
+import { ResourceDetailPage, formatTimestamp, } from "../components/ResourceDetailPage.js";
+import { getGatewayConfig, deleteGatewayConfig, } from "../services/gatewayConfigService.js";
+import { SpinnerComponent } from "../components/Spinner.js";
+import { ErrorMessage } from "../components/ErrorMessage.js";
+import { Breadcrumb } from "../components/Breadcrumb.js";
+import { ConfirmationPrompt } from "../components/ConfirmationPrompt.js";
+import { GatewayConfigCreatePage } from "../components/GatewayConfigCreatePage.js";
+import { colors } from "../utils/theme.js";
+/**
+ * Get a display label for the auth mechanism type
+ */
+function getAuthTypeLabel(authMechanism) {
+    if (authMechanism.type === "bearer") {
+        return "Bearer Token";
+    }
+    if (authMechanism.type === "header") {
+        return authMechanism.key ? `Header: ${authMechanism.key}` : "Header";
+    }
+    return authMechanism.type;
+}
+export function GatewayConfigDetailScreen({ gatewayConfigId, }) {
+    const { goBack } = useNavigation();
+    const gatewayConfigs = useGatewayConfigStore((state) => state.gatewayConfigs);
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const [fetchedConfig, setFetchedConfig] = React.useState(null);
+    const [deleting, setDeleting] = React.useState(false);
+    const [showDeleteConfirm, setShowDeleteConfirm] = React.useState(false);
+    const [showEditForm, setShowEditForm] = React.useState(false);
+    // Find config in store first
+    const configFromStore = gatewayConfigs.find((c) => c.id === gatewayConfigId);
+    // Fetch config from API if not in store or missing full details
+    React.useEffect(() => {
+        if (gatewayConfigId && !loading && !fetchedConfig) {
+            // Always fetch full details since store may only have basic info
+            setLoading(true);
+            setError(null);
+            getGatewayConfig(gatewayConfigId)
+                .then((config) => {
+                setFetchedConfig(config);
+                setLoading(false);
+            })
+                .catch((err) => {
+                setError(err);
+                setLoading(false);
+            });
+        }
+    }, [gatewayConfigId, loading, fetchedConfig]);
+    // Use fetched config for full details, fall back to store for basic display
+    const config = fetchedConfig || configFromStore;
+    // Show loading state while fetching or before fetch starts
+    if (!config && gatewayConfigId && !error) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [
+                        { label: "Gateway Configs" },
+                        { label: "Loading...", active: true },
+                    ] }), _jsx(SpinnerComponent, { message: "Loading gateway config details..." })] }));
+    }
+    // Show error state if fetch failed
+    if (error && !config) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [
+                        { label: "Gateway Configs" },
+                        { label: "Error", active: true },
+                    ] }), _jsx(ErrorMessage, { message: "Failed to load gateway config details", error: error })] }));
+    }
+    // Show error if no config found
+    if (!config) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [
+                        { label: "Gateway Configs" },
+                        { label: "Not Found", active: true },
+                    ] }), _jsx(ErrorMessage, { message: `Gateway config ${gatewayConfigId || "unknown"} not found`, error: new Error("Gateway config not found") })] }));
+    }
+    // Build detail sections
+    const detailSections = [];
+    // Basic details section
+    const basicFields = [];
+    if (config.description) {
+        basicFields.push({
+            label: "Description",
+            value: config.description,
+        });
+    }
+    basicFields.push({
+        label: "Endpoint",
+        value: config.endpoint,
+    });
+    if (config.create_time_ms) {
+        basicFields.push({
+            label: "Created",
+            value: formatTimestamp(config.create_time_ms),
+        });
+    }
+    if (config.account_id) {
+        basicFields.push({
+            label: "Account ID",
+            value: config.account_id,
+        });
+    }
+    if (basicFields.length > 0) {
+        detailSections.push({
+            title: "Details",
+            icon: figures.squareSmallFilled,
+            color: colors.warning,
+            fields: basicFields,
+        });
+    }
+    // Auth mechanism section
+    const authFields = [];
+    authFields.push({
+        label: "Auth Type",
+        value: (_jsx(Text, { color: colors.info, bold: true, children: getAuthTypeLabel(config.auth_mechanism) })),
+    });
+    if (config.auth_mechanism.type === "header" && config.auth_mechanism.key) {
+        authFields.push({
+            label: "Header Key",
+            value: config.auth_mechanism.key,
+        });
+    }
+    detailSections.push({
+        title: "Authentication",
+        icon: figures.arrowRight,
+        color: colors.info,
+        fields: authFields,
+    });
+    // Operations available for gateway configs
+    const operations = [
+        {
+            key: "edit",
+            label: "Edit Gateway Config",
+            color: colors.warning,
+            icon: figures.pointer,
+            shortcut: "e",
+        },
+        {
+            key: "delete",
+            label: "Delete Gateway Config",
+            color: colors.error,
+            icon: figures.cross,
+            shortcut: "d",
+        },
+    ];
+    // Handle operation selection
+    const handleOperation = async (operation, _resource) => {
+        switch (operation) {
+            case "edit":
+                setShowEditForm(true);
+                break;
+            case "delete":
+                // Show confirmation dialog
+                setShowDeleteConfirm(true);
+                break;
+        }
+    };
+    // Execute delete after confirmation
+    const executeDelete = async () => {
+        if (!config)
+            return;
+        setShowDeleteConfirm(false);
+        setDeleting(true);
+        try {
+            await deleteGatewayConfig(config.id);
+            goBack();
+        }
+        catch (err) {
+            setError(err);
+            setDeleting(false);
+        }
+    };
+    // Build detailed info lines for full details view
+    const buildDetailLines = (gc) => {
+        const lines = [];
+        // Core Information
+        lines.push(_jsx(Text, { color: colors.warning, bold: true, children: "Gateway Config Details" }, "core-title"));
+        lines.push(_jsxs(Text, { color: colors.idColor, children: [" ", "ID: ", gc.id] }, "core-id"));
+        lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Name: ", gc.name] }, "core-name"));
+        if (gc.description) {
+            lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Description: ", gc.description] }, "core-desc"));
+        }
+        lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Endpoint: ", gc.endpoint] }, "core-endpoint"));
+        if (gc.create_time_ms) {
+            lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Created: ", new Date(gc.create_time_ms).toLocaleString()] }, "core-created"));
+        }
+        if (gc.account_id) {
+            lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Account ID: ", gc.account_id] }, "core-account"));
+        }
+        lines.push(_jsx(Text, { children: " " }, "core-space"));
+        // Auth Mechanism
+        lines.push(_jsx(Text, { color: colors.warning, bold: true, children: "Authentication" }, "auth-title"));
+        lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Type: ", getAuthTypeLabel(gc.auth_mechanism)] }, "auth-type"));
+        if (gc.auth_mechanism.type === "header" && gc.auth_mechanism.key) {
+            lines.push(_jsxs(Text, { dimColor: true, children: [" ", "Header Key: ", gc.auth_mechanism.key] }, "auth-key"));
+        }
+        lines.push(_jsx(Text, { children: " " }, "auth-space"));
+        // Raw JSON
+        lines.push(_jsx(Text, { color: colors.warning, bold: true, children: "Raw JSON" }, "json-title"));
+        const jsonLines = JSON.stringify(gc, null, 2).split("\n");
+        jsonLines.forEach((line, idx) => {
+            lines.push(_jsxs(Text, { dimColor: true, children: [" ", line] }, `json-${idx}`));
+        });
+        return lines;
+    };
+    // Show edit form
+    if (showEditForm && config) {
+        return (_jsx(GatewayConfigCreatePage, { onBack: () => setShowEditForm(false), onCreate: (updatedConfig) => {
+                // Update the fetched config with the new data
+                setFetchedConfig(updatedConfig);
+                setShowEditForm(false);
+            }, initialConfig: config }));
+    }
+    // Show delete confirmation
+    if (showDeleteConfirm && config) {
+        return (_jsx(ConfirmationPrompt, { title: "Delete Gateway Config", message: `Are you sure you want to delete "${config.name || config.id}"?`, details: "This action cannot be undone. Any devboxes using this gateway config will no longer have access to it.", breadcrumbItems: [
+                { label: "Gateway Configs" },
+                { label: config.name || config.id },
+                { label: "Delete", active: true },
+            ], onConfirm: executeDelete, onCancel: () => setShowDeleteConfirm(false) }));
+    }
+    // Show deleting state
+    if (deleting) {
+        return (_jsxs(_Fragment, { children: [_jsx(Breadcrumb, { items: [
+                        { label: "Gateway Configs" },
+                        { label: config.name || config.id },
+                        { label: "Deleting...", active: true },
+                    ] }), _jsx(SpinnerComponent, { message: "Deleting gateway config..." })] }));
+    }
+    return (_jsx(ResourceDetailPage, { resource: config, resourceType: "Gateway Configs", getDisplayName: (gc) => gc.name || gc.id, getId: (gc) => gc.id, getStatus: () => "active", detailSections: detailSections, operations: operations, onOperation: handleOperation, onBack: goBack, buildDetailLines: buildDetailLines }));
+}

package/dist/screens/GatewayConfigListScreen.js

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

package/dist/screens/ScenarioRunDetailScreen.js

@@ -100,6 +100,12 @@ export function ScenarioRunDetailScreen({ scenarioRunId, benchmarkRunId, }) {
         basicFields.push({
             label: "Benchmark Run ID",
             value: _jsx(Text, { color: colors.idColor, children: run.benchmark_run_id }),
+            action: {
+                type: "navigate",
+                screen: "benchmark-run-detail",
+                params: { benchmarkRunId: run.benchmark_run_id },
+                hint: "View Run",
+            },
         });
     }
     if (basicFields.length > 0) {

package/dist/screens/SettingsMenuScreen.js

@@ -8,6 +8,9 @@ export function SettingsMenuScreen() {
             case "network-policies":
                 navigate("network-policy-list");
                 break;
+            case "gateway-configs":
+                navigate("gateway-config-list");
+                break;
             case "secrets":
                 navigate("secret-list");
                 break;

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

@@ -71,3 +71,50 @@ 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);
+}