@runloop/rl-cli 1.8.0 → 1.10.0

package/dist/services/gatewayConfigService.js

@@ -0,0 +1,153 @@
+/**
+ * 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,
+    };
+}
+/**
+ * Get a single gateway config by ID or name
+ */
+export async function getGatewayConfigByIdOrName(idOrName) {
+    const client = getClient();
+    // Try to retrieve directly by ID first
+    try {
+        const config = await client.gatewayConfigs.retrieve(idOrName);
+        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,
+        };
+    }
+    catch {
+        // Not found by ID, try by name
+    }
+    // Search by name
+    const queryParams = {
+        limit: 100,
+        name: idOrName,
+    };
+    const pagePromise = client.gatewayConfigs.list(queryParams);
+    const page = (await pagePromise);
+    const configs = page.gateway_configs || [];
+    if (configs.length === 0) {
+        return null;
+    }
+    // Return the first exact match, or first result if no exact match
+    const match = configs.find((g) => g.name === idOrName) || configs[0];
+    return getGatewayConfig(match.id);
+}
+/**
+ * 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];
+    },
+}));

package/dist/store/benchmarkStore.js

@@ -4,6 +4,15 @@
 import { create } from "zustand";
 const MAX_CACHE_SIZE = 10;
 export const useBenchmarkStore = create((set, get) => ({
+    // Initial benchmark (definition) state
+    benchmarks: [],
+    benchmarksLoading: false,
+    benchmarksError: null,
+    benchmarksTotalCount: 0,
+    benchmarksHasMore: false,
+    benchmarksCurrentPage: 0,
+    selectedBenchmarkIndex: 0,
+    selectedBenchmarkIds: new Set(),
     // Initial benchmark run state
     benchmarkRuns: [],
     benchmarkRunsLoading: false,
@@ -24,8 +33,30 @@ export const useBenchmarkStore = create((set, get) => ({
     selectedBenchmarkRunIndex: 0,
     selectedScenarioRunIndex: 0,
     // Caches
+    benchmarkPageCache: new Map(),
     benchmarkRunPageCache: new Map(),
     scenarioRunPageCache: new Map(),
+    // Benchmark (definition) Actions
+    setBenchmarks: (benchmarks) => set({ benchmarks }),
+    setBenchmarksLoading: (loading) => set({ benchmarksLoading: loading }),
+    setBenchmarksError: (error) => set({ benchmarksError: error }),
+    setBenchmarksTotalCount: (count) => set({ benchmarksTotalCount: count }),
+    setBenchmarksHasMore: (hasMore) => set({ benchmarksHasMore: hasMore }),
+    setBenchmarksCurrentPage: (page) => set({ benchmarksCurrentPage: page }),
+    setSelectedBenchmarkIndex: (index) => set({ selectedBenchmarkIndex: index }),
+    setSelectedBenchmarkIds: (ids) => set({ selectedBenchmarkIds: ids }),
+    toggleBenchmarkSelection: (id) => {
+        const state = get();
+        const next = new Set(state.selectedBenchmarkIds);
+        if (next.has(id)) {
+            next.delete(id);
+        }
+        else {
+            next.add(id);
+        }
+        set({ selectedBenchmarkIds: next });
+    },
+    clearBenchmarkSelection: () => set({ selectedBenchmarkIds: new Set() }),
     // Benchmark Run Actions
     setBenchmarkRuns: (runs) => set({ benchmarkRuns: runs }),
     setBenchmarkRunsLoading: (loading) => set({ benchmarkRunsLoading: loading }),
@@ -44,6 +75,22 @@ export const useBenchmarkStore = create((set, get) => ({
     setSelectedScenarioRunIndex: (index) => set({ selectedScenarioRunIndex: index }),
     setBenchmarkRunIdFilter: (id) => set({ benchmarkRunIdFilter: id }),
     // Cache management
+    cacheBenchmarkPage: (page, data) => {
+        const state = get();
+        const cache = state.benchmarkPageCache;
+        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({});
+    },
+    getCachedBenchmarkPage: (page) => {
+        return get().benchmarkPageCache.get(page);
+    },
     cacheBenchmarkRunPage: (page, data) => {
         const state = get();
         const cache = state.benchmarkRunPageCache;
@@ -78,18 +125,29 @@ export const useBenchmarkStore = create((set, get) => ({
     },
     clearCache: () => {
         const state = get();
+        state.benchmarkPageCache.clear();
         state.benchmarkRunPageCache.clear();
         state.scenarioRunPageCache.clear();
         set({
+            benchmarkPageCache: new Map(),
             benchmarkRunPageCache: new Map(),
             scenarioRunPageCache: new Map(),
         });
     },
     clearAll: () => {
         const state = get();
+        state.benchmarkPageCache.clear();
         state.benchmarkRunPageCache.clear();
         state.scenarioRunPageCache.clear();
         set({
+            benchmarks: [],
+            benchmarksLoading: false,
+            benchmarksError: null,
+            benchmarksTotalCount: 0,
+            benchmarksHasMore: false,
+            benchmarksCurrentPage: 0,
+            selectedBenchmarkIndex: 0,
+            selectedBenchmarkIds: new Set(),
             benchmarkRuns: [],
             benchmarkRunsLoading: false,
             benchmarkRunsError: null,
@@ -105,10 +163,15 @@ export const useBenchmarkStore = create((set, get) => ({
             benchmarkRunIdFilter: undefined,
             selectedBenchmarkRunIndex: 0,
             selectedScenarioRunIndex: 0,
+            benchmarkPageCache: new Map(),
             benchmarkRunPageCache: new Map(),
             scenarioRunPageCache: new Map(),
         });
     },
+    getSelectedBenchmark: () => {
+        const state = get();
+        return state.benchmarks[state.selectedBenchmarkIndex];
+    },
     getSelectedBenchmarkRun: () => {
         const state = get();
         return state.benchmarkRuns[state.selectedBenchmarkRunIndex];

package/dist/store/gatewayConfigStore.js

@@ -0,0 +1,83 @@
+/**
+ * Gateway Config Store - Manages gateway configuration state, pagination, and caching
+ */
+import { create } from "zustand";
+const MAX_CACHE_SIZE = 10;
+export const useGatewayConfigStore = create((set, get) => ({
+    gatewayConfigs: [],
+    loading: false,
+    initialLoading: true,
+    error: null,
+    currentPage: 0,
+    pageSize: 10,
+    totalCount: 0,
+    hasMore: false,
+    pageCache: new Map(),
+    lastIdCache: new Map(),
+    searchQuery: "",
+    selectedIndex: 0,
+    setGatewayConfigs: (configs) => set({ gatewayConfigs: configs }),
+    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);
+            }
+        }
+        // Deep copy all fields to avoid SDK references
+        const plainData = data.map((d) => {
+            return JSON.parse(JSON.stringify(d));
+        });
+        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({
+            gatewayConfigs: [],
+            loading: false,
+            initialLoading: true,
+            error: null,
+            currentPage: 0,
+            totalCount: 0,
+            hasMore: false,
+            pageCache: new Map(),
+            lastIdCache: new Map(),
+            searchQuery: "",
+            selectedIndex: 0,
+        });
+    },
+    getSelectedGatewayConfig: () => {
+        const state = get();
+        return state.gatewayConfigs[state.selectedIndex];
+    },
+}));

package/dist/utils/browser.js

@@ -0,0 +1,22 @@
+/**
+ * Cross-platform browser-opening utility.
+ */
+/**
+ * Open a URL in the system's default browser.
+ * Works on macOS (open), Windows (start), and Linux (xdg-open).
+ */
+export async function openInBrowser(url) {
+    const { exec } = await import("child_process");
+    const platform = process.platform;
+    let openCommand;
+    if (platform === "darwin") {
+        openCommand = `open "${url}"`;
+    }
+    else if (platform === "win32") {
+        openCommand = `start "${url}"`;
+    }
+    else {
+        openCommand = `xdg-open "${url}"`;
+    }
+    exec(openCommand);
+}

package/dist/utils/clipboard.js

@@ -0,0 +1,41 @@
+/**
+ * Cross-platform clipboard utility.
+ */
+/**
+ * Copy text to the system clipboard.
+ * Returns a promise that resolves with a status message.
+ */
+export async function copyToClipboard(text) {
+    const { spawn } = await import("child_process");
+    const platform = process.platform;
+    let command;
+    let args;
+    if (platform === "darwin") {
+        command = "pbcopy";
+        args = [];
+    }
+    else if (platform === "win32") {
+        command = "clip";
+        args = [];
+    }
+    else {
+        command = "xclip";
+        args = ["-selection", "clipboard"];
+    }
+    return new Promise((resolve) => {
+        const proc = spawn(command, args);
+        proc.stdin.write(text);
+        proc.stdin.end();
+        proc.on("exit", (code) => {
+            if (code === 0) {
+                resolve("Copied to clipboard!");
+            }
+            else {
+                resolve("Failed to copy");
+            }
+        });
+        proc.on("error", () => {
+            resolve("Copy not supported");
+        });
+    });
+}

package/dist/utils/commands.js

@@ -14,7 +14,9 @@ export function createProgram() {
     program
         .name("rli")
         .description("Beautiful CLI for Runloop devbox management")
-        .version(VERSION);
+        .version(VERSION)
+        .showHelpAfterError()
+        .showSuggestionAfterError();
     // Devbox commands
     const devbox = program
         .command("devbox")
@@ -40,6 +42,8 @@ export function createProgram() {
         .option("--root", "Run as root")
         .option("--user <user:uid>", "Run as this user (format: username:uid)")
         .option("--network-policy <id>", "Network policy ID to apply")
+        .option("--tunnel <mode>", "Tunnel authentication mode (open, authenticated)")
+        .option("--gateways <gateways...>", "Gateway configurations (format: ENV_PREFIX=gateway_id_or_name,secret_id_or_name)")
         .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
         .action(createDevbox);
     devbox
@@ -117,22 +121,36 @@ export function createProgram() {
         await sshDevbox(id, options);
     });
     devbox
-        .command("scp <id> <src> <dst>")
-        .description("Copy files to/from a devbox using scp")
+        .command("scp <src> <dst>")
+        .description("Copy files to/from a devbox using scp. Use the devbox ID (dbx_*) as a hostname in src or dst.\n\n" +
+        "  Examples:\n" +
+        "    $ rli devbox scp dbx_abc123:/home/user/file.txt ./file.txt       # download from devbox\n" +
+        "    $ rli devbox scp ./file.txt dbx_abc123:/home/user/file.txt       # upload to devbox\n" +
+        "    $ rli devbox scp root@dbx_abc123:/etc/hosts ./hosts              # with explicit user\n" +
+        "    $ rli devbox scp dbx_src:/data/file.txt dbx_dst:/data/file.txt   # devbox to devbox\n\n" +
+        "  If no user is specified, the devbox's configured user is used.\n" +
+        "  Paths without a dbx_ hostname are treated as local.\n" +
+        "  Devbox-to-devbox transfers route through your local machine via scp -3.")
         .option("--scp-options <options>", "Additional scp options (quoted)")
         .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
-        .action(async (id, src, dst, options) => {
+        .action(async (src, dst, options) => {
         const { scpFiles } = await import("../commands/devbox/scp.js");
-        await scpFiles(id, { src, dst, ...options });
+        await scpFiles(src, dst, options);
     });
     devbox
-        .command("rsync <id> <src> <dst>")
-        .description("Sync files to/from a devbox using rsync")
+        .command("rsync <src> <dst>")
+        .description("Sync files to/from a devbox using rsync. Use the devbox ID (dbx_*) as a hostname in src or dst.\n\n" +
+        "  Examples:\n" +
+        "    $ rli devbox rsync dbx_abc123:/home/user/data/ ./data/             # download from devbox\n" +
+        "    $ rli devbox rsync ./data/ dbx_abc123:/home/user/data/             # upload to devbox\n" +
+        "    $ rli devbox rsync root@dbx_abc123:/etc/config/ ./config/          # with explicit user\n\n" +
+        "  If no user is specified, the devbox's configured user is used.\n" +
+        "  Paths without a dbx_ hostname are treated as local.")
         .option("--rsync-options <options>", "Additional rsync options (quoted)")
         .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
-        .action(async (id, src, dst, options) => {
+        .action(async (src, dst, options) => {
         const { rsyncFiles } = await import("../commands/devbox/rsync.js");
-        await rsyncFiles(id, { src, dst, ...options });
+        await rsyncFiles(src, dst, options);
     });
     devbox
         .command("tunnel <id> <ports>")
@@ -248,6 +266,17 @@ export function createProgram() {
         const { getSnapshot } = await import("../commands/snapshot/get.js");
         await getSnapshot({ id, ...options });
     });
+    snapshot
+        .command("prune <devbox-id>")
+        .description("Delete old snapshots for a devbox, keeping only recent ready ones")
+        .option("--dry-run", "Show what would be deleted without actually deleting")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .option("--keep <n>", "Number of ready snapshots to keep", "1")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+        .action(async (devboxId, options) => {
+        const { pruneSnapshots } = await import("../commands/snapshot/prune.js");
+        await pruneSnapshots(devboxId, options);
+    });
     snapshot
         .command("status <snapshot-id>")
         .description("Get snapshot operation status")
@@ -303,6 +332,15 @@ export function createProgram() {
         const { getBlueprintLogs } = await import("../commands/blueprint/logs.js");
         await getBlueprintLogs({ id, ...options });
     });
+    blueprint
+        .command("delete <id>")
+        .description("Delete a blueprint by ID")
+        .alias("rm")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+        .action(async (id, options) => {
+        const { deleteBlueprint } = await import("../commands/blueprint/delete.js");
+        await deleteBlueprint(id, options);
+    });
     blueprint
         .command("prune <name>")
         .description("Delete old blueprint builds, keeping only recent successful ones")
@@ -488,6 +526,64 @@ export function createProgram() {
         const { deleteSecret } = await import("../commands/secret/delete.js");
         await deleteSecret(name, options);
     });
+    // Gateway config commands
+    const gatewayConfig = program
+        .command("gateway-config")
+        .description("Manage gateway configurations")
+        .alias("gwc");
+    gatewayConfig
+        .command("list")
+        .description("List gateway configurations")
+        .option("--name <name>", "Filter by name")
+        .option("--limit <n>", "Max results", "20")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
+        .action(async (options) => {
+        const { listGatewayConfigs } = await import("../commands/gateway-config/list.js");
+        await listGatewayConfigs(options);
+    });
+    gatewayConfig
+        .command("create")
+        .description("Create a new gateway configuration")
+        .requiredOption("--name <name>", "Gateway config name (required)")
+        .requiredOption("--endpoint <url>", "Target endpoint URL (required)")
+        .option("--bearer-auth", "Use Bearer token authentication (default)")
+        .option("--header-auth <header>", "Use custom header authentication (specify header key name)")
+        .option("--description <description>", "Description")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+        .action(async (options) => {
+        const { createGatewayConfig } = await import("../commands/gateway-config/create.js");
+        await createGatewayConfig(options);
+    });
+    gatewayConfig
+        .command("get <id>")
+        .description("Get gateway configuration details")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
+        .action(async (id, options) => {
+        const { getGatewayConfig } = await import("../commands/gateway-config/get.js");
+        await getGatewayConfig({ id, ...options });
+    });
+    gatewayConfig
+        .command("update <id>")
+        .description("Update a gateway configuration")
+        .option("--name <name>", "New name")
+        .option("--endpoint <url>", "New endpoint URL")
+        .option("--bearer-auth", "Use Bearer token authentication")
+        .option("--header-auth <header>", "Use custom header authentication (specify header key name)")
+        .option("--description <description>", "New description")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+        .action(async (id, options) => {
+        const { updateGatewayConfig } = await import("../commands/gateway-config/update.js");
+        await updateGatewayConfig({ id, ...options });
+    });
+    gatewayConfig
+        .command("delete <id>")
+        .description("Delete a gateway configuration")
+        .alias("rm")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+        .action(async (id, options) => {
+        const { deleteGatewayConfig } = await import("../commands/gateway-config/delete.js");
+        await deleteGatewayConfig(id, options);
+    });
     // MCP server commands
     const mcp = program
         .command("mcp")