@decocms/runtime 0.0.1-testing-beta.1

package/src/bindings.ts

@@ -0,0 +1,179 @@
+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,
+  decocmsApiUrl?: string,
+): ReturnType<(typeof MCPClient)["forWorkspace"]> => {
+  return MCPClient.forWorkspace(ctx.workspace, ctx.token, decocmsApiUrl);
+};
+
+const mcpClientForAppName = (appName: string, decoChatApiUrl?: string) => {
+  const mcpConnection: MCPConnection = {
+    type: "HTTP",
+    url: createAppsUrl({
+      appName,
+      decoChatApiUrl,
+    }),
+  };
+
+  return MCPClient.forConnection(mcpConnection, decoChatApiUrl);
+};
+
+export const proxyConnectionForId = (
+  integrationId: string,
+  ctx: Omit<WorkspaceClientContext, "token"> & {
+    token?: string;
+    cookie?: string;
+  },
+  decocmsApiUrl?: 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: decocmsApiUrl,
+      branch: ctx.branch,
+    }),
+    token: ctx.token,
+    headers,
+  };
+};
+const mcpClientForIntegrationId = (
+  integrationId: string,
+  ctx: WorkspaceClientContext,
+  decocmsApiUrl?: string,
+  appName?: string,
+) => {
+  const mcpConnection = proxyConnectionForId(
+    integrationId,
+    ctx,
+    decocmsApiUrl,
+    appName,
+  );
+
+  // TODO(@igorbrasileiro): Switch this proxy to be a proxy that call MCP Client.toolCall from @modelcontextprotocol
+  return MCPClient.forConnection(mcpConnection, decocmsApiUrl);
+};
+
+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/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/drizzle.ts

@@ -0,0 +1,201 @@
+import type { DrizzleConfig } from "drizzle-orm";
+import {
+  drizzle as drizzleProxy,
+  type SqliteRemoteDatabase,
+} from "drizzle-orm/sqlite-proxy";
+import { QueryResult } from "./mcp.ts";
+export * from "drizzle-orm/sqlite-core";
+export * as orm from "drizzle-orm";
+import { sql } from "drizzle-orm";
+import { DefaultEnv } from "./index.ts";
+
+const mapGetResult = ({ result: [page] }: { result: QueryResult[] }) => {
+  return page.results ?? [];
+};
+
+const mapPostResult = ({ result }: { result: QueryResult[] }) => {
+  return (
+    result
+      .map((page) => page.results ?? [])
+      .flat()
+      // @ts-expect-error - this is ok, result comes as unknown
+      .map(Object.values)
+  );
+};
+
+export function drizzle<
+  TSchema extends Record<string, unknown> = Record<string, never>,
+>(
+  { DECO_WORKSPACE_DB }: Pick<DefaultEnv, "DECO_WORKSPACE_DB">,
+  config?: DrizzleConfig<TSchema>,
+) {
+  return drizzleProxy((sql, params, method) => {
+    // https://orm.drizzle.team/docs/connect-drizzle-proxy says
+    // Drizzle always waits for {rows: string[][]} or {rows: string[]} for the return value.
+    // When the method is get, you should return a value as {rows: string[]}.
+    // Otherwise, you should return {rows: string[][]}.
+    const asRows = method === "get" ? mapGetResult : mapPostResult;
+    return DECO_WORKSPACE_DB.query({
+      sql,
+      params,
+    }).then((result) => ({ rows: asRows(result) }));
+  }, config);
+}
+
+/**
+ * The following code is a custom migration system tweaked
+ * from the durable-sqlite original migrator.
+ *
+ * @see https://github.com/drizzle-team/drizzle-orm/blob/main/drizzle-orm/src/durable-sqlite/migrator.ts
+ *
+ * It applies the migrations without transactions, as a workaround
+ * while we don't have remote transactions support on the
+ * workspace database durable object. Not ideal and we should
+ * look into implementing some way of doing transactions soon.
+ */
+
+export interface MigrationMeta {
+  sql: string[];
+  folderMillis: number;
+  hash: string;
+  bps: boolean;
+}
+
+export interface MigrationConfig {
+  journal: {
+    entries: { idx: number; when: number; tag: string; breakpoints: boolean }[];
+  };
+  migrations: Record<string, string>;
+  debug?: boolean;
+}
+
+function readMigrationFiles({
+  journal,
+  migrations,
+}: MigrationConfig): MigrationMeta[] {
+  const migrationQueries: MigrationMeta[] = [];
+
+  for (const journalEntry of journal.entries) {
+    const query =
+      migrations[`m${journalEntry.idx.toString().padStart(4, "0")}`];
+
+    if (!query) {
+      throw new Error(`Missing migration: ${journalEntry.tag}`);
+    }
+
+    try {
+      const result = query.split("--> statement-breakpoint").map((it) => {
+        return it;
+      });
+
+      migrationQueries.push({
+        sql: result,
+        bps: journalEntry.breakpoints,
+        folderMillis: journalEntry.when,
+        hash: "",
+      });
+    } catch {
+      throw new Error(`Failed to parse migration: ${journalEntry.tag}`);
+    }
+  }
+
+  return migrationQueries;
+}
+
+export async function migrateWithoutTransaction(
+  db: SqliteRemoteDatabase,
+  config: MigrationConfig,
+): Promise<void> {
+  const debug = config.debug ?? false;
+
+  if (debug) console.log("Migrating database");
+  const migrations = readMigrationFiles(config);
+  if (debug) console.log("Migrations", migrations);
+
+  try {
+    if (debug) console.log("Setting up migrations table");
+    const migrationsTable = "__drizzle_migrations";
+
+    // Create migrations table if it doesn't exist
+    // Note: Changed from SERIAL to INTEGER PRIMARY KEY AUTOINCREMENT for SQLite compatibility
+    const migrationTableCreate = sql`
+            CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                hash text NOT NULL,
+                created_at numeric
+            )
+        `;
+    await db.run(migrationTableCreate);
+
+    // Get the last applied migration
+    const dbMigrations = await db.values<[number, string, string]>(
+      sql`SELECT id, hash, created_at FROM ${sql.identifier(
+        migrationsTable,
+      )} ORDER BY created_at DESC LIMIT 1`,
+    );
+
+    const lastDbMigration = dbMigrations[0] ?? undefined;
+    if (debug) console.log("Last applied migration:", lastDbMigration);
+
+    // Apply pending migrations sequentially (without transaction wrapper)
+    for (const migration of migrations) {
+      const hasNoMigrations =
+        lastDbMigration === undefined || !lastDbMigration.length;
+      if (
+        hasNoMigrations ||
+        Number(lastDbMigration[2])! < migration.folderMillis
+      ) {
+        if (debug) console.log(`Applying migration: ${migration.folderMillis}`);
+
+        try {
+          // Execute all statements in the migration
+          for (const stmt of migration.sql) {
+            if (stmt.trim()) {
+              // Skip empty statements
+              if (debug) {
+                console.log("Executing:", stmt.substring(0, 100) + "...");
+              }
+              await db.run(sql.raw(stmt));
+            }
+          }
+
+          // Record successful migration
+          await db.run(
+            sql`INSERT INTO ${sql.identifier(
+              migrationsTable,
+            )} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`,
+          );
+
+          if (debug) {
+            console.log(
+              `✅ Migration ${migration.folderMillis} applied successfully`,
+            );
+          }
+        } catch (migrationError: unknown) {
+          console.error(
+            `❌ Migration ${migration.folderMillis} failed:`,
+            migrationError,
+          );
+          throw new Error(
+            `Migration failed at ${migration.folderMillis}: ${
+              migrationError instanceof Error
+                ? migrationError.message
+                : String(migrationError)
+            }`,
+          );
+        }
+      } else {
+        if (debug) {
+          console.log(
+            `⏭️ Skipping already applied migration: ${migration.folderMillis}`,
+          );
+        }
+      }
+    }
+
+    if (debug) console.log("✅ All migrations completed successfully");
+  } catch (error: unknown) {
+    console.error("❌ Migration process failed:", error);
+    throw error;
+  }
+}

package/src/http-client-transport.ts

@@ -0,0 +1,66 @@
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+import {
+  StreamableHTTPClientTransport,
+  type StreamableHTTPClientTransportOptions,
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+export class HTTPClientTransport extends StreamableHTTPClientTransport {
+  constructor(url: URL, opts?: StreamableHTTPClientTransportOptions) {
+    super(url, opts);
+  }
+
+  override send(
+    message: JSONRPCMessage,
+    options?: {
+      resumptionToken?: string;
+      onresumptiontoken?: (token: string) => void;
+    },
+  ): Promise<void> {
+    const mockAction = getMockActionFor(message);
+    if (mockAction?.type === "emit") {
+      this.onmessage?.(mockAction.message);
+      return Promise.resolve();
+    }
+    if (mockAction?.type === "suppress") {
+      return Promise.resolve();
+    }
+    return super.send(message, options);
+  }
+}
+
+type MockAction =
+  | { type: "emit"; message: JSONRPCMessage }
+  | { type: "suppress" };
+
+function getMockActionFor(message: JSONRPCMessage): MockAction | null {
+  const m = message;
+  if (!m || typeof m !== "object" || !("method" in m)) return null;
+
+  switch (m.method) {
+    case "initialize": {
+      const protocolVersion = m?.params?.protocolVersion;
+      if (!protocolVersion) return null;
+      return {
+        type: "emit",
+        message: {
+          result: {
+            protocolVersion,
+            capabilities: { tools: {} },
+            serverInfo: { name: "deco-chat-server", version: "1.0.0" },
+          },
+          jsonrpc: m.jsonrpc ?? "2.0",
+          // @ts-expect-error - id is not typed
+          id: m.id,
+        } as JSONRPCMessage,
+      };
+    }
+    case "notifications/roots/list_changed":
+    case "notifications/initialized":
+    case "notifications/cancelled":
+    case "notifications/progress": {
+      return { type: "suppress" };
+    }
+    default:
+      return null;
+  }
+}