@runloop/rl-cli 1.7.1 → 1.9.0

package/dist/store/benchmarkStore.js

@@ -0,0 +1,183 @@
+/**
+ * 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 (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,
+    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
+    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 }),
+    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
+    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;
+        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.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,
+            benchmarkRunsTotalCount: 0,
+            benchmarkRunsHasMore: false,
+            benchmarkRunsCurrentPage: 0,
+            scenarioRuns: [],
+            scenarioRunsLoading: false,
+            scenarioRunsError: null,
+            scenarioRunsTotalCount: 0,
+            scenarioRunsHasMore: false,
+            scenarioRunsCurrentPage: 0,
+            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];
+    },
+    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/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/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/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

@@ -40,6 +40,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
@@ -248,6 +250,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 +316,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 +510,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)")
+        .requiredOption("--auth-type <type>", "Authentication type: bearer or header (required)")
+        .option("--auth-key <key>", "Header key name (required for header auth type)")
+        .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("--auth-type <type>", "New authentication type: bearer or header")
+        .option("--auth-key <key>", "New header key name (required for header auth type)")
+        .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")

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/dist/utils/time.js

@@ -0,0 +1,121 @@
+/**
+ * Shared time formatting utilities using the Temporal API.
+ */
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Get elapsed seconds since the given epoch millisecond timestamp.
+ */
+function getElapsedSeconds(timestampMs) {
+    const now = Temporal.Now.instant();
+    const then = Temporal.Instant.fromEpochMilliseconds(timestampMs);
+    return Math.floor(now.since(then).total("second"));
+}
+/**
+ * Format a relative timestamp in concise form.
+ * Examples: "5s ago", "3m ago", "2h ago", "14d ago", "3mo ago", "1y ago"
+ *
+ * Used for UI detail components.
+ */
+export function formatTimeAgo(timestampMs) {
+    const seconds = getElapsedSeconds(timestampMs);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `${months}mo ago`;
+    const years = Math.floor(months / 12);
+    return `${years}y ago`;
+}
+/**
+ * Format a relative timestamp in verbose form.
+ * Examples: "5 minutes ago", "3 hours ago", "14 days ago"
+ *
+ * Used for CLI text output (e.g. prune commands).
+ */
+export function formatRelativeTime(timestampMs) {
+    if (!timestampMs)
+        return "unknown time";
+    const seconds = getElapsedSeconds(timestampMs);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(seconds / 3600);
+    const days = Math.floor(seconds / 86400);
+    if (minutes < 60) {
+        return `${minutes} minute${minutes !== 1 ? "s" : ""} ago`;
+    }
+    else if (hours < 24) {
+        return `${hours} hour${hours !== 1 ? "s" : ""} ago`;
+    }
+    else {
+        return `${days} day${days !== 1 ? "s" : ""} ago`;
+    }
+}
+/**
+ * Format a timestamp with HH:MM:SS time and a relative indicator.
+ * Examples: "14:30:05 (3m ago)", "01-15 09:00:00 (2d)"
+ *
+ * Used for resource list views.
+ */
+export function formatTimeAgoRich(timestampMs) {
+    const instant = Temporal.Instant.fromEpochMilliseconds(timestampMs);
+    const zdt = instant.toZonedDateTimeISO(Temporal.Now.timeZoneId());
+    const time = `${String(zdt.hour).padStart(2, "0")}:${String(zdt.minute).padStart(2, "0")}:${String(zdt.second).padStart(2, "0")}`;
+    const seconds = getElapsedSeconds(timestampMs);
+    // Less than 1 minute
+    if (seconds < 60)
+        return `${time} (${seconds}s ago)`;
+    const minutes = Math.floor(seconds / 60);
+    // Less than 1 hour
+    if (minutes < 60)
+        return `${time} (${minutes}m ago)`;
+    const hours = Math.floor(minutes / 60);
+    // Less than 24 hours
+    if (hours < 24)
+        return `${time} (${hours}hr ago)`;
+    const days = Math.floor(hours / 24);
+    const month = String(zdt.month).padStart(2, "0");
+    const day = String(zdt.day).padStart(2, "0");
+    const dateStr = `${month}-${day}`;
+    // 1-7 days - show date + time + relative
+    if (days <= 7) {
+        return `${dateStr} ${time} (${days}d)`;
+    }
+    // More than 7 days - just date + time
+    return `${dateStr} ${time}`;
+}
+/**
+ * Format a timestamp as "locale string (relative ago)".
+ * Example: "1/15/2025, 3:30:00 PM (2h ago)"
+ *
+ * Returns undefined if timestamp is falsy.
+ */
+export function formatTimestamp(timestamp) {
+    if (!timestamp)
+        return undefined;
+    const formatted = new Date(timestamp).toLocaleString();
+    const ago = formatTimeAgo(timestamp);
+    return `${formatted} (${ago})`;
+}
+/**
+ * Format a time range as "start → end" or "start (relative ago)" if no end.
+ *
+ * Returns undefined if createTime is falsy.
+ */
+export function formatTimeRange(createTime, endTime) {
+    if (!createTime)
+        return undefined;
+    const start = new Date(createTime).toLocaleString();
+    if (endTime) {
+        const end = new Date(endTime).toLocaleString();
+        return `${start} → ${end}`;
+    }
+    return `${start} (${formatTimeAgo(createTime)})`;
+}