@upstash/mcp-server 0.1.0 → 0.2.0-canary-4

package/dist/index.js

@@ -2,90 +2,29 @@
 
 // src/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { Command } from "commander";
+import { createServer } from "http";
 
-// src/init.ts
-import path from "path";
-import os from "os";
-import fs from "fs";
-import chalk from "chalk";
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/log.ts
 function log(...args) {
   const msg = `[DEBUG ${(/* @__PURE__ */ new Date()).toISOString()}] ${args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg)).join(" ")}
 `;
-  process.stderr.write(msg);
-}
-
-// src/config.ts
-var config = {
-  apiKey: "",
-  email: ""
-};
-
-// src/init.ts
-var claudeConfigPath = path.join(
-  os.homedir(),
-  "Library",
-  "Application Support",
-  "Claude",
-  "claude_desktop_config.json"
-);
-var UPSTASH_MCP_KEY = "upstash";
-async function init({ executablePath }) {
-  const isLocal = executablePath.includes("dist/index.js");
-  const upstashConfig = isLocal ? {
-    command: "node",
-    args: [executablePath, "run", config.email, config.apiKey]
-  } : {
-    command: "npx",
-    args: ["-y", "@upstash/mcp-server", "run", config.email, config.apiKey]
-  };
-  const configDir = path.dirname(claudeConfigPath);
-  if (!fs.existsSync(configDir)) {
-    log(chalk.blue("Creating Claude config directory..."));
-    fs.mkdirSync(configDir, { recursive: true });
-  }
-  const existingConfig = fs.existsSync(claudeConfigPath) ? JSON.parse(fs.readFileSync(claudeConfigPath, "utf8")) : { mcpServers: {} };
-  if (UPSTASH_MCP_KEY in ((existingConfig == null ? void 0 : existingConfig.mcpServers) || {})) {
-    log(chalk.yellow("Upstash entry already exists. Overriding it."));
-  }
-  if (isLocal) {
-    log(
-      chalk.yellow(
-        "Local executable detected. Using 'node' and absolute path instead of 'npx' for development."
-      )
-    );
+  for (const [, logs] of logsStore.entries()) {
+    logs.push(msg);
   }
-  const newConfig = {
-    ...existingConfig,
-    mcpServers: {
-      ...existingConfig.mcpServers,
-      [UPSTASH_MCP_KEY]: upstashConfig
-    }
-  };
-  fs.writeFileSync(claudeConfigPath, JSON.stringify(newConfig, null, 2));
-  log(
-    chalk.blue(
-      "\n" + JSON.stringify(
-        {
-          [UPSTASH_MCP_KEY]: upstashConfig
-        },
-        null,
-        2
-      ).replaceAll(config.apiKey, "********")
-    )
-  );
-  log(chalk.green(`Config written to: "${claudeConfigPath.replace(os.homedir(), "~")}"`));
+  process.stderr.write(msg);
 }
-
-// src/server.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var logsStore = /* @__PURE__ */ new Map();
 
 // src/tools/utils.ts
 import { z } from "zod";
 var utilTools = {
-  timestamps_to_date: tool({
+  util_timestamps_to_date: tool({
     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")
@@ -93,29 +32,54 @@ var utilTools = {
     handler: async ({ timestamps }) => {
       return timestamps.map((timestamp) => new Date(timestamp).toUTCString());
     }
+  }),
+  util_dates_to_timestamps: tool({
+    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")
+    }),
+    handler: async ({ dates }) => {
+      return dates.map((date) => new Date(date).getTime()).join(",");
+    }
   })
 };
 
 // src/tools/redis/backup.ts
 import { z as z2 } from "zod";
 
+// src/config.ts
+var config = {
+  apiKey: "",
+  email: ""
+};
+
 // src/middlewares.ts
-var formatCreationTime = (obj) => {
-  if (obj && typeof obj === "object" && "creation_time" in obj && typeof obj.creation_time === "number" && obj.creation_time > 0) {
-    obj.creation_time = new Date(obj.creation_time * 1e3).toLocaleString();
+var formatTimestamps = (obj) => {
+  if (!obj || typeof obj !== "object") {
+    return;
+  }
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      formatTimestamps(item);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const shouldFormat = typeof value === "number" && (key === "creationTime" || key === "creation_time" || key === "time" || key.toLowerCase().includes("createdat"));
+    if (shouldFormat && typeof value === "number" && value > 0) {
+      const timestamp = value > 1e12 ? value : value * 1e3;
+      const formatted = new Date(timestamp).toLocaleString("en-US", { timeZoneName: "short" });
+      obj[key] = `${formatted} (${value})`;
+    } else if (value && typeof value === "object") {
+      formatTimestamps(value);
+    }
   }
 };
 var middlewares = [
-  // Middleware to format creation_time field to human readable format
+  // Middleware to format timestamp fields to human readable format
   async (req, next) => {
     const res = await next();
-    if (Array.isArray(res)) {
-      for (const element of res) {
-        formatCreationTime(element);
-      }
-    } else {
-      formatCreationTime(res);
-    }
+    formatTimestamps(res);
     return res;
   }
 ];
@@ -133,18 +97,22 @@ import fetch from "node-fetch";
 var HttpClient = class {
   constructor(config2) {
     this.baseUrl = config2.baseUrl.replace(/\/$/, "");
+    this.qstashToken = config2.qstashToken;
+  }
+  async get(path, query) {
+    return this.requestWithMiddleware({ method: "GET", path, query });
   }
-  async get(path2) {
-    return this.requestWithMiddleware({ method: "GET", path: path2 });
+  async post(path, body, headers) {
+    return this.requestWithMiddleware({ method: "POST", path, body, headers });
   }
-  async post(path2, body) {
-    return this.requestWithMiddleware({ method: "POST", path: path2, body });
+  async put(path, body, headers) {
+    return this.requestWithMiddleware({ method: "PUT", path, body, headers });
   }
-  async patch(path2, body) {
-    return this.requestWithMiddleware({ method: "PATCH", path: path2, body });
+  async patch(path, body) {
+    return this.requestWithMiddleware({ method: "PATCH", path, body });
   }
-  async delete(path2) {
-    return this.requestWithMiddleware({ method: "DELETE", path: path2 });
+  async delete(path, body) {
+    return this.requestWithMiddleware({ method: "DELETE", path, body });
   }
   async requestWithMiddleware(req) {
     const res = await applyMiddlewares(req, async (req2) => {
@@ -158,70 +126,131 @@ var HttpClient = class {
     } else if (typeof req.path === "string") {
       req.path = [req.path];
     }
-    const url = [this.baseUrl, ...req.path].join("/");
-    const token = [config.email, config.apiKey].join(":");
-    const init2 = {
+    let url = [this.baseUrl, ...req.path].join("/");
+    if (req.query) {
+      const queryPairs = [];
+      for (const [key, value] of Object.entries(req.query)) {
+        if (value !== void 0 && value !== null && typeof value !== "object") {
+          queryPairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        }
+      }
+      if (queryPairs.length > 0) {
+        url += `?${queryPairs.join("&")}`;
+      }
+    }
+    const qstashToken = req.qstashToken || this.qstashToken;
+    let authHeader;
+    if (qstashToken) {
+      authHeader = `Bearer ${qstashToken}`;
+    } else {
+      const token = [config.email, config.apiKey].join(":");
+      authHeader = `Basic ${Buffer.from(token).toString("base64")}`;
+    }
+    const init = {
       method: req.method,
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Basic ${Buffer.from(token).toString("base64")}`
+        Authorization: authHeader,
+        ...req.headers
       }
     };
-    if (req.method !== "GET") {
-      init2.body = JSON.stringify(req.body);
+    if (req.method !== "GET" && req.body !== void 0) {
+      init.body = JSON.stringify(req.body);
     }
-    log("Sending request", {
+    log("-> sending request", {
       url,
-      ...init2,
-      headers: { ...init2.headers, Authorization: "***" }
+      ...init,
+      headers: {
+        ...init.headers
+        // , Authorization: "***"
+      }
     });
-    const res = await fetch(url, init2);
+    const res = await fetch(url, init);
     if (!res.ok) {
       throw new Error(`Request failed (${res.status} ${res.statusText}): ${await res.text()}`);
     }
-    return await res.json();
+    const text = await res.text();
+    if (!text) {
+      return {};
+    }
+    const result = safeParseJson(text);
+    if (result) {
+      log("<- received response", json(result));
+    } else {
+      log("<- received text response", text);
+    }
+    return result || text;
+  }
+};
+var safeParseJson = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
   }
 };
 var http = new HttpClient({ baseUrl: "https://api.upstash.com" });
+function createQStashClient({ url, token }) {
+  return new HttpClient({
+    baseUrl: url ?? "https://qstash.upstash.io",
+    qstashToken: token
+  });
+}
 
 // src/tools/redis/backup.ts
 var redisBackupTools = {
-  redis_database_create_backup: tool({
-    description: `Create a backup of a specific Upstash redis database.
-NOTE: Ask user to choose a name for the backup`,
-    inputSchema: z2.object({
-      database_id: z2.string().describe("The ID of the database to create a backup for."),
-      backup_name: z2.string().describe("A name for the backup.")
-    }),
-    handler: async ({ database_id, backup_name }) => {
-      await http.post(["v2/redis/create-backup", database_id], {
-        name: backup_name
-      });
-      return "OK";
-    }
-  }),
-  redis_database_delete_backup: tool({
-    description: `Delete a backup of a specific Upstash redis database.`,
-    inputSchema: z2.object({
-      database_id: z2.string().describe("The ID of the database to delete a backup from."),
-      backup_id: z2.string().describe("The ID of the backup to delete.")
-    }),
-    handler: async ({ database_id, backup_id }) => {
-      await http.delete(["v2/redis/delete-backup", database_id, backup_id]);
-      return "OK";
-    }
-  }),
-  redis_database_restore_backup: tool({
-    description: `Restore a backup of a specific Upstash redis database. A backup can only be restored to the same database it was created from.`,
+  redis_database_manage_backup: tool({
+    description: `Create, delete, or restore backups for a specific Upstash redis database. This tool handles all backup operations in one unified interface.`,
     inputSchema: z2.object({
-      database_id: z2.string().describe("The ID of the database to restore a backup to."),
-      backup_id: z2.string().describe("The ID of the backup to restore.")
-    }),
-    handler: async ({ database_id, backup_id }) => {
-      await http.post(["v2/redis/restore-backup", database_id], {
-        backup_id
-      });
-      return "OK";
+      database_id: z2.string().describe("The ID of the database to manage backups for."),
+      operation: z2.union([z2.literal("create"), z2.literal("delete"), z2.literal("restore")]).describe("The backup operation to perform: create, delete, or restore."),
+      backup_name: z2.string().optional().describe("Name for the backup (required for create operation)."),
+      backup_id: z2.string().optional().describe("ID of the backup (required for delete and restore operations).")
+    }).refine(
+      (data) => {
+        if (data.operation === "create" && !data.backup_name) {
+          return false;
+        }
+        if ((data.operation === "delete" || data.operation === "restore") && !data.backup_id) {
+          return false;
+        }
+        return true;
+      },
+      {
+        message: "backup_name is required for create operation, backup_id is required for delete and restore operations"
+      }
+    ),
+    handler: async ({ database_id, operation, backup_name, backup_id }) => {
+      switch (operation) {
+        case "create": {
+          if (!backup_name) {
+            throw new Error("backup_name is required for create operation");
+          }
+          await http.post(["v2/redis/create-backup", database_id], {
+            name: backup_name
+          });
+          return `Backup "${backup_name}" created successfully for database ${database_id}.`;
+        }
+        case "delete": {
+          if (!backup_id) {
+            throw new Error("backup_id is required for delete operation");
+          }
+          await http.delete(["v2/redis/delete-backup", database_id, backup_id]);
+          return `Backup ${backup_id} deleted successfully from database ${database_id}.`;
+        }
+        case "restore": {
+          if (!backup_id) {
+            throw new Error("backup_id is required for restore operation");
+          }
+          await http.post(["v2/redis/restore-backup", database_id], {
+            backup_id
+          });
+          return `Backup ${backup_id} restored successfully to database ${database_id}.`;
+        }
+        default: {
+          throw new Error(`Invalid operation: ${operation}. Use create, delete, or restore.`);
+        }
+      }
     }
   }),
   redis_database_list_backups: tool({
@@ -256,59 +285,74 @@ NOTE: Ask user to choose a name for the backup`,
 import { z as z3 } from "zod";
 import fetch2 from "node-fetch";
 var redisCommandTools = {
-  redis_database_run_single_redis_command: tool({
-    description: `Run a single Redis command on a specific Upstash redis database.
+  redis_database_run_redis_commands: tool({
+    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]`,
+NOTE: SCAN cursor [MATCH pattern] [COUNT count] [TYPE type]
+NOTE: Multiple commands will be executed as a pipeline for better performance.`,
     inputSchema: z3.object({
-      database_rest_url: z3.string().describe("The REST URL of the database. Example: https://***.upstash.io"),
-      database_rest_token: z3.string().describe("The REST token of the database."),
-      command: z3.array(z3.string()).describe("The Redis command to run. Example: ['SET', 'foo', 'bar', 'EX', 100]")
-    }),
-    handler: async ({ database_rest_url, database_rest_token, command }) => {
-      const req = await fetch2(database_rest_url, {
+      database_id: z3.string().optional().describe("The ID of the database to run commands on."),
+      database_rest_url: z3.string().optional().describe("The REST URL of the database. Example: https://***.upstash.io"),
+      database_rest_token: z3.string().optional().describe("The REST token of the database."),
+      commands: z3.array(z3.array(z3.string())).describe(
+        "The Redis commands to run. For single command: [['SET', 'foo', 'bar']], for multiple: [['SET', 'foo', 'bar'], ['GET', 'foo']]"
+      )
+    }).refine(
+      (data) => {
+        return data.database_id || data.database_rest_url && data.database_rest_token;
+      },
+      {
+        message: "Either provide database_id OR both database_rest_url and database_rest_token"
+      }
+    ),
+    handler: async ({ database_id, database_rest_url, database_rest_token, commands }) => {
+      if (database_id && (database_rest_url || database_rest_token)) {
+        throw new Error(
+          "Either provide database_id OR both database_rest_url and database_rest_token"
+        );
+      }
+      let restUrl = database_rest_url;
+      let restToken = database_rest_token;
+      if (database_id && (!database_rest_url || !database_rest_token)) {
+        log("Fetching database details for database_id:", database_id);
+        const db = await http.get(["v2/redis/database", database_id]);
+        restUrl = db.endpoint;
+        restToken = db.rest_token;
+      }
+      if (!restUrl || !restToken) {
+        throw new Error("Could not determine REST URL and token for the database");
+      }
+      const isSingleCommand = commands.length === 1;
+      const url = isSingleCommand ? restUrl : restUrl + "/pipeline";
+      const body = isSingleCommand ? JSON.stringify(commands[0]) : JSON.stringify(commands);
+      const req = await fetch2(url, {
         method: "POST",
-        body: JSON.stringify(command),
+        body,
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${database_rest_token}`
+          Authorization: `Bearer ${restToken}`
         }
       });
-      const result = await req.json();
-      log("command result:", result);
-      if ("error" in result) {
-        throw new Error("Redis error: " + result.error);
-      }
-      const isScanCommand = command[0].toLocaleLowerCase().includes("scan");
-      const messages = [json(result)];
-      if (isScanCommand)
-        messages.push(`NOTE: Use the returned cursor to get the next set of keys.
+      if (isSingleCommand) {
+        const result = await req.json();
+        log("command result:", result);
+        if ("error" in result) {
+          throw new Error("Redis error: " + result.error);
+        }
+        const isScanCommand = commands[0][0].toLocaleLowerCase().includes("scan");
+        const messages = [json(result)];
+        if (isScanCommand)
+          messages.push(`NOTE: Use the returned cursor to get the next set of keys.
 NOTE: The result might be too large to be returned. If applicable, stop after the second SCAN command and ask the user if they want to continue.`);
-      return messages;
-    }
-  }),
-  redis_database_run_multiple_redis_commands: tool({
-    description: `Run multiple Redis commands on a specific Upstash redis database`,
-    inputSchema: z3.object({
-      database_rest_url: z3.string().describe("The REST URL of the database. Example: https://***.upstash.io"),
-      database_rest_token: z3.string().describe("The REST token of the database."),
-      commands: z3.array(z3.array(z3.string())).describe("The Redis commands to run. Example: [['SET', 'foo', 'bar'], ['GET', 'foo']]")
-    }),
-    handler: async ({ database_rest_url, database_rest_token, commands }) => {
-      const req = await fetch2(database_rest_url + "/pipeline", {
-        method: "POST",
-        body: JSON.stringify(commands),
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${database_rest_token}`
+        return messages;
+      } else {
+        const result = await req.json();
+        log("commands result:", result);
+        if (result.some((r) => "error" in r)) {
+          throw new Error("Some commands in the pipeline resulted in an error:\n" + json(result));
         }
-      });
-      const result = await req.json();
-      log("commands result:", result);
-      if (result.some((r) => "error" in r)) {
-        throw new Error("Some commands in the pipeline resulted in an error:\n" + json(result));
+        return json(result);
       }
-      return json(result);
     }
   })
 };
@@ -433,28 +477,14 @@ ${GENERIC_DATABASE_NOTES}
       return json(updatedDb);
     }
   }),
-  redis_database_get_usage_last_5_days: tool({
-    description: `Get PRECISE command count and bandwidth usage statistics of an Upstash redis database over the last 5 days. This is a precise stat, not an average.
-NOTE: Ask user first if they want to see stats for each database seperately or just for one.`,
-    inputSchema: z4.object({
-      id: z4.string().describe("The ID of your database.")
-    }),
-    handler: async ({ id }) => {
-      const stats = await http.get(["v2/redis/stats", `${id}?period=3h`]);
-      return [
-        json({
-          days: stats.days,
-          command_usage: stats.dailyrequests,
-          bandwidth_usage: stats.bandwidths
-        }),
-        `NOTE: Times are calculated according to UTC+0`
-      ];
-    }
-  }),
-  redis_database_get_stats: tool({
-    description: `Get SAMPLED usage statistics of an Upstash redis database over a period of time (1h, 3h, 12h, 1d, 3d, 7d). Use this to check for peak usages and latency problems.
-Includes: read_latency_mean, write_latency_mean, keyspace, throughput (cmds/sec), diskusage
-NOTE: If the user does not specify which stat to get, use throughput as default.`,
+  redis_database_get_statistics: tool({
+    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
+
+For sampled stats, includes: read_latency_mean, write_latency_mean, keyspace, throughput (cmds/sec), diskusage
+NOTE: If user doesn't specify stat_type, defaults to "throughput" for sampled stats.
+NOTE: Ask user first if they want to see stats for each database separately or just for one.`,
     inputSchema: z4.object({
       id: z4.string().describe("The ID of your database."),
       period: z4.union([
@@ -464,27 +494,42 @@ NOTE: If the user does not specify which stat to get, use throughput as default.
         z4.literal("1d"),
         z4.literal("3d"),
         z4.literal("7d")
-      ]).describe("The period of the stats."),
-      type: z4.union([
+      ]).describe("The period for sampled stats."),
+      stat_type: z4.union([
         z4.literal("read_latency_mean"),
         z4.literal("write_latency_mean"),
         z4.literal("keyspace").describe("Number of keys in db"),
         z4.literal("throughput").describe("commands per second (sampled), calculate area for estimated count"),
         z4.literal("diskusage").describe("Current disk usage in bytes")
-      ]).describe("The type of stat to get")
+      ]).optional().describe("The type of sampled stat to get (defaults to 'throughput')")
     }),
-    handler: async ({ id, period, type }) => {
+    handler: async ({ id, period, stat_type }) => {
+      const statType = stat_type || "throughput";
       const stats = await http.get([
         "v2/redis/stats",
         `${id}?period=${period}`
       ]);
-      const stat = stats[type];
+      const stat = stats[statType];
       if (!Array.isArray(stat))
         throw new Error(
-          `Invalid key provided: ${type}. Valid keys are: ${Object.keys(stats).join(", ")}`
+          `Invalid stat_type provided: ${statType}. Valid keys are: ${Object.keys(stats).join(", ")}`
         );
       return [
-        JSON.stringify(parseUsageData(stat)),
+        json({
+          // 5-day precise usage stats
+          usage_last_5_days: {
+            days: stats.days,
+            command_usage: stats.dailyrequests,
+            bandwidth_usage: stats.bandwidths
+          },
+          // Sampled stats for the specified period and type
+          sampled_stats: {
+            period,
+            stat_type: statType,
+            data: parseUsageData(stat)
+          }
+        }),
+        `NOTE: Times are calculated according to UTC+0`,
         `NOTE: Use the timestamps_to_date tool to parse timestamps if needed`,
         `NOTE: Don't try to plot multiple stats in the same chart`
       ];
@@ -514,21 +559,536 @@ var redisTools = {
   ...utilTools
 };
 
+// src/tools/qstash/qstash.ts
+import { z as z5 } from "zod";
+
+// src/tools/qstash/utils.ts
+var cachedToken = null;
+var tokenExpiry = 0;
+async function getQStashToken() {
+  const now = Date.now();
+  if (cachedToken && now < tokenExpiry) {
+    return cachedToken;
+  }
+  try {
+    const user = await http.get("qstash/user");
+    cachedToken = user.token;
+    tokenExpiry = now + 60 * 60 * 1e3;
+    return user.token;
+  } catch (error) {
+    throw new Error(
+      `Failed to get QStash token: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function createQStashClientWithToken(creds = {}) {
+  if (!(creds == null ? void 0 : creds.token)) {
+    creds.token = await getQStashToken();
+  }
+  return createQStashClient({
+    url: creds == null ? void 0 : creds.url,
+    token: creds == null ? void 0 : creds.token
+  });
+}
+
+// src/tools/qstash/qstash.ts
+var qstashCreds = {
+  qstash_creds: z5.undefined()
+  // qstash_creds: z
+  //   .object({
+  //     url: z.string(),
+  //     token: z.string(),
+  //   })
+  //   .optional()
+  //   .describe(
+  //     "Optional qstash credentials. Use for local qstash connections and external qstash deployments"
+  //   ),
+};
+var qstashTools = {
+  qstash_get_user_token: tool({
+    description: `Get the QSTASH_TOKEN and QSTASH_URL of the current user. This
+    is not needed for the mcp tools since the token is automatically fetched from
+    the Upstash API for them.`,
+    handler: async () => {
+      const user = await http.get("qstash/user");
+      return [json(user)];
+    }
+  }),
+  qstash_publish_message: tool({
+    description: `Publish a message to a destination URL using QStash. This
+    sends an HTTP request to the specified destination via QStash's message
+    queue. This can also be used to trigger a upstash workflow run.`,
+    inputSchema: z5.object({
+      destination: z5.string().describe("The destination URL to send the message to (e.g., 'https://example.com')"),
+      body: z5.string().optional().describe("Request body (JSON string or plain text)"),
+      method: z5.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().describe("HTTP method (optional, defaults to POST)").default("POST"),
+      delay: z5.string().optional().describe("Delay before message delivery (e.g., '10s', '5m', '1h')"),
+      retries: z5.number().optional().describe("Number of retries on failure, default is 3"),
+      callback: z5.string().optional().describe("Callback URL that will be called when the message is successfully delivered"),
+      failureCallback: z5.string().optional().describe("Callback URL that will be called when the message is failed to deliver"),
+      timeout: z5.string().optional().describe("Request timeout (e.g., '30s', '1h')"),
+      queueName: z5.string().optional().describe(
+        "Queue name to use, you have to first create the queue in upstash. Prefer the flow control key instead"
+      ),
+      flow_control: z5.object({
+        key: z5.string().describe("Unique identifier for grouping messages under same flow control rules"),
+        parallelism: z5.number().optional().describe("Max concurrent active calls (default: unlimited)"),
+        rate: z5.number().optional().describe("Max calls per period (default: unlimited)"),
+        period: z5.string().optional().describe("Time window for rate limit (e.g., '1s', '1m', '1h', default: '1s')")
+      }).optional().describe("Flow control for rate limiting and parallelism management"),
+      extraHeaders: z5.record(z5.string()).optional().describe("Extra headers to add to the request"),
+      ...qstashCreds
+    }),
+    handler: async ({
+      destination,
+      body,
+      method,
+      extraHeaders,
+      delay,
+      retries,
+      callback,
+      failureCallback,
+      timeout,
+      queueName,
+      flow_control,
+      qstash_creds
+    }) => {
+      const client = await createQStashClientWithToken(qstash_creds);
+      const requestHeaders = {};
+      if (method) {
+        requestHeaders["Upstash-Method"] = method;
+      }
+      if (delay) {
+        requestHeaders["Upstash-Delay"] = delay;
+      }
+      if (retries !== void 0) {
+        requestHeaders["Upstash-Retries"] = retries.toString();
+      }
+      if (callback) {
+        requestHeaders["Upstash-Callback"] = callback;
+      }
+      if (failureCallback) {
+        requestHeaders["Upstash-Failure-Callback"] = failureCallback;
+      }
+      if (timeout) {
+        requestHeaders["Upstash-Timeout"] = timeout;
+      }
+      if (queueName) {
+        requestHeaders["Upstash-Queue-Name"] = queueName;
+      }
+      if (flow_control) {
+        requestHeaders["Upstash-Flow-Control-Key"] = flow_control.key;
+        const value = [
+          flow_control.parallelism === void 0 ? void 0 : `parallelism=${flow_control.parallelism}`,
+          flow_control.rate === void 0 ? void 0 : `rate=${flow_control.rate}`,
+          flow_control.period === void 0 ? void 0 : `period=${flow_control.period}`
+        ].filter(Boolean).join(",");
+        requestHeaders["Upstash-Flow-Control-Value"] = value;
+      }
+      if (extraHeaders) {
+        for (const [key, value] of Object.entries(extraHeaders)) {
+          requestHeaders[key] = value;
+        }
+      }
+      const response = await client.post(
+        `v2/publish/${destination}`,
+        body || {},
+        requestHeaders
+      );
+      return [
+        "Message published successfully",
+        `Message ID: ${response.messageId}`,
+        json(response)
+      ];
+    }
+  }),
+  qstash_logs_list: tool({
+    description: `List QStash logs with optional filtering. Returns a paginated list of message logs without their bodies.`,
+    inputSchema: z5.object({
+      cursor: z5.string().optional().describe("Cursor for pagination"),
+      messageId: z5.string().optional().describe("Filter logs by message ID"),
+      state: z5.enum([
+        "CREATED",
+        "ACTIVE",
+        "RETRY",
+        "ERROR",
+        "IN_PROGRESS",
+        "DELIVERED",
+        "FAILED",
+        "CANCEL_REQUESTED",
+        "CANCELLED"
+      ]).optional().describe("Filter logs by state"),
+      url: z5.string().optional().describe("Filter logs by URL"),
+      topicName: z5.string().optional().describe("Filter logs by topic name"),
+      scheduleId: z5.string().optional().describe("Filter logs by schedule ID"),
+      queueName: z5.string().optional().describe("Filter logs by queue name"),
+      fromDate: z5.number().optional().describe("Filter logs from date (Unix timestamp in milliseconds)"),
+      toDate: z5.number().optional().describe("Filter logs to date (Unix timestamp in milliseconds)"),
+      count: z5.number().max(1e3).optional().describe("Number of logs to return (max 1000)"),
+      ...qstashCreds
+    }),
+    handler: async (params) => {
+      const client = await createQStashClientWithToken(params.qstash_creds);
+      const response = await client.get("v2/logs", {
+        trimBody: 0,
+        groupBy: "messageId",
+        ...params
+      });
+      const firstMessageFields = Object.fromEntries(
+        Object.entries(response.messages[0] ?? {}).filter(
+          ([key, _value]) => !key.toLocaleLowerCase().includes("headers")
+        )
+      );
+      const cleanedEvents = response.messages.map((message) => ({
+        messageId: message.messageId,
+        events: message.events.map((event) => ({
+          state: event.state,
+          time: event.time
+        }))
+      }));
+      return [
+        `Found ${response.messages.length} log entries`,
+        response.cursor ? `Pagination cursor: ${response.cursor}` : "No more entries",
+        json({ ...firstMessageFields, events: cleanedEvents })
+      ];
+    }
+  }),
+  qstash_logs_get: tool({
+    description: `Get details of a single QStash log item by message ID without trimming the body.`,
+    inputSchema: z5.object({
+      messageId: z5.string().describe("The message ID to get details for"),
+      ...qstashCreds
+    }),
+    handler: async ({ messageId, qstash_creds }) => {
+      const client = await createQStashClientWithToken(qstash_creds);
+      const response = await client.get("v2/logs", { messageId });
+      if (response.messages.length === 0) {
+        return "No log entry found for the specified message ID";
+      }
+      const logEntry = response.messages[0];
+      return [`Log details for message ID: ${messageId}`, json(logEntry)];
+    }
+  }),
+  qstash_dlq_list: tool({
+    description: `List messages in the QStash Dead Letter Queue (DLQ) with optional filtering.`,
+    inputSchema: z5.object({
+      cursor: z5.string().optional().describe("Cursor for pagination"),
+      messageId: z5.string().optional().describe("Filter DLQ messages by message ID"),
+      url: z5.string().optional().describe("Filter DLQ messages by URL"),
+      topicName: z5.string().optional().describe("Filter DLQ messages by topic name"),
+      scheduleId: z5.string().optional().describe("Filter DLQ messages by schedule ID"),
+      queueName: z5.string().optional().describe("Filter DLQ messages by queue name"),
+      fromDate: z5.number().optional().describe("Filter from date (Unix timestamp in milliseconds)"),
+      toDate: z5.number().optional().describe("Filter to date (Unix timestamp in milliseconds)"),
+      responseStatus: z5.number().optional().describe("Filter by HTTP response status code"),
+      callerIp: z5.string().optional().describe("Filter by IP address of the publisher"),
+      count: z5.number().max(100).optional().describe("Number of messages to return (max 100)"),
+      ...qstashCreds
+    }),
+    handler: async (params) => {
+      const client = await createQStashClientWithToken(params.qstash_creds);
+      const response = await client.get("v2/dlq", {
+        trimBody: 0,
+        ...params
+      });
+      return [
+        `Found ${response.messages.length} DLQ messages`,
+        response.cursor ? `Pagination cursor: ${response.cursor}` : "No more entries",
+        json(response.messages)
+      ];
+    }
+  }),
+  qstash_dlq_get: tool({
+    description: `Get details of a single DLQ message by DLQ ID.`,
+    inputSchema: z5.object({
+      dlqId: z5.string().describe("The DLQ ID of the message to retrieve"),
+      ...qstashCreds
+    }),
+    handler: async ({ dlqId, qstash_creds }) => {
+      const client = await createQStashClientWithToken(qstash_creds);
+      const message = await client.get(`v2/dlq/${dlqId}`);
+      return [`DLQ message details for ID: ${dlqId}`, json(message)];
+    }
+  }),
+  qstash_schedules_list: tool({
+    description: `List all QStash schedules.`,
+    handler: async ({ qstash_creds }) => {
+      const client = await createQStashClientWithToken(qstash_creds);
+      const schedules = await client.get("v2/schedules");
+      return [`Found ${schedules.length} schedules`, json(schedules)];
+    }
+  }),
+  qstash_schedules_manage: tool({
+    description: `Create, update, or manage QStash schedules. This tool handles create, update (by providing scheduleId), pause, resume, and delete operations in one unified interface.`,
+    inputSchema: z5.object({
+      operation: z5.enum(["create", "update", "pause", "resume", "delete"]).describe("The operation to perform"),
+      scheduleId: z5.string().optional().describe("Schedule ID (required for update, pause, resume, delete operations)"),
+      destination: z5.string().optional().describe("Destination URL or topic name (required for create/update)"),
+      cron: z5.string().optional().describe("Cron expression (required for create/update)"),
+      method: z5.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().describe("HTTP method (optional, defaults to POST)"),
+      headers: z5.record(z5.string()).optional().describe("Request headers as key-value pairs"),
+      body: z5.string().optional().describe("Request body"),
+      delay: z5.string().optional().describe("Delay before message delivery (e.g., '10s', '5m', '1h')"),
+      retries: z5.number().optional().describe("Number of retries on failure"),
+      callback: z5.string().optional().describe("Callback URL for successful delivery"),
+      failureCallback: z5.string().optional().describe("Callback URL for failed delivery"),
+      timeout: z5.string().optional().describe("Request timeout (e.g., '30s')"),
+      queueName: z5.string().optional().describe("Queue name to use"),
+      ...qstashCreds
+    }),
+    handler: async ({
+      operation,
+      scheduleId,
+      destination,
+      cron,
+      method = "POST",
+      headers,
+      body,
+      delay,
+      retries,
+      callback,
+      failureCallback,
+      timeout,
+      queueName,
+      qstash_creds
+    }) => {
+      const client = await createQStashClientWithToken(qstash_creds);
+      switch (operation) {
+        case "create":
+        case "update": {
+          if (!destination || !cron) {
+            throw new Error("destination and cron are required for create/update operations");
+          }
+          const requestHeaders = {
+            "Upstash-Cron": cron
+          };
+          if (method !== "POST") {
+            requestHeaders["Upstash-Method"] = method;
+          }
+          if (delay) {
+            requestHeaders["Upstash-Delay"] = delay;
+          }
+          if (retries !== void 0) {
+            requestHeaders["Upstash-Retries"] = retries.toString();
+          }
+          if (callback) {
+            requestHeaders["Upstash-Callback"] = callback;
+          }
+          if (failureCallback) {
+            requestHeaders["Upstash-Failure-Callback"] = failureCallback;
+          }
+          if (timeout) {
+            requestHeaders["Upstash-Timeout"] = timeout;
+          }
+          if (queueName) {
+            requestHeaders["Upstash-Queue-Name"] = queueName;
+          }
+          if (scheduleId && operation === "update") {
+            requestHeaders["Upstash-Schedule-Id"] = scheduleId;
+          }
+          if (headers) {
+            for (const [key, value] of Object.entries(headers)) {
+              requestHeaders[key] = value;
+            }
+          }
+          const response = await client.post(
+            `v2/schedules/${destination}`,
+            body || {},
+            requestHeaders
+          );
+          return [
+            operation === "create" ? "Schedule created successfully" : "Schedule updated successfully",
+            `Schedule ID: ${response.scheduleId}`,
+            json(response)
+          ];
+        }
+        case "pause": {
+          if (!scheduleId) {
+            throw new Error("scheduleId is required for pause operation");
+          }
+          await client.post(`v2/schedules/${scheduleId}/pause`);
+          return `Schedule ${scheduleId} paused successfully`;
+        }
+        case "resume": {
+          if (!scheduleId) {
+            throw new Error("scheduleId is required for resume operation");
+          }
+          await client.post(`v2/schedules/${scheduleId}/resume`);
+          return `Schedule ${scheduleId} resumed successfully`;
+        }
+        case "delete": {
+          if (!scheduleId) {
+            throw new Error("scheduleId is required for delete operation");
+          }
+          await client.delete(`v2/schedules/${scheduleId}`);
+          return `Schedule ${scheduleId} deleted successfully`;
+        }
+        default: {
+          throw new Error(`Unknown operation: ${operation}`);
+        }
+      }
+    }
+  })
+};
+
+// src/tools/qstash/workflow.ts
+import { z as z6 } from "zod";
+var workflowTools = {
+  workflow_logs_list: tool({
+    description: `List Upstash Workflow logs with optional filtering. Returns grouped workflow runs with their execution details.`,
+    inputSchema: z6.object({
+      cursor: z6.string().optional().describe("Cursor for pagination"),
+      workflowRunId: z6.string().optional().describe("Filter by specific workflow run ID"),
+      count: z6.number().optional().describe("Number of workflow runs to return"),
+      state: z6.enum(["RUN_STARTED", "RUN_SUCCESS", "RUN_FAILED", "RUN_CANCELED"]).optional().describe("Filter by workflow state"),
+      workflowUrl: z6.string().optional().describe("Filter by workflow URL (exact match)"),
+      workflowCreatedAt: z6.number().optional().describe("Filter by workflow creation timestamp (Unix timestamp)"),
+      ...qstashCreds
+    }),
+    handler: async (params) => {
+      const client = await createQStashClientWithToken(params.qstash_creds);
+      const response = await client.get("v2/workflows/events", {
+        trimBody: 0,
+        groupBy: "workflowRunId",
+        ...params
+      });
+      const cleaned = response.runs.map(
+        (run) => Object.fromEntries(Object.entries(run).filter(([key, _value]) => key !== "steps"))
+      );
+      return [
+        `Found ${response.runs.length} workflow runs`,
+        response.cursor ? `Pagination cursor: ${response.cursor}` : "No more entries",
+        json({
+          ...response,
+          runs: cleaned
+        })
+      ];
+    }
+  }),
+  workflow_logs_get: tool({
+    description: `Get details of a single workflow run by workflow run ID. There
+    could be multiple workflow runs with the same workflow run ID, so you can
+    use the workflowCreatedAt to get the details of the specific workflow run.`,
+    inputSchema: z6.object({
+      workflowRunId: z6.string().describe("The workflow run ID to get details for"),
+      workflowCreatedAt: z6.number().optional().describe("The workflow creation timestamp (Unix timestamp)"),
+      ...qstashCreds
+    }),
+    handler: async (params) => {
+      const client = await createQStashClientWithToken(params.qstash_creds);
+      const response = await client.get("v2/workflows/logs", {
+        ...params
+      });
+      if (response.runs.length === 0) {
+        return "No workflow run found";
+      }
+      const workflowRun = response.runs[0];
+      return [
+        `Workflow run details for ID: ${params.workflowRunId} created at: ${params.workflowCreatedAt}`,
+        json(workflowRun)
+      ];
+    }
+  }),
+  workflow_dlq_list: tool({
+    description: `List failed workflow runs in the Dead Letter Queue (DLQ) with optional filtering.`,
+    inputSchema: z6.object({
+      cursor: z6.string().optional().describe("Cursor for pagination"),
+      workflowRunId: z6.string().optional().describe("Filter by workflow run ID"),
+      workflowUrl: z6.string().optional().describe("Filter by workflow URL"),
+      fromDate: z6.number().optional().describe("Filter from date (Unix timestamp in milliseconds)"),
+      toDate: z6.number().optional().describe("Filter to date (Unix timestamp in milliseconds)"),
+      responseStatus: z6.number().optional().describe("Filter by HTTP response status code"),
+      callerIP: z6.string().optional().describe("Filter by IP address of the caller"),
+      failureCallbackState: z6.string().optional().describe("Filter by failure callback state"),
+      count: z6.number().optional().describe("Number of DLQ messages to return"),
+      ...qstashCreds
+    }),
+    handler: async (params) => {
+      const client = await createQStashClientWithToken(params.qstash_creds);
+      const response = await client.get("v2/workflows/dlq", {
+        ...params,
+        trimBody: 0
+      });
+      const cleaned = response.messages.map(
+        (message) => Object.fromEntries(Object.entries(message).filter(([key]) => !key.includes("header")))
+      );
+      return [
+        `Found ${response.messages.length} failed workflow runs in DLQ`,
+        response.cursor ? `Pagination cursor: ${response.cursor}` : "No more entries",
+        json({
+          ...response,
+          messages: cleaned
+        })
+      ];
+    }
+  }),
+  workflow_dlq_get: tool({
+    description: `Get details of a single failed workflow run from the DLQ by DLQ ID.`,
+    inputSchema: z6.object({
+      dlqId: z6.string().describe("The DLQ ID of the failed workflow run to retrieve"),
+      ...qstashCreds
+    }),
+    handler: async (params) => {
+      const client = await createQStashClientWithToken(params.qstash_creds);
+      const message = await client.get(`v2/workflows/dlq/${params.dlqId}`);
+      return [`Failed workflow run details for DLQ ID: ${params.dlqId}`, json(message)];
+    }
+  }),
+  workflow_dlq_manage: tool({
+    description: `Delete, restart, and resume failed workflow runs in the DLQ using only the DLQ ID.`,
+    inputSchema: z6.object({
+      dlqId: z6.string().describe("The DLQ ID of the failed workflow run"),
+      action: z6.enum(["delete", "restart", "resume"]).describe(
+        "The action to perform: delete (remove from DLQ), restart (from beginning), or resume (from the failed step)"
+      ),
+      ...qstashCreds
+    }),
+    handler: async ({ dlqId, action, qstash_creds }) => {
+      const client = await createQStashClientWithToken(qstash_creds);
+      switch (action) {
+        case "delete": {
+          await client.delete(`v2/workflows/dlq/delete/${dlqId}`);
+          return `Failed workflow run with DLQ ID ${dlqId} deleted successfully`;
+        }
+        case "restart": {
+          const restartResponse = await client.post(`v2/workflows/dlq/restart/${dlqId}`);
+          return [
+            `Workflow run restarted successfully from DLQ ID: ${dlqId}`,
+            json(restartResponse)
+          ];
+        }
+        case "resume": {
+          const resumeResponse = await client.post(`v2/workflows/dlq/resume/${dlqId}`);
+          return [`Workflow run resumed successfully from DLQ ID: ${dlqId}`, json(resumeResponse)];
+        }
+        default: {
+          throw new Error(
+            `Invalid action: ${action}. Supported actions are: delete, restart, resume`
+          );
+        }
+      }
+    }
+  })
+};
+
+// src/tools/qstash/index.ts
+var qstashAllTools = {
+  ...qstashTools,
+  ...workflowTools
+};
+
 // src/tools/index.ts
 var json = (json2) => typeof json2 === "string" ? json2 : JSON.stringify(json2, null, 2);
 var tools = {
-  ...redisTools
+  ...redisTools,
+  ...qstashAllTools
 };
 function tool(tool2) {
   return tool2;
 }
 
-// src/tool.ts
-import { z as z5 } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-
 // src/settings.ts
-var MAX_MESSAGE_LENGTH = 8e3;
+var MAX_MESSAGE_LENGTH = 3e4;
 
 // src/tool.ts
 function handlerResponseToCallResult(response) {
@@ -542,66 +1102,67 @@ function handlerResponseToCallResult(response) {
     };
   } else return response;
 }
-function convertToJsonSchema(schema) {
-  const jsonSchema = zodToJsonSchema(schema);
-  delete jsonSchema.$schema;
-  const removeAdditionalProperties = (schema2) => {
-    if (schema2.type !== "object") return;
-    delete schema2.additionalProperties;
-    for (const value of Object.values(schema2.properties)) {
-      removeAdditionalProperties(value);
+
+// src/server.ts
+import z7 from "zod";
+function createServerInstance() {
+  const server = new McpServer(
+    { name: "upstash", version: "0.1.0" },
+    {
+      capabilities: {
+        tools: {},
+        logging: {}
+      }
     }
-  };
-  removeAdditionalProperties(jsonSchema);
-  return jsonSchema;
-}
-function convertToTools(tools2) {
-  return Object.entries(tools2).map(([name, tool2]) => ({
+  );
+  const toolsList = Object.entries(tools).map(([name, tool2]) => ({
     name,
     description: tool2.description,
-    inputSchema: convertToJsonSchema(tool2.inputSchema ?? z5.object({}))
+    inputSchema: tool2.inputSchema,
+    tool: tool2
   }));
-}
-
-// src/server.ts
-var server = new Server(
-  { name: "upstash", version: "0.1.0" },
-  { capabilities: { tools: {} } }
-);
-var toolsList = convertToTools(tools);
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  log("Received list tools request", toolsList);
-  return { tools: toolsList };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const toolName = request.params.name;
-  log("< received tool call:", toolName, request.params.arguments);
-  try {
-    if (toolName in tools) {
-      const tool2 = tools[toolName];
-      const result = await tool2.handler(request.params.arguments);
-      const response = handlerResponseToCallResult(result);
-      log("> tool result:", response.content.map((item) => item.text).join("\n"));
-      return response;
-    }
-    throw new Error(`Unknown tool: ${toolName}`);
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    log("> error in tool call:", msg);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${msg}`
+  for (const toolDef of toolsList) {
+    const toolName = toolDef.name;
+    const tool2 = toolDef.tool;
+    server.registerTool(
+      toolName,
+      {
+        description: tool2.description,
+        inputSchema: (tool2.inputSchema ?? z7.object({})).shape
+      },
+      // @ts-expect-error - Just ignore the types here
+      async (args) => {
+        log("< received tool call:", toolName, args);
+        try {
+          const result = await tool2.handler(args);
+          const response = handlerResponseToCallResult(result);
+          log("> tool result:", response.content.map((item) => item.text).join("\n"));
+          return response;
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          log("> error in tool call:", msg);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${error instanceof Error ? error.name : "Error"}: ${msg}`
+              },
+              ...DEBUG ? [
+                {
+                  type: "text",
+                  text: `
+Stack trace: ${error instanceof Error ? error.stack : "No stack trace available"}`
+                }
+              ] : []
+            ],
+            isError: true
+          };
         }
-      ],
-      isError: true
-    };
+      }
+    );
   }
-});
-
-// src/index.ts
-import "dotenv/config";
+  return server;
+}
 
 // src/test-connection.ts
 async function testConnection() {
@@ -613,57 +1174,155 @@ async function testConnection() {
 }
 
 // src/index.ts
-process.on("uncaughtException", (error) => {
-  log("Uncaught exception:", error.name, error.message, error.stack);
-});
-process.on("unhandledRejection", (error) => {
-  if (error instanceof Error) log("Unhandled rejection:", error.name, error.message, error.stack);
-  else log("Unhandled rejection:", error);
-});
-var envApiKey = process.env.UPSTASH_API_KEY;
-var envEmail = process.env.UPSTASH_EMAIL;
-var USAGE_GENERAL = `Usage: npx @upstash/mcp-server (init|run) <UPSTASH_EMAIL> <UPSTASH_API_KEY>`;
-var USAGE_RUN = `Usage: npx @upstash/mcp-server run <UPSTASH_EMAIL> <UPSTASH_API_KEY>`;
-var USAGE_INIT = `Usage: npx @upstash/mcp-server init <UPSTASH_EMAIL> <UPSTASH_API_KEY>`;
-async function parseArguments() {
-  const [cmd, ...args] = process.argv.slice(2);
-  if (!cmd) throw new Error(USAGE_GENERAL);
-  else if (cmd === "init") {
-    const [email, apiKey, ...rest] = args;
-    const finalApiKey = apiKey || envApiKey;
-    const finalEmail = email || envEmail;
-    if (rest.length > 0) throw new Error(`Too many arguments. ${USAGE_INIT}`);
-    if (!finalApiKey) throw new Error(`Missing API key. ${USAGE_INIT}`);
-    if (!finalEmail) throw new Error(`Missing email. ${USAGE_INIT}`);
-    config.apiKey = finalApiKey;
-    config.email = finalEmail;
-    await testConnection();
-    await init({
-      executablePath: process.argv[1]
-    });
-  } else if (cmd === "run") {
-    const [email, apiKey, ...rest] = args;
-    const finalApiKey = apiKey || envApiKey;
-    const finalEmail = email || envEmail;
-    if (!finalApiKey) throw new Error(`Missing API key. ${USAGE_RUN}`);
-    if (!finalEmail) throw new Error(`Missing email. ${USAGE_RUN}`);
-    if (rest.length > 0) throw new Error(`Too many arguments. ${USAGE_RUN}`);
-    log("Starting MCP server");
-    config.apiKey = finalApiKey;
-    config.email = finalEmail;
-    await testConnection();
-    await main();
-  } else {
-    throw new Error(`Unknown command: ${cmd}. Expected 'init' or 'run'. ${USAGE_GENERAL}`);
+import "dotenv/config";
+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").allowUnknownOption().parse(process.argv);
+var cliOptions = program.opts();
+var DEBUG = cliOptions.debug ?? false;
+var allowedTransports = ["stdio", "http"];
+if (!allowedTransports.includes(cliOptions.transport)) {
+  console.error(
+    `Invalid --transport value: '${cliOptions.transport}'. Must be one of: stdio, http.`
+  );
+  process.exit(1);
+}
+var TRANSPORT_TYPE = cliOptions.transport || "stdio";
+var passedPortFlag = process.argv.includes("--port");
+if (TRANSPORT_TYPE === "stdio" && passedPortFlag) {
+  console.error("The --port flag is not allowed when using --transport stdio.");
+  process.exit(1);
+}
+var CLI_PORT = (() => {
+  const parsed = Number.parseInt(cliOptions.port, 10);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+})();
+var sseTransports = {};
+function getClientIp(req) {
+  var _a;
+  const forwardedFor = req.headers["x-forwarded-for"] || req.headers["X-Forwarded-For"];
+  if (forwardedFor) {
+    const ips = Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor;
+    const ipList = ips.split(",").map((ip) => ip.trim());
+    for (const ip of ipList) {
+      const plainIp = ip.replace(/^::ffff:/, "");
+      if (!plainIp.startsWith("10.") && !plainIp.startsWith("192.168.") && !/^172\.(1[6-9]|2\d|3[01])\./.test(plainIp)) {
+        return plainIp;
+      }
+    }
+    return ipList[0].replace(/^::ffff:/, "");
+  }
+  if ((_a = req.socket) == null ? void 0 : _a.remoteAddress) {
+    return req.socket.remoteAddress.replace(/^::ffff:/, "");
   }
+  return void 0;
 }
 async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+  const email = cliOptions.email || process.env.UPSTASH_EMAIL;
+  const apiKey = cliOptions.apiKey || process.env.UPSTASH_API_KEY;
+  if (!email || !apiKey) {
+    console.error(
+      "Missing required credentials. Provide --email and --api-key or set UPSTASH_EMAIL and UPSTASH_API_KEY environment variables."
+    );
+    process.exit(1);
+  }
+  config.email = email;
+  config.apiKey = apiKey;
+  await testConnection();
+  const transportType = TRANSPORT_TYPE;
+  if (transportType === "http") {
+    const initialPort = CLI_PORT ?? 3e3;
+    let actualPort = initialPort;
+    const httpServer = createServer(async (req, res) => {
+      const url = new globalThis.URL(req.url || "", `http://${req.headers.host}`).pathname;
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,DELETE");
+      res.setHeader(
+        "Access-Control-Allow-Headers",
+        "Content-Type, MCP-Session-Id, MCP-Protocol-Version, X-Upstash-API-Key, Upstash-API-Key, X-API-Key, Authorization"
+      );
+      res.setHeader("Access-Control-Expose-Headers", "MCP-Session-Id");
+      if (req.method === "OPTIONS") {
+        res.writeHead(200);
+        res.end();
+        return;
+      }
+      try {
+        const _clientIp = getClientIp(req);
+        const requestServer = createServerInstance();
+        if (url === "/mcp") {
+          const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: void 0
+          });
+          await requestServer.connect(transport);
+          await transport.handleRequest(req, res);
+        } else if (url === "/sse" && req.method === "GET") {
+          const sseTransport = new SSEServerTransport("/messages", res);
+          sseTransports[sseTransport.sessionId] = sseTransport;
+          res.on("close", () => {
+            delete sseTransports[sseTransport.sessionId];
+          });
+          await requestServer.connect(sseTransport);
+        } else if (url === "/messages" && req.method === "POST") {
+          const sessionId = new globalThis.URL(
+            req.url || "",
+            `http://${req.headers.host}`
+          ).searchParams.get("sessionId") ?? "";
+          if (!sessionId) {
+            res.writeHead(400);
+            res.end("Missing sessionId parameter");
+            return;
+          }
+          const sseTransport = sseTransports[sessionId];
+          if (!sseTransport) {
+            res.writeHead(400);
+            res.end(`No transport found for sessionId: ${sessionId}`);
+            return;
+          }
+          await sseTransport.handlePostMessage(req, res);
+        } else if (url === "/ping") {
+          res.writeHead(200, { "Content-Type": "text/plain" });
+          res.end("pong");
+        } else {
+          res.writeHead(404);
+          res.end("Not found");
+        }
+      } catch (error) {
+        console.error("Error handling request:", error);
+        if (!res.headersSent) {
+          res.writeHead(500);
+          res.end("Internal Server Error");
+        }
+      }
+    });
+    const startServer = (port, maxAttempts = 10) => {
+      httpServer.once("error", (err) => {
+        if (err.code === "EADDRINUSE" && port < initialPort + maxAttempts) {
+          console.warn(`Port ${port} is in use, trying port ${port + 1}...`);
+          startServer(port + 1, maxAttempts);
+        } else {
+          console.error(`Failed to start server: ${err.message}`);
+          process.exit(1);
+        }
+      });
+      httpServer.listen(port, () => {
+        actualPort = port;
+        console.error(
+          `Upstash MCP Server running on ${transportType.toUpperCase()} at http://localhost:${actualPort}/mcp with SSE endpoint at /sse`
+        );
+      });
+    };
+    startServer(initialPort);
+  } else {
+    const server = createServerInstance();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Upstash MCP Server running on stdio");
+  }
 }
-parseArguments().catch((error) => {
-  if (!(error instanceof Error)) throw error;
-  console.error(error.message);
+main().catch((error) => {
+  console.error("Fatal error in main():", error);
   process.exit(1);
 });
+export {
+  DEBUG
+};
 //# sourceMappingURL=index.js.map