@decocms/runtime 0.28.1 → 1.0.0-alpha-candy.1

package/src/client.ts

@@ -1,35 +1,3 @@
-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
@@ -38,7 +6,7 @@ export type MCPClient<T> = {
         init?: CustomInit,
       ) => Promise<Awaited<ReturnType<T[K]>>>
     : never;
-} & SubscribeMethods<T>;
+};
 
 export type CustomInit = RequestInit & {
   handleResponse?: (response: Response) => Promise<unknown>;
@@ -53,123 +21,11 @@ export const DEFAULT_INIT: CustomInit = {
   },
 };
 
-/**
- * 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 = {

package/src/index.ts

@@ -1,30 +1,14 @@
 /* oxlint-disable no-explicit-any */
 import type { ExecutionContext } from "@cloudflare/workers-types";
 import { decodeJwt } from "jose";
-import type { z } from "zod/v3";
-import {
-  getReqToken,
-  handleAuthCallback,
-  handleLogout,
-  StateParser,
-} from "./auth.ts";
-import {
-  createContractBinding,
-  createIntegrationBinding,
-  workspaceClient,
-} from "./bindings.ts";
-import { DeconfigResource } from "./bindings/deconfig/index.ts";
-import { DECO_MCP_CLIENT_HEADER } from "./client.ts";
-import { DeprecatedEnv } from "./deprecated.ts";
+import type { z } from "zod";
+import { createContractBinding, createIntegrationBinding } from "./bindings.ts";
+import { State } from "./state.ts";
 import {
   createMCPServer,
   type CreateMCPServerOptions,
   MCPServer,
-} from "./mastra.ts";
-import { MCPClient, type QueryResult } from "./mcp.ts";
-import { State } from "./state.ts";
-import type { WorkflowDO } from "./workflow.ts";
-import { Workflow } from "./workflow.ts";
+} from "./tools.ts";
 import type { Binding, ContractBinding, MCPBinding } from "./wrangler.ts";
 export { proxyConnectionForId } from "./bindings.ts";
 export {
@@ -32,30 +16,15 @@ export {
   type CreateStubAPIOptions,
   type ToolBinder,
 } from "./mcp.ts";
-export interface WorkspaceDB {
-  query: (params: {
-    sql: string;
-    params: string[];
-  }) => Promise<{ result: QueryResult[] }>;
-}
 
-export interface DefaultEnv<TSchema extends z.ZodTypeAny = any>
-  extends DeprecatedEnv<TSchema> {
-  DECO_REQUEST_CONTEXT: RequestContext<TSchema>;
-  DECO_APP_NAME: string;
-  DECO_APP_SLUG: string;
-  DECO_APP_ENTRYPOINT: string;
-  DECO_API_URL?: string;
-  DECO_WORKSPACE: string;
-  DECO_API_JWT_PUBLIC_KEY: string;
-  DECO_APP_DEPLOYMENT_ID: string;
-  DECO_BINDINGS: string;
-  DECO_API_TOKEN: string;
-  DECO_WORKFLOW_DO: DurableObjectNamespace<WorkflowDO>;
-  DECO_WORKSPACE_DB: WorkspaceDB & {
-    forContext: (ctx: RequestContext) => WorkspaceDB;
-  };
+export interface DefaultEnv<TSchema extends z.ZodTypeAny = any> {
+  MESH_REQUEST_CONTEXT: RequestContext<TSchema>;
+  MESH_BINDINGS: string;
+  MESH_APP_DEPLOYMENT_ID: string;
   IS_LOCAL: boolean;
+  MESH_URL?: string;
+  MESH_RUNTIME_TOKEN?: string;
+  MESH_APP_NAME?: string;
   [key: string]: unknown;
 }
 
@@ -63,7 +32,7 @@ export interface BindingsObject {
   bindings?: Binding[];
 }
 
-export const WorkersMCPBindings = {
+export const MCPBindings = {
   parse: (bindings?: string): Binding[] => {
     if (!bindings) return [];
     try {
@@ -109,14 +78,13 @@ export interface User {
 
 export interface RequestContext<TSchema extends z.ZodTypeAny = any> {
   state: z.infer<TSchema>;
-  branch?: string;
   token: string;
-  workspace: string;
+  meshUrl: string;
   ensureAuthenticated: (options?: {
     workspaceHint?: string;
   }) => User | undefined;
   callerApp?: string;
-  integrationId?: string;
+  connectionId?: string;
 }
 
 // 2. Map binding type to its creator function
@@ -136,26 +104,12 @@ const creatorByType: CreatorByType = {
 const withDefaultBindings = ({
   env,
   server,
-  ctx,
   url,
 }: {
   env: DefaultEnv;
   server: MCPServer<any, any>;
-  ctx: RequestContext;
   url?: string;
 }) => {
-  const client = workspaceClient(ctx);
-  const createWorkspaceDB = (ctx: RequestContext): WorkspaceDB => {
-    const client = workspaceClient(ctx);
-    return {
-      query: ({ sql, params }) => {
-        return client.DATABASES_RUN_SQL({
-          sql,
-          params,
-        });
-      },
-    };
-  };
   env["SELF"] = new Proxy(
     {},
     {
@@ -174,20 +128,6 @@ const withDefaultBindings = ({
     },
   );
 
-  const workspaceDbBinding = {
-    ...createWorkspaceDB(ctx),
-    forContext: createWorkspaceDB,
-  };
-
-  env["DECO_API"] = MCPClient;
-  env["DECO_WORKSPACE_API"] = client;
-  env["DECO_WORKSPACE_DB"] = workspaceDbBinding;
-
-  // Backwards compatibility
-  env["DECO_CHAT_API"] = MCPClient;
-  env["DECO_CHAT_WORKSPACE_API"] = client;
-  env["DECO_CHAT_WORKSPACE_DB"] = workspaceDbBinding;
-
   env["IS_LOCAL"] =
     (url?.startsWith("http://localhost") ||
       url?.startsWith("http://127.0.0.1")) ??
@@ -204,13 +144,9 @@ export class UnauthorizedError extends Error {
   }
 }
 
-const AUTH_CALLBACK_ENDPOINT = "/oauth/callback";
-const AUTH_START_ENDPOINT = "/oauth/start";
-const AUTH_LOGOUT_ENDPOINT = "/oauth/logout";
-const AUTHENTICATED = (user?: unknown, workspace?: string) => () => {
+const AUTHENTICATED = (user?: unknown) => () => {
   return {
     ...((user as User) ?? {}),
-    workspace,
   } as User;
 };
 
@@ -218,68 +154,50 @@ export const withBindings = <TEnv>({
   env: _env,
   server,
   tokenOrContext,
-  origin,
   url,
-  branch,
 }: {
   env: TEnv;
   server: MCPServer<TEnv, any>;
   tokenOrContext?: string | RequestContext;
-  origin?: string | null;
   url?: string;
-  branch?: string | null;
 }): TEnv => {
-  branch ??= undefined;
   const env = _env as DefaultEnv<any>;
 
-  const apiUrl = env.DECO_API_URL ?? "https://api.decocms.com";
   let context;
   if (typeof tokenOrContext === "string") {
     const decoded = decodeJwt(tokenOrContext);
-    const workspace = decoded.aud as string;
+    const metadata = decoded.metadata as {
+      state: Record<string, unknown>;
+      meshUrl: string;
+      connectionId: string;
+    };
 
     context = {
-      state: decoded.state as Record<string, unknown>,
+      state: metadata.state,
       token: tokenOrContext,
-      integrationId: decoded.integrationId as string,
-      workspace,
-      ensureAuthenticated: AUTHENTICATED(decoded.user, workspace),
-      branch,
+      meshUrl: metadata.meshUrl,
+      connectionId: metadata.connectionId,
+      ensureAuthenticated: AUTHENTICATED(decoded.user),
     } as RequestContext<any>;
   } else if (typeof tokenOrContext === "object") {
     context = tokenOrContext;
     const decoded = decodeJwt(tokenOrContext.token);
-    const workspace = decoded.aud as string;
+    const metadata = decoded.metadata as {
+      state: Record<string, unknown>;
+      meshUrl: string;
+      connectionId: string;
+    };
     const appName = decoded.appName as string | undefined;
     context.callerApp = appName;
-    context.integrationId ??= decoded.integrationId as string;
-    context.ensureAuthenticated = AUTHENTICATED(decoded.user, workspace);
+    context.connectionId ??= metadata.connectionId;
+    context.ensureAuthenticated = AUTHENTICATED(decoded.user);
   } else {
-    context = {
-      state: undefined,
-      token: env.DECO_API_TOKEN,
-      workspace: env.DECO_WORKSPACE,
-      branch,
-      ensureAuthenticated: (options?: { workspaceHint?: string }) => {
-        const workspaceHint = options?.workspaceHint ?? env.DECO_WORKSPACE;
-        const authUri = new URL("/apps/oauth", apiUrl);
-        authUri.searchParams.set("client_id", env.DECO_APP_NAME);
-        authUri.searchParams.set(
-          "redirect_uri",
-          new URL(AUTH_CALLBACK_ENDPOINT, origin ?? env.DECO_APP_ENTRYPOINT)
-            .href,
-        );
-        workspaceHint &&
-          authUri.searchParams.set("workspace_hint", workspaceHint);
-        throw new UnauthorizedError("Unauthorized", authUri);
-      },
-    };
+    // should not reach here
+    throw new Error("Invalid token or context");
   }
 
-  env.DECO_REQUEST_CONTEXT = context;
-  // Backwards compatibility
-  env.DECO_CHAT_REQUEST_CONTEXT = context;
-  const bindings = WorkersMCPBindings.parse(env.DECO_BINDINGS);
+  env.MESH_REQUEST_CONTEXT = context;
+  const bindings = MCPBindings.parse(env.MESH_BINDINGS);
 
   for (const binding of bindings) {
     env[binding.name] = creatorByType[binding.type](binding as any, env);
@@ -288,7 +206,6 @@ export const withBindings = <TEnv>({
   withDefaultBindings({
     env,
     server,
-    ctx: env.DECO_REQUEST_CONTEXT,
     url,
   });
 
@@ -297,9 +214,7 @@ export const withBindings = <TEnv>({
 
 export const withRuntime = <TEnv, TSchema extends z.ZodTypeAny = never>(
   userFns: UserDefaultExport<TEnv, TSchema>,
-): ExportedHandler<TEnv & DefaultEnv<TSchema>> & {
-  Workflow: ReturnType<typeof Workflow>;
-} => {
+): ExportedHandler<TEnv & DefaultEnv<TSchema>> => {
   const server = createMCPServer<TEnv, TSchema>(userFns);
   const fetcher = async (
     req: Request,
@@ -307,21 +222,6 @@ export const withRuntime = <TEnv, TSchema extends z.ZodTypeAny = never>(
     ctx: ExecutionContext,
   ) => {
     const url = new URL(req.url);
-    if (url.pathname === AUTH_CALLBACK_ENDPOINT) {
-      return handleAuthCallback(req, {
-        apiUrl: env.DECO_API_URL,
-        appName: env.DECO_APP_NAME,
-      });
-    }
-    if (url.pathname === AUTH_START_ENDPOINT) {
-      env.DECO_REQUEST_CONTEXT.ensureAuthenticated();
-      const redirectTo = new URL("/", url);
-      const next = url.searchParams.get("next");
-      return Response.redirect(next ?? redirectTo, 302);
-    }
-    if (url.pathname === AUTH_LOGOUT_ENDPOINT) {
-      return handleLogout(req);
-    }
     if (url.pathname === "/mcp") {
       return server.fetch(req, env, ctx);
     }
@@ -348,56 +248,27 @@ export const withRuntime = <TEnv, TSchema extends z.ZodTypeAny = never>(
       });
     }
 
-    if (url.pathname.startsWith(DeconfigResource.WatchPathNameBase)) {
-      return DeconfigResource.watchAPI(req, env);
-    }
     return (
       userFns.fetch?.(req, env, ctx) ||
       new Response("Not found", { status: 404 })
     );
   };
   return {
-    Workflow: Workflow(server, userFns.workflows),
     fetch: async (
       req: Request,
       env: TEnv & DefaultEnv<TSchema>,
       ctx: ExecutionContext,
     ) => {
-      const referer = req.headers.get("referer");
-      const isFetchRequest = req.headers.has(DECO_MCP_CLIENT_HEADER);
-
-      try {
-        const bindings = withBindings({
-          env,
-          server,
-          branch:
-            req.headers.get("x-deco-branch") ??
-            new URL(req.url).searchParams.get("__b"),
-          tokenOrContext: await getReqToken(req, env),
-          origin:
-            referer ?? req.headers.get("origin") ?? new URL(req.url).origin,
-          url: req.url,
-        });
-        return await State.run(
-          { req, env: bindings, ctx },
-          async () => await fetcher(req, bindings, ctx),
-        );
-      } catch (error) {
-        if (error instanceof UnauthorizedError) {
-          if (!isFetchRequest) {
-            const url = new URL(req.url);
-            error.redirectTo.searchParams.set(
-              "state",
-              StateParser.stringify({
-                next: url.searchParams.get("next") ?? referer ?? req.url,
-              }),
-            );
-            return Response.redirect(error.redirectTo, 302);
-          }
-          return new Response(null, { status: 401 });
-        }
-        throw error;
-      }
+      const bindings = withBindings({
+        env,
+        server,
+        tokenOrContext: req.headers.get("x-mesh-token") ?? undefined,
+        url: req.url,
+      });
+      return await State.run(
+        { req, env: bindings, ctx },
+        async () => await fetcher(req, bindings, ctx),
+      );
     },
   };
 };

package/src/mcp.ts

@@ -1,169 +1,12 @@
 /* oxlint-disable no-explicit-any */
-import { env } from "cloudflare:workers";
-import { z } from "zod/v3";
-import type { MCPConnection } from "./connection.ts";
-import type { DefaultEnv } from "./index.ts";
-import { createMCPClientProxy } from "./proxy.ts";
 import type { ToolBinder } from "@decocms/bindings";
-
-export interface FetchOptions extends RequestInit {
-  path?: string;
-  segments?: string[];
-}
-
-const Timings = z.object({
-  sql_duration_ms: z.number().optional(),
-});
-
-const Meta = z.object({
-  changed_db: z.boolean().optional(),
-  changes: z.number().optional(),
-  duration: z.number().optional(),
-  last_row_id: z.number().optional(),
-  rows_read: z.number().optional(),
-  rows_written: z.number().optional(),
-  served_by_primary: z.boolean().optional(),
-  served_by_region: z
-    .enum(["WNAM", "ENAM", "WEUR", "EEUR", "APAC", "OC"])
-    .optional(),
-  size_after: z.number().optional(),
-  timings: Timings.optional(),
-});
-
-const QueryResult = z.object({
-  meta: Meta.optional(),
-  results: z.array(z.unknown()).optional(),
-  success: z.boolean().optional(),
-});
-
-export type QueryResult = z.infer<typeof QueryResult>;
-
-const workspaceTools = [
-  {
-    name: "INTEGRATIONS_GET" as const,
-    inputSchema: z.object({
-      id: z.string(),
-    }),
-    outputSchema: z.object({
-      connection: z.object({}),
-    }),
-  },
-  {
-    name: "DATABASES_RUN_SQL" as const,
-    inputSchema: z.object({
-      sql: z.string().describe("The SQL query to run"),
-      params: z
-        .array(z.string())
-        .describe("The parameters to pass to the SQL query"),
-    }),
-    outputSchema: z.object({
-      result: z.array(QueryResult),
-    }),
-  },
-] satisfies ToolBinder<string, unknown, object>[];
-
-// Default fetcher instance with API_SERVER_URL and API_HEADERS
-const global = createMCPFetchStub<[]>({});
-export const MCPClient = new Proxy(
-  {} as typeof global & {
-    forWorkspace: (
-      workspace: string,
-      token?: string,
-    ) => MCPClientFetchStub<typeof workspaceTools>;
-    forConnection: <TDefinition extends readonly ToolBinder[]>(
-      connection: MCPConnectionProvider,
-    ) => MCPClientFetchStub<TDefinition>;
-  },
-  {
-    get(_, name) {
-      if (name === "toJSON") {
-        return null;
-      }
-
-      if (name === "forWorkspace") {
-        return (workspace: string, token?: string) =>
-          createMCPFetchStub<[]>({
-            workspace,
-            token,
-            decoCmsApiUrl: (env as DefaultEnv).DECO_API_URL,
-          });
-      }
-      if (name === "forConnection") {
-        return <TDefinition extends readonly ToolBinder[]>(
-          connection: MCPConnectionProvider,
-        ) =>
-          createMCPFetchStub<TDefinition>({
-            connection,
-            decoCmsApiUrl: (env as DefaultEnv).DECO_API_URL,
-          });
-      }
-      return global[name as keyof typeof global];
-    },
-  },
-);
+export {
+  createMCPFetchStub,
+  isStreamableToolBinder,
+  MCPClient,
+  type CreateStubAPIOptions,
+  type MCPClientFetchStub,
+  type MCPClientStub,
+} from "@decocms/bindings/client"; // Default fetcher instance with API_SERVER_URL and API_HEADERS
 
 export type { ToolBinder };
-
-export const isStreamableToolBinder = (
-  toolBinder: ToolBinder,
-): toolBinder is ToolBinder<string, any, any, true> => {
-  return toolBinder.streamable === true;
-};
-export type MCPClientStub<TDefinition extends readonly ToolBinder[]> = {
-  [K in TDefinition[number] as K["name"]]: K extends ToolBinder<
-    string,
-    infer TInput,
-    infer TReturn
-  >
-    ? (params: TInput, init?: RequestInit) => Promise<TReturn>
-    : never;
-};
-
-export type MCPClientFetchStub<TDefinition extends readonly ToolBinder[]> = {
-  [K in TDefinition[number] as K["name"]]: K["streamable"] extends true
-    ? K extends ToolBinder<string, infer TInput, any, true>
-      ? (params: TInput, init?: RequestInit) => Promise<Response>
-      : never
-    : K extends ToolBinder<string, infer TInput, infer TReturn, any>
-      ? (params: TInput, init?: RequestInit) => Promise<Awaited<TReturn>>
-      : never;
-};
-
-export type MCPConnectionProvider = MCPConnection;
-
-export interface MCPClientRaw {
-  callTool: (tool: string, args: unknown) => Promise<unknown>;
-  listTools: () => Promise<
-    {
-      name: string;
-      inputSchema: any;
-      outputSchema?: any;
-      description: string;
-    }[]
-  >;
-}
-export type JSONSchemaToZodConverter = (jsonSchema: any) => z.ZodTypeAny;
-export interface CreateStubAPIOptions {
-  mcpPath?: string;
-  decoCmsApiUrl?: string;
-  workspace?: string;
-  token?: string;
-  connection?: MCPConnectionProvider;
-  streamable?: Record<string, boolean>;
-  debugId?: () => string;
-  getErrorByStatusCode?: (
-    statusCode: number,
-    message?: string,
-    traceId?: string,
-    errorObject?: unknown,
-  ) => Error;
-  supportsToolName?: boolean;
-}
-
-export function createMCPFetchStub<TDefinition extends readonly ToolBinder[]>(
-  options?: CreateStubAPIOptions,
-): MCPClientFetchStub<TDefinition> {
-  return createMCPClientProxy<MCPClientFetchStub<TDefinition>>({
-    ...(options ?? {}),
-  });
-}