feat(provider): add Upstash Redis REST actions (#210)

## Summary / 概要

- Add a locally executable Upstash Redis provider backed by the official
REST API.
- 新增基于 Upstash 官方 REST API 的本地可执行 Redis Provider。

## Changes / 改动内容

- Add custom credentials with estUrl and secret estToken, validated
through PING.
- 新增 
estUrl 与敏感 
estToken 凭据，并使用 PING 校验连接。

- Add seven string-key actions: get, set, delete, exists, expire, tl,
and single-page scan.
- 新增 7 个字符串键操作：get、set、delete、exists、expire、	tl 和单页 scan。

- Support atomic SET key value [EX seconds] [NX|XX] writes and preserve
Redis TTL semantics.
- 支持原子 SET key value [EX seconds] [NX|XX] 写入，并保留 Redis TTL 语义。

- Restrict REST URLs to public https://*.upstash.io root endpoints and
route requests through the injected SSRF-protected fetcher.
- REST URL 仅允许公网 https://*.upstash.io 根路径端点，所有请求均使用注入的 SSRF 防护 Fetch。

- Handle timeouts, cancellation, JSON response envelopes, upstream
errors, and non-JSON error bodies while preserving relevant HTTP status
codes.
- 处理超时、取消、JSON 响应包络、上游错误和非 JSON 错误响应，并保留关键 HTTP 状态码。

## Validation / 验证

- scripts/generate-catalog.ts
- 
pm run typecheck
- �itest run - 57 files and 548 tests passed
- Mock Fetch smoke tests for credential validation, command encoding,
output normalization, URL validation, and non-JSON upstream errors

## Notes / 说明

- No npm dependencies or shared runtime changes were added.
- 未新增 npm 依赖，也未修改共享运行时。

- package-lock.json is intentionally excluded because it is unrelated
local user work.
- package-lock.json 为无关的本地用户修改，未包含在本 PR 中。

---------

Co-authored-by: Kevin Cui <bh@bugs.cc>

Author: vinkiYu

src/providers/upstash_redis/actions.ts

@@ -0,0 +1,117 @@
+import type { ActionDefinition } from "../../core/types.ts";
+
+import { s } from "../../core/json-schema.ts";
+import { defineProviderAction } from "../../core/provider-definition.ts";
+
+const service = "upstash_redis";
+
+const keySchema = s.nonEmptyString("The Redis key.");
+const valueSchema = s.nonEmptyString("The string value stored for the Redis key.");
+const expirationSecondsSchema = s.positiveInteger("Expiration time in seconds.");
+
+export const upstashRedisActions: ActionDefinition[] = [
+  defineProviderAction(service, {
+    name: "get",
+    description: "Get the string value stored for one Redis key.",
+    inputSchema: s.actionInput({ key: keySchema }, ["key"], "The Redis key to retrieve."),
+    outputSchema: s.actionOutput(
+      {
+        value: s.nullableString(
+          "The stored string value, or null when the key does not exist. Upstash replaces bytes that are not valid UTF-8 with U+FFFD, so only text values round-trip exactly.",
+        ),
+      },
+      "The value returned for the Redis key.",
+    ),
+    followUpActions: ["upstash_redis.set", "upstash_redis.delete", "upstash_redis.expire", "upstash_redis.ttl"],
+  }),
+  defineProviderAction(service, {
+    name: "set",
+    description: "Store a string value for one Redis key, optionally with an expiration or conditional write.",
+    inputSchema: s.object(
+      "The Redis string value to store.",
+      {
+        key: keySchema,
+        value: valueSchema,
+        expirationSeconds: expirationSecondsSchema,
+        condition: s.stringEnum(["NX", "XX"], {
+          description: "Optional Redis write condition: NX stores only a new key; XX stores only an existing key.",
+        }),
+      },
+      { required: ["key", "value"], optional: ["expirationSeconds", "condition"] },
+    ),
+    outputSchema: s.actionOutput(
+      { stored: s.boolean("Whether Redis stored the value. False means the requested condition was not met.") },
+      "The result of the Redis SET command.",
+    ),
+    followUpActions: ["upstash_redis.get", "upstash_redis.ttl"],
+  }),
+  defineProviderAction(service, {
+    name: "delete",
+    description: "Delete one Redis key.",
+    inputSchema: s.actionInput({ key: keySchema }, ["key"], "The Redis key to delete."),
+    outputSchema: s.actionOutput(
+      { deleted: s.boolean("Whether Redis deleted an existing key.") },
+      "The result of the Redis DEL command.",
+    ),
+  }),
+  defineProviderAction(service, {
+    name: "exists",
+    description: "Check whether one Redis key exists.",
+    inputSchema: s.actionInput({ key: keySchema }, ["key"], "The Redis key to check."),
+    outputSchema: s.actionOutput(
+      { exists: s.boolean("Whether the Redis key exists.") },
+      "The result of the Redis EXISTS command.",
+    ),
+    followUpActions: ["upstash_redis.get", "upstash_redis.ttl"],
+  }),
+  defineProviderAction(service, {
+    name: "expire",
+    description: "Set or replace the expiration time for one Redis key.",
+    inputSchema: s.actionInput(
+      { key: keySchema, expirationSeconds: expirationSecondsSchema },
+      ["key", "expirationSeconds"],
+      "The Redis key and its new expiration time.",
+    ),
+    outputSchema: s.actionOutput(
+      { updated: s.boolean("Whether Redis updated the expiration for an existing key.") },
+      "The result of the Redis EXPIRE command.",
+    ),
+    followUpActions: ["upstash_redis.ttl"],
+  }),
+  defineProviderAction(service, {
+    name: "ttl",
+    description: "Get the remaining expiration time for one Redis key.",
+    inputSchema: s.actionInput({ key: keySchema }, ["key"], "The Redis key whose expiration to retrieve."),
+    outputSchema: s.actionOutput(
+      {
+        ttlSeconds: s.integer(
+          "Remaining expiration in seconds. -2 means the key does not exist; -1 means the key has no expiration.",
+        ),
+      },
+      "The result of the Redis TTL command.",
+    ),
+  }),
+  defineProviderAction(service, {
+    name: "scan",
+    description: "Scan one page of Redis keys without reading the full keyspace.",
+    inputSchema: s.object(
+      "Cursor pagination and optional filters for Redis SCAN.",
+      {
+        cursor: s.nonEmptyString("The cursor returned by a previous scan. Omit it to start at cursor 0."),
+        match: s.nonEmptyString("Optional Redis glob pattern used to filter keys."),
+        count: s.integer("Optional scan work hint from 1 to 1000.", { minimum: 1, maximum: 1000 }),
+      },
+      { optional: ["cursor", "match", "count"] },
+    ),
+    outputSchema: s.actionOutput(
+      {
+        nextCursor: s.nonEmptyString(
+          "Cursor to pass to the next scan request. A value of 0 means scanning is complete.",
+        ),
+        keys: s.stringArray("Keys returned in this scan page."),
+        complete: s.boolean("Whether this scan reached cursor 0."),
+      },
+      "One page returned by Redis SCAN.",
+    ),
+  }),
+];

src/providers/upstash_redis/definition.ts

@@ -0,0 +1,45 @@
+import type { ProviderDefinition } from "../../core/types.ts";
+
+import { upstashRedisActions } from "./actions.ts";
+
+const service = "upstash_redis";
+
+/**
+ * Upstash Redis provider backed by the official REST API.
+ */
+export const provider: ProviderDefinition = {
+  service,
+  displayName: "Upstash Redis",
+  description: "Read and manage string keys in an Upstash Redis database through its REST API.",
+  categories: ["Data", "Developer Tools"],
+  authTypes: ["custom_credential"],
+  auth: [
+    {
+      type: "custom_credential",
+      fields: [
+        {
+          key: "restUrl",
+          label: "REST URL",
+          inputType: "text",
+          required: true,
+          secret: false,
+          placeholder: "https://your-database.upstash.io",
+          description:
+            "The HTTPS REST URL shown for an Upstash Redis database in the Upstash console. Only official upstash.io endpoints are supported.",
+        },
+        {
+          key: "restToken",
+          label: "REST Token",
+          inputType: "password",
+          required: true,
+          secret: true,
+          placeholder: "Your Upstash REST token",
+          description:
+            "The Upstash Redis REST token sent as a Bearer token. A read-only token can run get, exists, and ttl, but Upstash also blocks scan for read-only tokens, so the standard token is required for scan and for every write action.",
+        },
+      ],
+    },
+  ],
+  homepageUrl: "https://upstash.com/redis",
+  actions: upstashRedisActions,
+};

src/providers/upstash_redis/executors.ts

@@ -0,0 +1,22 @@
+import type { CredentialValidators, ExecutionContext, ProviderExecutors } from "../../core/types.ts";
+import type { UpstashRedisContext } from "./runtime.ts";
+
+import { defineProviderExecutors, requireCustomCredential } from "../provider-runtime.ts";
+import { createUpstashRedisContext, upstashRedisActionHandlers, validateUpstashRedisCredential } from "./runtime.ts";
+
+const service = "upstash_redis";
+
+export const executors: ProviderExecutors = defineProviderExecutors({
+  service,
+  handlers: upstashRedisActionHandlers,
+  async createContext(context: ExecutionContext, fetcher): Promise<UpstashRedisContext> {
+    const credential = await requireCustomCredential(context, service);
+    return createUpstashRedisContext(credential.values, fetcher, context.signal);
+  },
+});
+
+export const credentialValidators: CredentialValidators = {
+  customCredential(input, { fetcher, signal }) {
+    return validateUpstashRedisCredential(input.values, fetcher, signal);
+  },
+};