@decocms/runtime 0.24.0 → 0.25.1

package/src/bindings.ts

@@ -0,0 +1,178 @@
+import type { MCPConnection } from "./connection.ts";
+import type { DefaultEnv, RequestContext } from "./index.ts";
+import { MCPClient } from "./mcp.ts";
+import type {
+  BindingBase,
+  ContractBinding,
+  MCPBinding,
+  MCPIntegrationNameBinding,
+} from "./wrangler.ts";
+
+interface IntegrationContext {
+  integrationId: string;
+  workspace: string;
+  branch?: string;
+  decoCmsApiUrl?: string;
+}
+
+const normalizeWorkspace = (workspace: string) => {
+  if (workspace.startsWith("/users")) {
+    return workspace;
+  }
+  if (workspace.startsWith("/shared")) {
+    return workspace;
+  }
+  if (workspace.includes("/")) {
+    return workspace;
+  }
+  return `/shared/${workspace}`;
+};
+
+/**
+ * Url: /apps/mcp?appName=$appName
+ */
+const createAppsUrl = ({
+  appName,
+  decoChatApiUrl,
+}: {
+  appName: string;
+  decoChatApiUrl?: string;
+}) =>
+  new URL(
+    `/apps/mcp?appName=${appName}`,
+    decoChatApiUrl ?? "https://api.decocms.com",
+  ).href;
+/**
+ * Url: /:workspace.root/:workspace.slug/:integrationId/mcp
+ */
+const createIntegrationsUrl = ({
+  integrationId,
+  workspace,
+  decoCmsApiUrl,
+  branch,
+}: IntegrationContext) => {
+  const base = `${normalizeWorkspace(workspace)}/${integrationId}/mcp`;
+  const url = new URL(base, decoCmsApiUrl ?? "https://api.decocms.com");
+  branch && url.searchParams.set("branch", branch);
+  return url.href;
+};
+
+type WorkspaceClientContext = Omit<
+  RequestContext,
+  "ensureAuthenticated" | "state" | "fetchIntegrationMetadata"
+>;
+export const workspaceClient = (
+  ctx: WorkspaceClientContext,
+): ReturnType<(typeof MCPClient)["forWorkspace"]> => {
+  return MCPClient.forWorkspace(ctx.workspace, ctx.token);
+};
+
+const mcpClientForAppName = (appName: string, decoChatApiUrl?: string) => {
+  const mcpConnection: MCPConnection = {
+    type: "HTTP",
+    url: createAppsUrl({
+      appName,
+      decoChatApiUrl,
+    }),
+  };
+
+  return MCPClient.forConnection(mcpConnection);
+};
+
+export const proxyConnectionForId = (
+  integrationId: string,
+  ctx: Omit<WorkspaceClientContext, "token"> & {
+    token?: string;
+    cookie?: string;
+  },
+  decoChatApiUrl?: string,
+  appName?: string,
+): MCPConnection => {
+  let headers: Record<string, string> | undefined = appName
+    ? { "x-caller-app": appName }
+    : undefined;
+  if (ctx.cookie) {
+    headers ??= {};
+    headers.cookie = ctx.cookie;
+  }
+  return {
+    type: "HTTP",
+    url: createIntegrationsUrl({
+      integrationId,
+      workspace: ctx.workspace,
+      decoCmsApiUrl: decoChatApiUrl,
+      branch: ctx.branch,
+    }),
+    token: ctx.token,
+    headers,
+  };
+};
+const mcpClientForIntegrationId = (
+  integrationId: string,
+  ctx: WorkspaceClientContext,
+  decoChatApiUrl?: string,
+  appName?: string,
+) => {
+  const mcpConnection = proxyConnectionForId(
+    integrationId,
+    ctx,
+    decoChatApiUrl,
+    appName,
+  );
+
+  // TODO(@igorbrasileiro): Switch this proxy to be a proxy that call MCP Client.toolCall from @modelcontextprotocol
+  return MCPClient.forConnection(mcpConnection);
+};
+
+function mcpClientFromState(
+  binding: BindingBase | MCPIntegrationNameBinding,
+  env: DefaultEnv,
+) {
+  const ctx = env.DECO_REQUEST_CONTEXT;
+  const bindingFromState = ctx?.state?.[binding.name];
+  const integrationId =
+    bindingFromState &&
+    typeof bindingFromState === "object" &&
+    "value" in bindingFromState
+      ? bindingFromState.value
+      : undefined;
+  if (typeof integrationId !== "string" && "integration_name" in binding) {
+    // in case of a binding to an app name, we need to use the new apps/mcp endpoint which will proxy the request to the app but without any token
+    return mcpClientForAppName(binding.integration_name, env.DECO_API_URL);
+  }
+  return mcpClientForIntegrationId(
+    integrationId,
+    ctx,
+    env.DECO_API_URL,
+    env.DECO_APP_NAME,
+  );
+}
+
+export const createContractBinding = (
+  binding: ContractBinding,
+  env: DefaultEnv,
+) => {
+  return mcpClientFromState(binding, env);
+};
+
+export const createIntegrationBinding = (
+  binding: MCPBinding,
+  env: DefaultEnv,
+) => {
+  const integrationId =
+    "integration_id" in binding ? binding.integration_id : undefined;
+  if (!integrationId) {
+    return mcpClientFromState(binding, env);
+  }
+  // bindings pointed to an specific integration id are binded using the app deployment workspace
+  return mcpClientForIntegrationId(
+    integrationId,
+    {
+      workspace: env.DECO_WORKSPACE,
+      token: env.DECO_API_TOKEN,
+      branch: env.DECO_REQUEST_CONTEXT?.branch,
+    },
+    env.DECO_API_URL,
+    env.DECO_APP_NAME,
+  );
+};

package/src/cf-imports.ts

@@ -0,0 +1 @@
+export { DurableObject } from "cloudflare:workers";

package/src/client.ts

@@ -0,0 +1,201 @@
+import { toAsyncIterator } from "./bindings/deconfig/helpers.ts";
+// Extract resource name from DECO_RESOURCE_${NAME}_READ pattern
+type ExtractResourceName<K> = K extends `DECO_RESOURCE_${infer Name}_READ`
+  ? Name
+  : never;
+
+// Generate SUBSCRIBE method name from resource name
+type SubscribeMethodName<Name extends string> =
+  `DECO_RESOURCE_${Name}_SUBSCRIBE`;
+
+// Extract data type from READ method return type
+type ExtractReadData<T> = T extends Promise<{ data: infer D }>
+  ? D
+  : T extends { data: infer D }
+    ? D
+    : never;
+
+// Generate all SUBSCRIBE method names for a given type
+type SubscribeMethods<T> = {
+  [K in keyof T as K extends `DECO_RESOURCE_${string}_READ`
+    ? SubscribeMethodName<ExtractResourceName<K>>
+    : never]: K extends `DECO_RESOURCE_${string}_READ`
+    ? // oxlint-disable-next-line no-explicit-any
+      T[K] extends (...args: any) => any
+      ? (args: { id: string } | { uri: string }) => AsyncIterableIterator<{
+          uri: string;
+          data: ExtractReadData<Awaited<ReturnType<T[K]>>>;
+        }>
+      : never
+    : never;
+};
+
+export type MCPClient<T> = {
+  // oxlint-disable-next-line no-explicit-any
+  [K in keyof T]: T[K] extends (...args: any) => any
+    ? (
+        args: Parameters<T[K]>[0],
+        init?: CustomInit,
+      ) => Promise<Awaited<ReturnType<T[K]>>>
+    : never;
+} & SubscribeMethods<T>;
+
+export type CustomInit = RequestInit & {
+  handleResponse?: (response: Response) => Promise<unknown>;
+};
+
+export const DECO_MCP_CLIENT_HEADER = "X-Deco-MCP-Client";
+
+export const DEFAULT_INIT: CustomInit = {
+  credentials: "include",
+  headers: {
+    [DECO_MCP_CLIENT_HEADER]: "true",
+  },
+};
+
+/**
+ * Helper function to call an MCP tool via fetch
+ */
+async function callMCPTool<T = unknown>(
+  methodName: string,
+  args: unknown,
+  init?: CustomInit,
+): Promise<T> {
+  const mergedInit: CustomInit = {
+    ...init,
+    headers: {
+      ...DEFAULT_INIT.headers,
+      ...init?.headers,
+    },
+  };
+
+  const response = await fetch(`/mcp/call-tool/${methodName}`, {
+    method: "POST",
+    body: JSON.stringify(args),
+    credentials: "include",
+    ...mergedInit,
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to call ${methodName}: ${response.statusText}`);
+  }
+
+  return response.json() as Promise<T>;
+}
+
+/**
+ * Creates a subscribe method for a resource that returns an async iterator
+ * yielding {uri, data} objects as resources are updated.
+ */
+function createSubscribeMethod(
+  resourceName: string,
+  init?: CustomInit,
+): (args: { id: string }) => AsyncIterableIterator<{
+  uri: string;
+  data: unknown;
+}> {
+  return async function* (args: { id: string } | { uri: string }) {
+    // Step 1: Call DESCRIBE to get watch endpoint configuration and URI template
+    const describeMethodName = `DECO_RESOURCE_${resourceName}_DESCRIBE`;
+    const readMethodName = `DECO_RESOURCE_${resourceName}_READ`;
+
+    // Get describe information
+    const describeData = await callMCPTool<{
+      uriTemplate?: string;
+      features?: {
+        watch?: {
+          pathname?: string;
+        };
+      };
+    }>(describeMethodName, {}, init);
+
+    const watchPathname = describeData?.features?.watch?.pathname;
+    const uriTemplate = describeData?.uriTemplate;
+
+    if (!watchPathname) {
+      throw new Error(
+        `Resource ${resourceName} does not support watch functionality`,
+      );
+    }
+
+    if (!uriTemplate) {
+      throw new Error(`Resource ${resourceName} does not provide uriTemplate`);
+    }
+
+    // Step 2: Construct URI from template by replacing * with id
+    const resourceUri =
+      "uri" in args ? args.uri : uriTemplate.replace("*", args.id);
+
+    // Step 3: Construct watch URL and create EventSource
+    const watchUrl = new URL(watchPathname, globalThis.location.origin);
+    watchUrl.searchParams.set("uri", resourceUri);
+
+    const eventSource = new EventSource(watchUrl.href);
+
+    // Step 4: Use toAsyncIterator to consume SSE events and enrich with READ data
+    const eventStream = toAsyncIterator<{ uri: string }>(
+      eventSource,
+      "message",
+    );
+
+    // Iterate over SSE events and enrich with full data
+    for await (const event of eventStream) {
+      const uri = event.uri;
+
+      if (uri) {
+        // Call READ to get full resource data
+        const readData = await callMCPTool<{ data: unknown }>(
+          readMethodName,
+          { uri },
+          init,
+        );
+
+        yield { uri, data: readData.data };
+      }
+    }
+  };
+}
+
+export const createClient = <T>(init?: CustomInit): MCPClient<T> => {
+  return new Proxy(
+    {},
+    {
+      get: (_, prop) => {
+        const propStr = String(prop);
+
+        // Check if this is a SUBSCRIBE method call
+        const subscribeMatch = propStr.match(/^DECO_RESOURCE_(.+)_SUBSCRIBE$/);
+        if (subscribeMatch) {
+          const resourceName = subscribeMatch[1];
+          return createSubscribeMethod(resourceName, init);
+        }
+
+        // Regular method call
+        return async (args: unknown, innerInit?: CustomInit) => {
+          const mergedInit: CustomInit = {
+            ...init,
+            ...innerInit,
+            headers: {
+              ...DEFAULT_INIT.headers,
+              ...init?.headers,
+              ...innerInit?.headers,
+            },
+          };
+
+          const response = await fetch(`/mcp/call-tool/${String(prop)}`, {
+            method: "POST",
+            body: JSON.stringify(args),
+            credentials: "include",
+            ...mergedInit,
+          });
+
+          if (typeof mergedInit.handleResponse === "function") {
+            return mergedInit.handleResponse(response);
+          }
+
+          return response.json();
+        };
+      },
+    },
+  ) as MCPClient<T>;
+};

package/src/connection.ts

@@ -0,0 +1,53 @@
+export type SSEConnection = {
+  type: "SSE";
+  url: string;
+  token?: string;
+  headers?: Record<string, string>;
+};
+
+export type WebsocketConnection = {
+  type: "Websocket";
+  url: string;
+  token?: string;
+};
+
+export type DecoConnection = {
+  type: "Deco";
+  tenant: string;
+  token?: string;
+};
+
+export type InnateConnection = {
+  type: "INNATE";
+  name: string;
+  workspace?: string;
+};
+
+export type HTTPConnection = {
+  type: "HTTP";
+  url: string;
+  headers?: Record<string, string>;
+  token?: string;
+};
+
+export type MCPConnection =
+  | SSEConnection
+  | WebsocketConnection
+  | InnateConnection
+  | DecoConnection
+  | HTTPConnection;
+
+export type Integration = {
+  /** Unique identifier for the MCP */
+  id: string;
+  /** Human-readable name of the integration */
+  name: string;
+  /** Brief description of the integration's functionality */
+  description?: string;
+  /** URL to the integration's icon */
+  icon?: string;
+  /** Access level of the integration */
+  access?: string | null;
+  /** Connection configuration */
+  connection: MCPConnection;
+};

package/src/d1-store.ts

@@ -0,0 +1,34 @@
+import {
+  D1ClientConfig as MastraD1StoreConfig,
+  D1Store as MastraD1Store,
+} from "@mastra/cloudflare-d1";
+
+export class D1Store extends MastraD1Store {
+  constructor(private config: MastraD1StoreConfig) {
+    super(config);
+  }
+
+  override async init() {
+    await super.init();
+
+    // Create indexes for better performance on frequently queried columns
+    const indexQueries = [
+      {
+        sql: "CREATE INDEX IF NOT EXISTS idx_mastra_workflow_snapshot_created_at ON mastra_workflow_snapshot(createdAt)",
+        params: [],
+      },
+      {
+        sql: "CREATE INDEX IF NOT EXISTS idx_mastra_messages_created_at ON mastra_messages(createdAt)",
+        params: [],
+      },
+    ];
+
+    // Execute each index creation query
+    for (const { sql, params } of indexQueries) {
+      await this.config.client.query({
+        sql,
+        params,
+      });
+    }
+  }
+}

package/src/deprecated.ts

@@ -0,0 +1,59 @@
+import type { RequestContext } from "./index.ts";
+import type { DurableObjectNamespace } from "@cloudflare/workers-types";
+import type { WorkspaceDB } from "./index.ts";
+import type { WorkflowDO } from "./workflow.ts";
+import type { z } from "zod";
+
+// oxlint-disable-next-line no-explicit-any
+export interface DeprecatedEnv<TSchema extends z.ZodTypeAny = any> {
+  /**
+   * @deprecated Use DECO_REQUEST_CONTEXT instead
+   */
+  DECO_CHAT_REQUEST_CONTEXT: RequestContext<TSchema>;
+  /**
+   * @deprecated Use DECO_APP_NAME instead
+   */
+  DECO_CHAT_APP_NAME: string;
+  /**
+   * @deprecated Use DECO_APP_SLUG instead
+   */
+  DECO_CHAT_APP_SLUG: string;
+  /**
+   * @deprecated Use DECO_APP_ENTRYPOINT instead
+   */
+  DECO_CHAT_APP_ENTRYPOINT: string;
+  /**
+   * @deprecated Use DECO_API_URL instead
+   */
+  DECO_CHAT_API_URL?: string;
+  /**
+   * @deprecated Use DECO_WORKSPACE instead
+   */
+  DECO_CHAT_WORKSPACE: string;
+  /**
+   * @deprecated Use DECO_API_JWT_PUBLIC_KEY instead
+   */
+  DECO_CHAT_API_JWT_PUBLIC_KEY: string;
+  /**
+   * @deprecated Use DECO_APP_DEPLOYMENT_ID instead
+   */
+  DECO_CHAT_APP_DEPLOYMENT_ID: string;
+  /**
+   * @deprecated Use DECO_BINDINGS instead
+   */
+  DECO_CHAT_BINDINGS: string;
+  /**
+   * @deprecated Use DECO_API_TOKEN instead
+   */
+  DECO_CHAT_API_TOKEN: string;
+  /**
+   * @deprecated Use DECO_WORKFLOW_DO instead
+   */
+  DECO_CHAT_WORKFLOW_DO: DurableObjectNamespace<WorkflowDO>;
+  /**
+   * @deprecated Use DECO_WORKSPACE_DB instead
+   */
+  DECO_CHAT_WORKSPACE_DB: WorkspaceDB & {
+    forContext: (ctx: RequestContext) => WorkspaceDB;
+  };
+}