@runloop/rl-cli 1.2.0 → 1.4.0

package/dist/services/networkPolicyService.js

@@ -0,0 +1,108 @@
+/**
+ * Network Policy Service - Handles all network policy API calls
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List network policies with pagination
+ */
+export async function listNetworkPolicies(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.networkPolicies.list(queryParams);
+    const page = (await pagePromise);
+    const networkPolicies = [];
+    if (page.network_policies && Array.isArray(page.network_policies)) {
+        page.network_policies.forEach((p) => {
+            // CRITICAL: Truncate all strings to prevent Yoga crashes
+            const MAX_ID_LENGTH = 100;
+            const MAX_NAME_LENGTH = 200;
+            const MAX_DESC_LENGTH = 500;
+            networkPolicies.push({
+                id: String(p.id || "").substring(0, MAX_ID_LENGTH),
+                name: String(p.name || "").substring(0, MAX_NAME_LENGTH),
+                description: p.description
+                    ? String(p.description).substring(0, MAX_DESC_LENGTH)
+                    : undefined,
+                create_time_ms: p.create_time_ms,
+                update_time_ms: p.update_time_ms,
+                egress: {
+                    allow_all: p.egress.allow_all,
+                    allow_devbox_to_devbox: p.egress.allow_devbox_to_devbox,
+                    allowed_hostnames: p.egress.allowed_hostnames || [],
+                },
+            });
+        });
+    }
+    const result = {
+        networkPolicies,
+        totalCount: page.total_count || networkPolicies.length,
+        hasMore: page.has_more || false,
+    };
+    return result;
+}
+/**
+ * Get a single network policy by ID
+ */
+export async function getNetworkPolicy(id) {
+    const client = getClient();
+    const policy = await client.networkPolicies.retrieve(id);
+    return {
+        id: policy.id,
+        name: policy.name,
+        description: policy.description ?? undefined,
+        create_time_ms: policy.create_time_ms,
+        update_time_ms: policy.update_time_ms,
+        egress: {
+            allow_all: policy.egress.allow_all,
+            allow_devbox_to_devbox: policy.egress.allow_devbox_to_devbox,
+            allowed_hostnames: policy.egress.allowed_hostnames || [],
+        },
+    };
+}
+/**
+ * Delete a network policy
+ */
+export async function deleteNetworkPolicy(id) {
+    const client = getClient();
+    await client.networkPolicies.delete(id);
+}
+export async function createNetworkPolicy(params) {
+    const client = getClient();
+    const policy = await client.networkPolicies.create(params);
+    return {
+        id: policy.id,
+        name: policy.name,
+        description: policy.description ?? undefined,
+        create_time_ms: policy.create_time_ms,
+        update_time_ms: policy.update_time_ms,
+        egress: {
+            allow_all: policy.egress.allow_all,
+            allow_devbox_to_devbox: policy.egress.allow_devbox_to_devbox,
+            allowed_hostnames: policy.egress.allowed_hostnames || [],
+        },
+    };
+}
+export async function updateNetworkPolicy(id, params) {
+    const client = getClient();
+    const policy = await client.networkPolicies.update(id, params);
+    return {
+        id: policy.id,
+        name: policy.name,
+        description: policy.description ?? undefined,
+        create_time_ms: policy.create_time_ms,
+        update_time_ms: policy.update_time_ms,
+        egress: {
+            allow_all: policy.egress.allow_all,
+            allow_devbox_to_devbox: policy.egress.allow_devbox_to_devbox,
+            allowed_hostnames: policy.egress.allowed_hostnames || [],
+        },
+    };
+}

package/dist/services/objectService.js

@@ -0,0 +1,101 @@
+/**
+ * Object Service - Handles all storage object API calls
+ */
+import { getClient } from "../utils/client.js";
+/**
+ * List storage objects with pagination
+ */
+export async function listObjects(options) {
+    const client = getClient();
+    const queryParams = {
+        limit: options.limit,
+    };
+    if (options.startingAfter) {
+        queryParams.starting_after = options.startingAfter;
+    }
+    if (options.name) {
+        queryParams.name = options.name;
+    }
+    if (options.contentType) {
+        queryParams.content_type = options.contentType;
+    }
+    if (options.state) {
+        queryParams.state = options.state;
+    }
+    if (options.isPublic !== undefined) {
+        queryParams.is_public = options.isPublic;
+    }
+    const result = await client.objects.list(queryParams);
+    const objects = [];
+    if (result.objects && Array.isArray(result.objects)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        result.objects.forEach((obj) => {
+            // CRITICAL: Truncate all strings to prevent Yoga crashes
+            const MAX_ID_LENGTH = 100;
+            const MAX_NAME_LENGTH = 200;
+            const MAX_CONTENT_TYPE_LENGTH = 100;
+            const MAX_STATE_LENGTH = 50;
+            objects.push({
+                id: String(obj.id || "").substring(0, MAX_ID_LENGTH),
+                name: String(obj.name || "").substring(0, MAX_NAME_LENGTH),
+                content_type: obj.content_type || "unspecified",
+                create_time_ms: obj.create_time_ms || 0,
+                state: obj.state || "UPLOADING",
+                size_bytes: obj.size_bytes,
+                delete_after_time_ms: obj.delete_after_time_ms,
+                // UI-specific extended fields
+                is_public: obj.is_public,
+            });
+        });
+    }
+    // Access pagination properties from the result
+    const pageResult = result;
+    return {
+        objects,
+        totalCount: pageResult.total_count || objects.length,
+        hasMore: pageResult.has_more || false,
+    };
+}
+/**
+ * Get full object details by ID
+ */
+export async function getObject(id) {
+    const client = getClient();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const obj = await client.objects.retrieve(id);
+    return {
+        id: obj.id,
+        name: obj.name || "",
+        content_type: obj.content_type || "unspecified",
+        create_time_ms: obj.create_time_ms || 0,
+        state: obj.state || "UPLOADING",
+        size_bytes: obj.size_bytes,
+        delete_after_time_ms: obj.delete_after_time_ms,
+        // UI-specific extended fields
+        is_public: obj.is_public,
+        download_url: obj.download_url || undefined,
+        metadata: obj.metadata,
+    };
+}
+/**
+ * Delete an object
+ */
+export async function deleteObject(id) {
+    const client = getClient();
+    await client.objects.delete(id);
+}
+/**
+ * Format file size in human-readable format
+ */
+export function formatFileSize(bytes) {
+    if (bytes === undefined || bytes === null)
+        return "Unknown";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+    }
+    return `${size.toFixed(unitIndex > 0 ? 2 : 0)} ${units[unitIndex]}`;
+}

package/dist/services/snapshotService.js

@@ -33,11 +33,14 @@ export async function listSnapshots(options) {
                 name: snapshotView.name
                     ? String(snapshotView.name).substring(0, MAX_NAME_LENGTH)
                     : undefined,
+                create_time_ms: snapshotView.create_time_ms,
+                metadata: snapshotView.metadata || {},
+                source_devbox_id: String(snapshotView.source_devbox_id || "").substring(0, MAX_ID_LENGTH),
+                // UI-specific extended fields
                 devbox_id: String(snapshotView.source_devbox_id || "").substring(0, MAX_ID_LENGTH),
                 status: snapshotView.status
                     ? String(snapshotView.status).substring(0, MAX_STATUS_LENGTH)
                     : "",
-                create_time_ms: snapshotView.create_time_ms,
             });
         });
     }
@@ -56,6 +59,36 @@ export async function getSnapshotStatus(id) {
     const status = await client.devboxes.diskSnapshots.queryStatus(id);
     return status;
 }
+/**
+ * Get full snapshot details by ID
+ */
+export async function getSnapshot(id) {
+    const client = getClient();
+    const statusResponse = await client.devboxes.diskSnapshots.queryStatus(id);
+    // The queryStatus returns a status wrapper with snapshot data inside
+    const snapshot = statusResponse.snapshot;
+    const operationStatus = statusResponse.status; // 'in_progress', 'error', 'complete', 'deleted'
+    if (!snapshot) {
+        // If no snapshot data yet, return minimal info based on operation status
+        return {
+            id: id,
+            create_time_ms: Date.now(),
+            metadata: {},
+            source_devbox_id: "",
+            status: operationStatus === "in_progress" ? "pending" : operationStatus,
+        };
+    }
+    return {
+        id: snapshot.id,
+        name: snapshot.name || undefined,
+        create_time_ms: snapshot.create_time_ms,
+        metadata: snapshot.metadata || {},
+        source_devbox_id: snapshot.source_devbox_id || "",
+        // UI-specific extended fields
+        devbox_id: snapshot.source_devbox_id || undefined,
+        status: operationStatus === "complete" ? "ready" : operationStatus,
+    };
+}
 /**
  * Create a snapshot
  */
@@ -67,9 +100,12 @@ export async function createSnapshot(devboxId, name) {
     return {
         id: snapshot.id,
         name: snapshot.name || undefined,
-        devbox_id: snapshot.devbox_id || devboxId,
-        status: snapshot.status || "pending",
         create_time_ms: snapshot.create_time_ms,
+        metadata: snapshot.metadata || {},
+        source_devbox_id: snapshot.source_devbox_id || devboxId,
+        // UI-specific extended fields
+        devbox_id: snapshot.source_devbox_id || devboxId,
+        status: "pending",
     };
 }
 /**

package/dist/store/blueprintStore.js

@@ -38,16 +38,10 @@ export const useBlueprintStore = create((set, get) => ({
                 lastIdCache.delete(oldestKey);
             }
         }
-        // Create plain data objects to avoid SDK references
-        const plainData = data.map((b) => ({
-            id: b.id,
-            name: b.name,
-            status: b.status,
-            create_time_ms: b.create_time_ms,
-            build_status: b.build_status,
-            architecture: b.architecture,
-            resources: b.resources,
-        }));
+        // 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({});

package/dist/store/index.js

@@ -5,3 +5,4 @@ export { useNavigation, useNavigationStore, NavigationProvider, } from "./naviga
 export { useDevboxStore } from "./devboxStore.js";
 export { useBlueprintStore } from "./blueprintStore.js";
 export { useSnapshotStore } from "./snapshotStore.js";
+export { useObjectStore } from "./objectStore.js";

package/dist/store/networkPolicyStore.js

@@ -0,0 +1,83 @@
+/**
+ * Network Policy Store - Manages network policy list state, pagination, and caching
+ */
+import { create } from "zustand";
+const MAX_CACHE_SIZE = 10;
+export const useNetworkPolicyStore = create((set, get) => ({
+    networkPolicies: [],
+    loading: false,
+    initialLoading: true,
+    error: null,
+    currentPage: 0,
+    pageSize: 10,
+    totalCount: 0,
+    hasMore: false,
+    pageCache: new Map(),
+    lastIdCache: new Map(),
+    searchQuery: "",
+    selectedIndex: 0,
+    setNetworkPolicies: (policies) => set({ networkPolicies: policies }),
+    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({
+            networkPolicies: [],
+            loading: false,
+            initialLoading: true,
+            error: null,
+            currentPage: 0,
+            totalCount: 0,
+            hasMore: false,
+            pageCache: new Map(),
+            lastIdCache: new Map(),
+            searchQuery: "",
+            selectedIndex: 0,
+        });
+    },
+    getSelectedNetworkPolicy: () => {
+        const state = get();
+        return state.networkPolicies[state.selectedIndex];
+    },
+}));

package/dist/store/objectStore.js

@@ -0,0 +1,92 @@
+/**
+ * Object Store - Manages storage object list state, pagination, and caching
+ */
+import { create } from "zustand";
+const MAX_CACHE_SIZE = 10;
+export const useObjectStore = create((set, get) => ({
+    objects: [],
+    loading: false,
+    initialLoading: true,
+    error: null,
+    currentPage: 0,
+    pageSize: 10,
+    totalCount: 0,
+    hasMore: false,
+    pageCache: new Map(),
+    lastIdCache: new Map(),
+    nameFilter: undefined,
+    contentTypeFilter: undefined,
+    stateFilter: undefined,
+    isPublicFilter: undefined,
+    selectedIndex: 0,
+    setObjects: (objects) => set({ objects }),
+    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 }),
+    setNameFilter: (name) => set({ nameFilter: name }),
+    setContentTypeFilter: (contentType) => set({ contentTypeFilter: contentType }),
+    setStateFilter: (state) => set({ stateFilter: state }),
+    setIsPublicFilter: (isPublic) => set({ isPublicFilter: isPublic }),
+    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({
+            objects: [],
+            loading: false,
+            initialLoading: true,
+            error: null,
+            currentPage: 0,
+            totalCount: 0,
+            hasMore: false,
+            pageCache: new Map(),
+            lastIdCache: new Map(),
+            nameFilter: undefined,
+            contentTypeFilter: undefined,
+            stateFilter: undefined,
+            isPublicFilter: undefined,
+            selectedIndex: 0,
+        });
+    },
+    getSelectedObject: () => {
+        const state = get();
+        return state.objects[state.selectedIndex];
+    },
+}));

package/dist/store/snapshotStore.js

@@ -38,14 +38,10 @@ export const useSnapshotStore = create((set, get) => ({
                 lastIdCache.delete(oldestKey);
             }
         }
-        // Create plain data objects to avoid SDK references
-        const plainData = data.map((s) => ({
-            id: s.id,
-            name: s.name,
-            devbox_id: s.devbox_id,
-            status: s.status,
-            create_time_ms: s.create_time_ms,
-        }));
+        // 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({});

package/dist/utils/commands.js

@@ -38,6 +38,7 @@ export function createProgram() {
         .option("--available-ports <ports...>", "Available ports")
         .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("-o, --output [format]", "Output format: text|json|yaml (default: text)")
         .action(createDevbox);
     devbox
@@ -311,6 +312,24 @@ export function createProgram() {
         const { pruneBlueprints } = await import("../commands/blueprint/prune.js");
         await pruneBlueprints(name, options);
     });
+    blueprint
+        .command("from-dockerfile")
+        .description("Create a blueprint from a Dockerfile with build context support")
+        .requiredOption("--name <name>", "Blueprint name (required)")
+        .option("--build-context <path>", "Build context directory (default: current directory)")
+        .option("--dockerfile <path>", "Dockerfile path (default: Dockerfile in build context)")
+        .option("--system-setup-commands <commands...>", "System setup commands")
+        .option("--resources <size>", "Resource size (X_SMALL, SMALL, MEDIUM, LARGE, X_LARGE, XX_LARGE)")
+        .option("--architecture <arch>", "Architecture (arm64, x86_64)")
+        .option("--available-ports <ports...>", "Available ports")
+        .option("--root", "Run as root")
+        .option("--user <user:uid>", "Run as this user (format: username:uid)")
+        .option("--ttl <seconds>", "TTL in seconds for the build context object (default: 3600)")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
+        .action(async (options) => {
+        const { createBlueprintFromDockerfile } = await import("../commands/blueprint/from-dockerfile.js");
+        await createBlueprintFromDockerfile(options);
+    });
     // Object storage commands
     const object = program
         .command("object")
@@ -374,6 +393,52 @@ export function createProgram() {
         const { deleteObject } = await import("../commands/object/delete.js");
         await deleteObject({ id, ...options });
     });
+    // Network policy commands
+    const networkPolicy = program
+        .command("network-policy")
+        .description("Manage network policies")
+        .alias("np");
+    networkPolicy
+        .command("list")
+        .description("List network policies")
+        .option("--limit <n>", "Max results", "20")
+        .option("--starting-after <id>", "Starting point for pagination")
+        .option("--name <name>", "Filter by name")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
+        .action(async (options) => {
+        const { listNetworkPolicies } = await import("../commands/network-policy/list.js");
+        await listNetworkPolicies(options);
+    });
+    networkPolicy
+        .command("get <id>")
+        .description("Get network policy details")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: json)")
+        .action(async (id, options) => {
+        const { getNetworkPolicy } = await import("../commands/network-policy/get.js");
+        await getNetworkPolicy({ id, ...options });
+    });
+    networkPolicy
+        .command("create")
+        .description("Create a new network policy")
+        .requiredOption("--name <name>", "Policy name (required)")
+        .option("--description <description>", "Policy description")
+        .option("--allow-all", "Allow all egress traffic")
+        .option("--allow-devbox-to-devbox", "Allow devbox-to-devbox communication")
+        .option("--allowed-hostnames <hostnames...>", "List of allowed hostnames for egress")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+        .action(async (options) => {
+        const { createNetworkPolicy } = await import("../commands/network-policy/create.js");
+        await createNetworkPolicy(options);
+    });
+    networkPolicy
+        .command("delete <id>")
+        .description("Delete a network policy")
+        .alias("rm")
+        .option("-o, --output [format]", "Output format: text|json|yaml (default: text)")
+        .action(async (id, options) => {
+        const { deleteNetworkPolicy } = await import("../commands/network-policy/delete.js");
+        await deleteNetworkPolicy(id, options);
+    });
     // MCP server commands
     const mcp = program
         .command("mcp")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runloop/rl-cli",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Beautiful CLI for the Runloop platform",
   "type": "module",
   "bin": {
@@ -67,7 +67,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.19.1",
-    "@runloop/api-client": "^1.0.0",
+    "@runloop/api-client": "1.3.0",
     "@types/express": "^5.0.3",
     "chalk": "^5.3.0",
     "commander": "^14.0.1",