@upstash/mcp-server 0.2.2 → 0.2.3

package/dist/index.js

@@ -9,6 +9,15 @@ import { createServer } from "http";
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
+// src/config.ts
+var config = {
+  apiKey: "",
+  email: "",
+  boxApiKey: "",
+  disableTelemetry: false,
+  readonly: false
+};
+
 // src/log.ts
 import { appendFileSync } from "fs";
 import path from "path";
@@ -44,6 +53,7 @@ function tool(t) {
 // src/tools/utils.ts
 var utilTools = {
   util_timestamps_to_date: tool({
+    readonly: true,
     description: `Use this tool to convert a timestamp to a human-readable date`,
     inputSchema: z.object({
       timestamps: z.array(z.number()).describe("Array of timestamps to convert")
@@ -53,6 +63,7 @@ var utilTools = {
     }
   }),
   util_dates_to_timestamps: tool({
+    readonly: true,
     description: `Use this tool to convert an array of ISO 8601 dates to an array of timestamps`,
     inputSchema: z.object({
       dates: z.array(z.string()).describe("Array of dates to convert")
@@ -66,13 +77,6 @@ var utilTools = {
 // src/tools/redis/backup.ts
 import { z as z2 } from "zod";
 
-// src/config.ts
-var config = {
-  apiKey: "",
-  email: "",
-  disableTelemetry: false
-};
-
 // src/middlewares.ts
 var formatTimestamps = (obj) => {
   if (!obj || typeof obj !== "object") {
@@ -113,7 +117,7 @@ var applyMiddlewares = async (req, func) => {
 };
 
 // src/version.ts
-var VERSION = "v0.2.2";
+var VERSION = "0.2.3";
 
 // src/telemetry.ts
 function getRuntime() {
@@ -296,6 +300,7 @@ var redisBackupTools = {
     }
   }),
   redis_database_list_backups: tool({
+    readonly: true,
     // TODO: Add explanation for fields
     // TODO: Is this in bytes?
     description: `List all backups of a specific Upstash redis database.`,
@@ -327,6 +332,7 @@ var redisBackupTools = {
 import { z as z3 } from "zod";
 var redisCommandTools = {
   redis_database_run_redis_commands: tool({
+    readonly: true,
     description: `Run one or more Redis commands on a specific Upstash redis database. Either provide database_id OR both database_rest_url and database_rest_token.
 NOTE: For discovery, use SCAN over KEYS. Use TYPE to get the type of a key.
 NOTE: SCAN cursor [MATCH pattern] [COUNT count] [TYPE type]
@@ -355,7 +361,7 @@ NOTE: Multiple commands will be executed as a pipeline for better performance.`,
         log("Fetching database details for database_id:", database_id);
         const db = await http.get(["v2/redis/database", database_id]);
         restUrl = "https://" + db.endpoint;
-        restToken = db.rest_token;
+        restToken = config.readonly ? db.read_only_rest_token : db.rest_token;
       }
       if (!restUrl || !restToken) {
         throw new Error("Could not determine REST URL and token for the database");
@@ -448,6 +454,7 @@ NOTE: Ask user for the region and name of the database.${GENERIC_DATABASE_NOTES}
     }
   }),
   redis_database_list_databases: tool({
+    readonly: true,
     description: `List all Upstash redis databases. Only their names and ids.${GENERIC_DATABASE_NOTES}`,
     handler: async () => {
       const dbs = await http.get("v2/redis/databases");
@@ -474,6 +481,7 @@ NOTE: Ask user for the region and name of the database.${GENERIC_DATABASE_NOTES}
     }
   }),
   redis_database_get_details: tool({
+    readonly: true,
     description: `Get further details of a specific Upstash redis database. Includes all details of the database including usage statistics.
 db_disk_threshold: Total disk usage limit.
 db_memory_threshold: Maximum memory usage.
@@ -516,6 +524,7 @@ ${GENERIC_DATABASE_NOTES}
     }
   }),
   redis_database_get_statistics: tool({
+    readonly: true,
     description: `Get comprehensive usage statistics of an Upstash redis database. Returns both:
 1. PRECISE 5-day usage: Exact command count and bandwidth usage over the last 5 days
 2. SAMPLED period stats: Sampled statistics over a specified period (1h, 3h, 12h, 1d, 3d, 7d) for performance monitoring
@@ -633,6 +642,11 @@ async function getQStashCredentials(region) {
   return { token: match.token };
 }
 async function createQStashClientWithToken(options) {
+  if (config.readonly) {
+    throw new Error(
+      "QStash is not available in readonly mode yet. This feature will be implemented in the near future."
+    );
+  }
   const { qstash_creds, region, local_mode_port } = options;
   if (qstash_creds) {
     return createQStashClient({ url: qstash_creds.url, token: qstash_creds.token });
@@ -1169,10 +1183,424 @@ var qstashAllTools = {
   ...workflowTools
 };
 
+// src/tools/box/manage.ts
+import { z as z9 } from "zod";
+
+// src/tools/box/common.ts
+import { z as z8 } from "zod";
+var BOX_BASE_URL = "https://us-east-1.box.upstash.com";
+function buildBoxCommon() {
+  const hasConfigKey = Boolean(config.boxApiKey);
+  return {
+    box_api_key: hasConfigKey ? z8.string().optional().describe(
+      "NOTE: The api key is already pre-configured at server startup; only pass this to override the configured key."
+    ) : z8.string().describe(
+      "Box API key (starts with 'box_'). Check the project's .env file for BOX_API_KEY, or ask the user for it."
+    )
+  };
+}
+
+// src/tools/box/utils.ts
+function getBoxClient(params) {
+  const apiKey = params.box_api_key || config.boxApiKey;
+  if (!apiKey) {
+    throw new Error(
+      "No Box API key available. Pass box_api_key as a tool argument, or configure the server with --box-api-key / UPSTASH_BOX_API_KEY env var."
+    );
+  }
+  return new HttpClient({
+    baseUrl: BOX_BASE_URL,
+    qstashToken: apiKey
+  });
+}
+
+// src/tools/box/manage.ts
+var boxManageTool = {
+  box_manage: tool({
+    description: `Manage Upstash Box containers. Supports creating, listing, getting, deleting, pausing, resuming, and forking boxes. Boxes are secure cloud containers with built-in AI agent capabilities.`,
+    get inputSchema() {
+      return z9.object({
+        action: z9.enum(["create", "list", "get", "delete", "pause", "resume", "fork"]).describe("The action to perform"),
+        box_id: z9.string().optional().describe("Box ID (required for get, delete, pause, resume, fork)"),
+        // Create-specific fields
+        name: z9.string().optional().describe("Display name for the box"),
+        model: z9.string().optional().describe(
+          "LLM model to use (e.g. 'claude/sonnet_4_6', 'openai/o4-mini'). Required for create"
+        ),
+        agent: z9.enum(["claude-code", "codex", "opencode"]).optional().default("claude-code").describe("Agent type (default: claude-code)"),
+        runtime: z9.string().optional().default("node").describe("Runtime environment (e.g. 'node', 'python')"),
+        agent_api_key: z9.string().optional().describe("API key for the AI agent provider. Empty uses managed key"),
+        env_vars: z9.record(z9.string()).optional().describe("Environment variables to set in the box"),
+        clone_repo: z9.string().optional().describe("Git repository URL to clone into the box"),
+        clone_token: z9.string().optional().describe("Token for cloning private repositories"),
+        ephemeral: z9.boolean().optional().describe("If true, box auto-deletes after TTL expires"),
+        ttl: z9.number().optional().describe("Time-to-live in seconds for ephemeral boxes (max 259200 = 3 days)"),
+        // List-specific fields
+        status: z9.enum(["active", "deleted"]).optional().describe("Filter for list action: 'active' (default) or 'deleted'"),
+        ...buildBoxCommon()
+      });
+    },
+    handler: async (params) => {
+      const { action, box_id } = params;
+      const client = getBoxClient(params);
+      switch (action) {
+        case "create": {
+          if (!params.model) {
+            throw new Error("model is required for create action");
+          }
+          const body = {
+            model: params.model
+          };
+          if (params.name) body.name = params.name;
+          if (params.agent) body.agent = params.agent;
+          if (params.runtime) body.runtime = params.runtime;
+          if (params.agent_api_key) body.agent_api_key = params.agent_api_key;
+          if (params.env_vars) body.env_vars = params.env_vars;
+          if (params.clone_repo) body.clone_repo = params.clone_repo;
+          if (params.clone_token) body.clone_token = params.clone_token;
+          if (params.ephemeral !== void 0) body.ephemeral = params.ephemeral;
+          if (params.ttl !== void 0) body.ttl = params.ttl;
+          const box = await client.post("v2/box", body);
+          return [
+            `Box created successfully (status: ${box.status})`,
+            `Box ID: ${box.id}`,
+            json(box)
+          ];
+        }
+        case "list": {
+          const query = {};
+          if (params.status === "deleted") query.status = "deleted";
+          const boxes = await client.get("v2/box", query);
+          return [`Found ${boxes.length} boxes`, json(boxes)];
+        }
+        case "get": {
+          if (!box_id) throw new Error("box_id is required for get action");
+          const box = await client.get(`v2/box/${box_id}`);
+          return [`Box ${box_id} (status: ${box.status})`, json(box)];
+        }
+        case "delete": {
+          if (!box_id) throw new Error("box_id is required for delete action");
+          await client.delete(`v2/box/${box_id}`);
+          return `Box ${box_id} deleted successfully`;
+        }
+        case "pause": {
+          if (!box_id) throw new Error("box_id is required for pause action");
+          await client.post(`v2/box/${box_id}/pause`);
+          return `Box ${box_id} paused successfully`;
+        }
+        case "resume": {
+          if (!box_id) throw new Error("box_id is required for resume action");
+          await client.post(`v2/box/${box_id}/resume`);
+          return `Box ${box_id} resumed successfully`;
+        }
+        case "fork": {
+          if (!box_id) throw new Error("box_id is required for fork action");
+          const forked = await client.post(`v2/box/${box_id}/fork`);
+          return [`Box forked successfully`, `New Box ID: ${forked.id}`, json(forked)];
+        }
+        default: {
+          throw new Error(`Unknown action: ${action}`);
+        }
+      }
+    }
+  })
+};
+
+// src/tools/box/exec.ts
+import { z as z10 } from "zod";
+var boxExecTool = {
+  box_exec: tool({
+    description: `Execute a shell command inside an Upstash Box container. Use this for file operations, git commands, package installs, or any shell operation inside the box.`,
+    get inputSchema() {
+      return z10.object({
+        box_id: z10.string().describe("The box ID to execute the command in"),
+        command: z10.array(z10.string()).describe("Command and arguments as an array (e.g. ['bash', '-c', 'ls -la'])"),
+        folder: z10.string().optional().describe("Working directory inside the box"),
+        async: z10.boolean().optional().describe("If true, return immediately without waiting for completion"),
+        ...buildBoxCommon()
+      });
+    },
+    handler: async (params) => {
+      const { box_id, command, folder, async: isAsync } = params;
+      const client = getBoxClient(params);
+      const body = { command };
+      if (folder) body.folder = folder;
+      if (isAsync) body.async = isAsync;
+      const response = await client.post(`v2/box/${box_id}/exec`, body);
+      if (response.exit_code !== 0) {
+        return [
+          `Command failed with exit code ${response.exit_code}`,
+          response.output ? `stdout: ${response.output}` : "",
+          response.error ? `stderr: ${response.error}` : ""
+        ].filter(Boolean);
+      }
+      return [
+        `Command executed successfully (exit code: ${response.exit_code})`,
+        response.output || "(no output)"
+      ];
+    }
+  })
+};
+
+// src/tools/box/agent-run.ts
+import { z as z11 } from "zod";
+var boxAgentRunTool = {
+  box_agent_run: tool({
+    description: `Run an AI agent prompt inside an Upstash Box. The agent has access to shell, filesystem, and git inside the box. It reasons, executes commands, and iterates until the task is complete. This is a synchronous call that may take a while depending on the complexity of the prompt.`,
+    get inputSchema() {
+      return z11.object({
+        box_id: z11.string().describe("The box ID to run the agent in"),
+        prompt: z11.string().describe("The natural-language prompt for the agent to execute"),
+        model: z11.string().optional().describe("Override the box's default LLM model for this run"),
+        folder: z11.string().optional().describe("Working directory inside the box for the agent"),
+        ...buildBoxCommon()
+      });
+    },
+    handler: async (params) => {
+      const { box_id, prompt, model, folder } = params;
+      const client = getBoxClient(params);
+      const body = { prompt };
+      if (model) body.model = model;
+      if (folder) body.folder = folder;
+      const response = await client.post(`v2/box/${box_id}/run`, body);
+      const result = [`Agent run completed`];
+      if (response.run_id) {
+        result.push(`Run ID: ${response.run_id}`);
+      }
+      result.push(response.output || "(no output)");
+      if (response.metadata) {
+        result.push(
+          `Tokens: ${response.metadata.input_tokens ?? 0} in / ${response.metadata.output_tokens ?? 0} out` + (response.metadata.cost_usd ? ` ($${response.metadata.cost_usd.toFixed(4)})` : "")
+        );
+      }
+      return result;
+    }
+  })
+};
+
+// src/tools/box/logs.ts
+import { z as z12 } from "zod";
+var boxLogsTool = {
+  box_logs: tool({
+    description: `Get logs from an Upstash Box container. Useful for debugging what happened inside the box. Returns timestamped log entries from the system, user, and agent sources.`,
+    get inputSchema() {
+      return z12.object({
+        box_id: z12.string().describe("The box ID to get logs for"),
+        offset: z12.number().optional().default(0).describe("Starting position for log entries (default: 0)"),
+        limit: z12.number().max(1e3).optional().default(100).describe("Maximum number of log entries to return (max 1000, default: 100)"),
+        ...buildBoxCommon()
+      });
+    },
+    handler: async (params) => {
+      const { box_id, offset, limit } = params;
+      const client = getBoxClient(params);
+      const response = await client.get(`v2/box/${box_id}/logs`, {
+        offset,
+        limit
+      });
+      const logs = response.logs ?? [];
+      if (logs.length === 0) {
+        return "No logs found for this box";
+      }
+      return [`Found ${logs.length} log entries`, json(logs)];
+    }
+  })
+};
+
+// src/tools/box/runs.ts
+import { z as z13 } from "zod";
+var boxRunsTool = {
+  box_runs: tool({
+    description: `List, get details, or cancel runs (execution history) for an Upstash Box. Useful for debugging past agent runs and shell executions, checking their status, output, token usage, and costs.`,
+    get inputSchema() {
+      return z13.object({
+        action: z13.enum(["list", "get", "cancel"]).describe("The action to perform"),
+        box_id: z13.string().describe("The box ID"),
+        run_id: z13.string().optional().describe("Run ID (required for get and cancel actions)"),
+        ...buildBoxCommon()
+      });
+    },
+    handler: async (params) => {
+      const { action, box_id, run_id } = params;
+      const client = getBoxClient(params);
+      switch (action) {
+        case "list": {
+          const response = await client.get(`v2/box/${box_id}/runs`);
+          const runs = response.runs ?? [];
+          return [`Found ${runs.length} runs`, json(runs)];
+        }
+        case "get": {
+          if (!run_id) throw new Error("run_id is required for get action");
+          const run = await client.get(`v2/box/${box_id}/runs/${run_id}`);
+          return [`Run ${run_id} (status: ${run.status})`, json(run)];
+        }
+        case "cancel": {
+          if (!run_id) throw new Error("run_id is required for cancel action");
+          await client.post(`v2/box/${box_id}/runs/${run_id}/cancel`);
+          return `Run ${run_id} cancelled successfully`;
+        }
+        default: {
+          throw new Error(`Unknown action: ${action}`);
+        }
+      }
+    }
+  })
+};
+
+// src/tools/box/preview.ts
+import { z as z14 } from "zod";
+var boxPreviewTool = {
+  box_preview: tool({
+    description: `Manage preview URLs for web applications running inside an Upstash Box. Create public URLs to access services running on specific ports, list existing previews, or delete them.`,
+    get inputSchema() {
+      return z14.object({
+        action: z14.enum(["create", "list", "delete"]).describe("The action to perform"),
+        box_id: z14.string().describe("The box ID"),
+        port: z14.number().min(1).max(65535).optional().describe("Port number (required for create and delete)"),
+        basic_auth: z14.boolean().optional().describe("Enable basic auth on the preview URL (create only)"),
+        bearer_token: z14.boolean().optional().describe("Enable bearer token auth on the preview URL (create only)"),
+        ...buildBoxCommon()
+      });
+    },
+    handler: async (params) => {
+      const { action, box_id, port, basic_auth, bearer_token } = params;
+      const client = getBoxClient(params);
+      switch (action) {
+        case "create": {
+          if (!port) throw new Error("port is required for create action");
+          const body = { port };
+          if (basic_auth) body.basic_auth = basic_auth;
+          if (bearer_token) body.bearer_token = bearer_token;
+          const response = await client.post(
+            `v2/box/${box_id}/preview`,
+            body
+          );
+          const result = [
+            `Preview URL created: ${response.url}`,
+            `Port: ${response.port}`
+          ];
+          if (response.username) result.push(`Username: ${response.username}`);
+          if (response.password) result.push(`Password: ${response.password}`);
+          if (response.token) result.push(`Token: ${response.token}`);
+          return result;
+        }
+        case "list": {
+          const response = await client.get(`v2/box/${box_id}/preview`);
+          const previews = response.previews ?? [];
+          return [`Found ${previews.length} preview URLs`, json(previews)];
+        }
+        case "delete": {
+          if (!port) throw new Error("port is required for delete action");
+          await client.delete(`v2/box/${box_id}/preview/${port}`);
+          return `Preview for port ${port} deleted successfully`;
+        }
+        default: {
+          throw new Error(`Unknown action: ${action}`);
+        }
+      }
+    }
+  })
+};
+
+// src/tools/box/snapshots.ts
+import { z as z15 } from "zod";
+var boxSnapshotsTool = {
+  box_snapshots: tool({
+    description: `Manage Upstash Box snapshots. Create full filesystem snapshots of a box, list snapshots, delete them, or restore a box from a snapshot.`,
+    get inputSchema() {
+      return z15.object({
+        action: z15.enum(["create", "list", "list_all", "delete", "restore"]).describe(
+          "The action to perform. 'list' lists snapshots for a specific box, 'list_all' lists all your snapshots"
+        ),
+        box_id: z15.string().optional().describe("Box ID (required for create, list, delete)"),
+        snapshot_id: z15.string().optional().describe("Snapshot ID (required for delete and restore)"),
+        // Create-specific
+        name: z15.string().optional().describe("Name for the snapshot (auto-generated if empty)"),
+        // Restore-specific
+        model: z15.string().optional().describe("LLM model for the restored box (required for restore)"),
+        runtime: z15.string().optional().describe("Override the snapshot's runtime for the restored box"),
+        env_vars: z15.record(z15.string()).optional().describe("Environment variables for the restored box"),
+        ephemeral: z15.boolean().optional().describe("Create the restored box as ephemeral"),
+        ttl: z15.number().optional().describe("TTL in seconds for the restored ephemeral box (max 259200)"),
+        ...buildBoxCommon()
+      });
+    },
+    handler: async (params) => {
+      const { action, box_id, snapshot_id } = params;
+      const client = getBoxClient(params);
+      switch (action) {
+        case "create": {
+          if (!box_id) throw new Error("box_id is required for create action");
+          const body = {};
+          if (params.name) body.name = params.name;
+          const snapshot = await client.post(`v2/box/${box_id}/snapshots`, body);
+          return [
+            `Snapshot created (status: ${snapshot.status})`,
+            `Snapshot ID: ${snapshot.id}`,
+            json(snapshot)
+          ];
+        }
+        case "list": {
+          if (!box_id) throw new Error("box_id is required for list action");
+          const response = await client.get(
+            `v2/box/${box_id}/snapshots`
+          );
+          const snapshots = response.snapshots ?? [];
+          return [`Found ${snapshots.length} snapshots for box ${box_id}`, json(snapshots)];
+        }
+        case "list_all": {
+          const response = await client.get("v2/box/snapshots");
+          const snapshots = response.snapshots ?? [];
+          return [`Found ${snapshots.length} snapshots total`, json(snapshots)];
+        }
+        case "delete": {
+          if (!box_id) throw new Error("box_id is required for delete action");
+          if (!snapshot_id) throw new Error("snapshot_id is required for delete action");
+          await client.delete(`v2/box/${box_id}/snapshots/${snapshot_id}`);
+          return `Snapshot ${snapshot_id} deleted successfully`;
+        }
+        case "restore": {
+          if (!snapshot_id) throw new Error("snapshot_id is required for restore action");
+          if (!params.model) throw new Error("model is required for restore action");
+          const body = {
+            snapshot_id,
+            model: params.model
+          };
+          if (params.runtime) body.runtime = params.runtime;
+          if (params.env_vars) body.env_vars = params.env_vars;
+          if (params.ephemeral !== void 0) body.ephemeral = params.ephemeral;
+          if (params.ttl !== void 0) body.ttl = params.ttl;
+          const box = await client.post("v2/box/from-snapshot", body);
+          return [
+            `Box restored from snapshot (status: ${box.status})`,
+            `New Box ID: ${box.id}`,
+            json(box)
+          ];
+        }
+        default: {
+          throw new Error(`Unknown action: ${action}`);
+        }
+      }
+    }
+  })
+};
+
+// src/tools/box/index.ts
+var boxTools = {
+  ...boxManageTool,
+  ...boxExecTool,
+  ...boxAgentRunTool,
+  ...boxLogsTool,
+  ...boxRunsTool,
+  ...boxPreviewTool,
+  ...boxSnapshotsTool
+};
+
 // src/tools/index.ts
 var tools = {
   ...redisTools,
-  ...qstashAllTools
+  ...qstashAllTools,
+  ...boxTools
 };
 
 // src/settings.ts
@@ -1192,7 +1620,7 @@ function handlerResponseToCallResult(response) {
 }
 
 // src/server.ts
-import z8 from "zod";
+import z16 from "zod";
 function createServerInstance() {
   const server = new McpServer(
     { name: "upstash", version: "0.1.0" },
@@ -1203,7 +1631,8 @@ function createServerInstance() {
       }
     }
   );
-  const toolsList = Object.entries(tools).map(([name, tool2]) => ({
+  const filteredTools = config.readonly ? Object.fromEntries(Object.entries(tools).filter(([_, tool2]) => tool2.readonly)) : tools;
+  const toolsList = Object.entries(filteredTools).map(([name, tool2]) => ({
     name,
     description: tool2.description,
     inputSchema: tool2.inputSchema,
@@ -1216,7 +1645,7 @@ function createServerInstance() {
       toolName,
       {
         description: tool2.description,
-        inputSchema: (tool2.inputSchema ?? z8.object({})).shape
+        inputSchema: (tool2.inputSchema ?? z16.object({})).shape
       },
       // @ts-expect-error - Just ignore the types here
       async (args) => {
@@ -1253,6 +1682,7 @@ Stack trace: ${error instanceof Error ? error.stack : "No stack trace available"
 }
 
 // src/test-connection.ts
+var READONLY_ERROR = "Readonly API key";
 async function testConnection() {
   log("\u{1F9EA} Testing connection to Upstash API");
   let dbs;
@@ -1267,6 +1697,14 @@ async function testConnection() {
   }
   if (!Array.isArray(dbs))
     throw new Error("Invalid response from Upstash API. Check your API key and email.");
+  try {
+    await http.delete("v2/redis/database/readonly-check-nonexistent");
+  } catch (error) {
+    if (error instanceof Error && error.message.includes(READONLY_ERROR)) {
+      config.readonly = true;
+      log("\u{1F512} Readonly API key detected. Write operations will be disabled.");
+    }
+  }
   log("\u2705 Connection to Upstash API is successful");
 }
 
@@ -1276,7 +1714,7 @@ var argv = process.argv.slice(2);
 if (argv.length >= 3 && argv[0] === "run") {
   argv = ["--email", argv[1], "--api-key", argv[2], ...argv.slice(3)];
 }
-var program = new Command().option("--transport <stdio|http>", "transport type", "stdio").option("--port <number>", "port for HTTP transport", "3000").option("--email <email>", "Upstash email").option("--api-key <key>", "Upstash API key").option("--debug", "Enable debug mode").option("--disable-telemetry", "Disable telemetry headers sent to Upstash APIs").allowUnknownOption();
+var program = new Command().option("--transport <stdio|http>", "transport type", "stdio").option("--port <number>", "port for HTTP transport", "3000").option("--email <email>", "Upstash email").option("--api-key <key>", "Upstash API key").option("--box-api-key <key>", "Upstash Box API key (optional)").option("--debug", "Enable debug mode").option("--disable-telemetry", "Disable telemetry headers sent to Upstash APIs").allowUnknownOption();
 program.parse(argv, { from: "user" });
 var cliOptions = program.opts();
 var DEBUG = cliOptions.debug ?? false;
@@ -1311,6 +1749,7 @@ async function main() {
   }
   config.email = email;
   config.apiKey = apiKey;
+  config.boxApiKey = cliOptions.boxApiKey || process.env.UPSTASH_BOX_API_KEY || "";
   config.disableTelemetry = cliOptions.disableTelemetry ?? false;
   await testConnection();
   const transportType = TRANSPORT_TYPE;