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

package/package.json

@@ -1,101 +1,35 @@
 {
   "name": "@decocms/runtime",
-  "version": "0.28.1",
+  "version": "1.0.0-alpha-candy.2",
   "type": "module",
-  "scripts": {
-    "build": "tsup",
-    "prepublishOnly": "npm run build"
-  },
   "dependencies": {
     "@cloudflare/workers-types": "^4.20250617.0",
     "@deco/mcp": "npm:@jsr/deco__mcp@0.5.5",
-    "@decocms/bindings": "*",
-    "@mastra/cloudflare-d1": "^0.13.4",
+    "@decocms/bindings": "1.0.1-alpha-candy.1",
     "@mastra/core": "^0.20.2",
     "@modelcontextprotocol/sdk": "^1.19.1",
     "@ai-sdk/provider": "^2.0.0",
     "bidc": "0.0.3",
     "drizzle-orm": "^0.44.5",
+    "hono": "^4.10.7",
     "jose": "^6.0.11",
     "mime-db": "1.52.0",
     "zod": "^3.25.76",
     "zod-from-json-schema": "^0.0.5",
     "zod-to-json-schema": "3.25.0"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist/**/*",
-    "src/**/*",
-    "config-schema.json"
-  ],
   "exports": {
-    ".": {
-      "source": "./src/index.ts",
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./proxy": {
-      "source": "./src/proxy.ts",
-      "types": "./dist/proxy.d.ts",
-      "default": "./dist/proxy.js"
-    },
-    "./admin": {
-      "source": "./src/admin.ts",
-      "types": "./dist/admin.d.ts",
-      "default": "./dist/admin.js"
-    },
-    "./client": {
-      "source": "./src/client.ts",
-      "types": "./dist/client.d.ts",
-      "default": "./dist/client.js"
-    },
-    "./mastra": {
-      "source": "./src/mastra.ts",
-      "types": "./dist/mastra.d.ts",
-      "default": "./dist/mastra.js"
-    },
-    "./drizzle": {
-      "source": "./src/drizzle.ts",
-      "types": "./dist/drizzle.d.ts",
-      "default": "./dist/drizzle.js"
-    },
-    "./d1": {
-      "source": "./src/d1-store.ts",
-      "types": "./dist/d1-store.d.ts",
-      "default": "./dist/d1-store.js"
-    },
-    "./resources": {
-      "source": "./src/resources.ts",
-      "types": "./dist/resources.d.ts",
-      "default": "./dist/resources.js"
-    },
-    "./views": {
-      "source": "./src/views.ts",
-      "types": "./dist/views.d.ts",
-      "default": "./dist/views.js"
-    },
-    "./mcp-client": {
-      "source": "./src/mcp-client.ts",
-      "types": "./dist/mcp-client.d.ts",
-      "default": "./dist/mcp-client.js"
-    },
-    "./bindings": {
-      "source": "./src/bindings/index.ts",
-      "types": "./dist/bindings/index.d.ts",
-      "default": "./dist/bindings/index.js"
-    },
-    "./deconfig": {
-      "source": "./src/bindings/deconfig/index.ts",
-      "types": "./dist/bindings/deconfig/index.d.ts",
-      "default": "./dist/bindings/deconfig/index.js"
-    }
+    ".": "./src/index.ts",
+    "./proxy": "./src/proxy.ts",
+    "./client": "./src/client.ts",
+    "./mcp-client": "./src/mcp-client.ts",
+    "./bindings": "./src/bindings/index.ts",
+    "./asset-server": "./src/asset-server/index.ts",
+    "./tools": "./src/tools.ts"
   },
   "devDependencies": {
     "@types/mime-db": "^1.43.6",
-    "ts-json-schema-generator": "^2.4.0",
-    "tsup": "^8.5.0",
-    "typescript": "^5.9.3"
+    "ts-json-schema-generator": "^2.4.0"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -103,4 +37,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/scripts/generate-json-schema.ts

@@ -0,0 +1,24 @@
+// heavily inspired by https://github.com/cloudflare/workers-sdk/blob/main/packages/wrangler/scripts/generate-json-schema.ts
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createGenerator } from "ts-json-schema-generator";
+import type { Config, Schema } from "ts-json-schema-generator";
+
+const config: Config = {
+  path: join(import.meta.dirname!, "../src/wrangler.ts"),
+  type: "WranglerConfig",
+  skipTypeCheck: true,
+};
+
+const applyFormattingRules = (schema: Schema) => {
+  return { ...schema, allowTrailingCommas: true };
+};
+
+const schema = applyFormattingRules(
+  createGenerator(config).createSchema(config.type),
+);
+
+writeFileSync(
+  join(import.meta.dirname!, "../config-schema.json"),
+  JSON.stringify(schema, null, 2),
+);

package/src/asset-server/dev-server-proxy.ts

@@ -0,0 +1,16 @@
+import { proxy } from "hono/proxy";
+import { Context } from "hono";
+
+export const devServerProxy = (url: string | URL) => (c: Context) => {
+  const incomingUrl = new URL(c.req.raw.url);
+  const target = new URL(url);
+  target.pathname = incomingUrl.pathname;
+  target.search = incomingUrl.search;
+
+  return proxy(target, {
+    raw: c.req.raw,
+    headers: {
+      ...c.req.raw.headers,
+    },
+  });
+};

package/src/asset-server/index.ts

@@ -0,0 +1,44 @@
+import { serveStatic } from "hono/bun";
+import { Hono } from "hono";
+import { devServerProxy } from "./dev-server-proxy";
+import { Handler } from "hono/types";
+
+interface AssetServerConfig {
+  env: "development" | "production" | "test";
+  localDevProxyUrl?: string | URL;
+  assetsDirectory?: string;
+}
+
+const DEFAULT_LOCAL_DEV_PROXY_URL = "http://localhost:4000";
+const DEFAULT_ASSETS_DIRECTORY = "./dist/client";
+
+interface HonoApp {
+  use: (path: string, handler: Handler) => void;
+  get: (path: string, handler: Handler) => void;
+}
+
+export const applyAssetServerRoutes = (
+  app: HonoApp,
+  config: AssetServerConfig,
+) => {
+  const environment = config.env;
+  const localDevProxyUrl =
+    config.localDevProxyUrl ?? DEFAULT_LOCAL_DEV_PROXY_URL;
+  const assetsDirectory = config.assetsDirectory ?? DEFAULT_ASSETS_DIRECTORY;
+
+  if (environment === "development") {
+    app.use("*", devServerProxy(localDevProxyUrl));
+  } else if (environment === "production") {
+    app.use("/assets/*", serveStatic({ root: assetsDirectory }));
+    app.get("*", serveStatic({ path: `${assetsDirectory}/index.html` }));
+  }
+};
+
+export const createAssetServer = (config: AssetServerConfig) => {
+  const app = new Hono();
+  applyAssetServerRoutes(app, config);
+  return app;
+};
+
+export const createAssetServerFetcher = (config: AssetServerConfig) =>
+  createAssetServer(config).fetch;

package/src/bindings/README.md

@@ -78,7 +78,7 @@ To create a new binding:
    input/output:
 
 ```ts
-import { z } from "zod/v3";
+import { z } from "zod";
 import type { Binder } from "../index.ts";
 
 const myInputSchema = z.object({ ... });

package/src/bindings/binder.ts

@@ -1,14 +1,13 @@
 /* oxlint-disable no-explicit-any */
-import { z } from "zod/v3";
+import { z } from "zod";
 import type { MCPConnection } from "../connection.ts";
-import { createPrivateTool, createStreamableTool } from "../mastra.ts";
 import {
   createMCPFetchStub,
   type MCPClientFetchStub,
   type ToolBinder,
 } from "../mcp.ts";
+import { createPrivateTool, createStreamableTool } from "../tools.ts";
 import { CHANNEL_BINDING } from "./channels.ts";
-import { VIEW_BINDING } from "./views.ts";
 
 // ToolLike is a simplified version of the Tool interface that matches what we need for bindings
 export interface ToolLike<
@@ -93,8 +92,6 @@ export type MCPBindingClient<T extends ReturnType<typeof bindingClient>> =
   ReturnType<T["forConnection"]>;
 
 export const ChannelBinding = bindingClient(CHANNEL_BINDING);
-export const ViewBinding = bindingClient(VIEW_BINDING);
-
 export type { Callbacks } from "./channels.ts";
 
 export const impl = <TBinder extends Binder>(

package/src/bindings/channels.ts

@@ -1,4 +1,4 @@
-import { z } from "zod/v3";
+import { z } from "zod";
 import type { ToolBinder } from "../mcp.ts";
 
 const callbacksSchema = z.object({

package/src/bindings/index.ts

@@ -1,16 +1,13 @@
 import { CHANNEL_BINDING } from "./channels.ts";
-import { VIEW_BINDING as VIEWS_BINDING } from "./views.ts";
 
 // Import new Resources 2.0 bindings function
 import { LANGUAGE_MODEL_BINDING } from "@decocms/bindings/llm";
-import { createResourceBindings } from "./resources/bindings.ts";
 
 // Export types and utilities from binder
 export {
   bindingClient,
   ChannelBinding,
   impl,
-  ViewBinding,
   type Binder,
   type BinderImplementation,
   type MCPBindingClient,
@@ -23,40 +20,10 @@ export * from "./channels.ts";
 // Export binding utilities
 export * from "./utils.ts";
 
-// Export views schemas
-export * from "./views.ts";
-
-// Re-export Resources bindings function for convenience
-export { createResourceBindings };
-
-// Export resources types and schemas
-export * from "./resources/bindings.ts";
-export * from "./resources/helpers.ts";
-export * from "./resources/schemas.ts";
-
-// Export deconfig helpers and types
-export {
-  getMetadataString as deconfigGetMetadataString,
-  getMetadataValue as deconfigGetMetadataValue,
-  normalizeDirectory as deconfigNormalizeDirectory,
-  ResourcePath,
-  ResourceUri,
-} from "./deconfig/helpers.ts";
-export { createDeconfigResource } from "./deconfig/index.ts";
-export type {
-  DeconfigClient,
-  DeconfigResourceOptions,
-  EnhancedResourcesTools,
-  ResourcesBinding,
-  ResourcesTools,
-} from "./deconfig/index.ts";
-export { deconfigTools } from "./deconfig/types.ts";
-
 export { streamToResponse } from "./language-model/utils.ts";
 
 export const WellKnownBindings = {
   Channel: CHANNEL_BINDING,
-  View: VIEWS_BINDING,
   LanguageModel: LANGUAGE_MODEL_BINDING,
   // Note: Resources is not included here since it's a generic function
   // Use createResourceBindings(dataSchema) directly for Resources 2.0

package/src/bindings/language-model/utils.ts

@@ -25,94 +25,3 @@ export function streamToResponse(
     },
   });
 }
-
-export function responseToStream(
-  response: Response,
-): ReadableStream<LanguageModelV2StreamPart> {
-  if (!response.body) {
-    throw new Error("Response body is null");
-  }
-
-  return response.body.pipeThrough(new TextDecoderStream()).pipeThrough(
-    new TransformStream<string, LanguageModelV2StreamPart>({
-      transform(chunk, controller) {
-        // Split by newlines and parse each line
-        const lines = chunk.split("\n");
-
-        for (const line of lines) {
-          if (line.trim()) {
-            try {
-              const parsed = JSON.parse(line) as LanguageModelV2StreamPart;
-              controller.enqueue(parsed);
-            } catch (error) {
-              console.error("Failed to parse stream chunk:", error);
-            }
-          }
-        }
-      },
-    }),
-  );
-}
-
-/**
- * Lazy promise wrapper that defers execution until the promise is awaited.
- * The factory function is only called when .then() is invoked for the first time.
- */
-class Lazy<T> implements PromiseLike<T> {
-  private promise: Promise<T> | null = null;
-
-  constructor(private factory: () => Promise<T>) {}
-
-  private getOrCreatePromise(): Promise<T> {
-    if (!this.promise) {
-      this.promise = this.factory();
-    }
-    return this.promise;
-  }
-
-  // eslint-disable-next-line no-thenable
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | PromiseLike<TResult1>)
-      | null
-      | undefined,
-    onrejected?:
-      | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
-      | null
-      | undefined,
-  ): PromiseLike<TResult1 | TResult2> {
-    return this.getOrCreatePromise().then(onfulfilled, onrejected);
-  }
-
-  catch<TResult = never>(
-    onrejected?:
-      | ((reason: unknown) => TResult | PromiseLike<TResult>)
-      | null
-      | undefined,
-  ): Promise<T | TResult> {
-    return this.getOrCreatePromise().catch(onrejected);
-  }
-
-  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
-    return this.getOrCreatePromise().finally(onfinally);
-  }
-}
-
-/**
- * Creates a lazy promise that only executes when awaited.
- *
- * @param factory - A function that returns a Promise<T>
- * @returns A Promise-like object that defers execution until .then() is called
- *
- * @example
- * ```ts
- * const lazyData = lazy(() => fetchExpensiveData());
- * // fetchExpensiveData() is NOT called yet
- *
- * const result = await lazyData;
- * // fetchExpensiveData() is called NOW
- * ```
- */
-export function lazy<T>(factory: () => Promise<T>): Promise<T> {
-  return new Lazy(factory) as unknown as Promise<T>;
-}

package/src/bindings.ts

@@ -4,88 +4,22 @@ import { MCPClient } from "./mcp.ts";
 import type {
   BindingBase,
   ContractBinding,
+  MCPAppBinding,
   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<
+type ClientContext = 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"> & {
+  connectionId: string,
+  ctx: Omit<ClientContext, "token"> & {
     token?: string;
     cookie?: string;
+    meshUrl: string;
   },
-  decoChatApiUrl?: string,
   appName?: string,
 ): MCPConnection => {
   let headers: Record<string, string> | undefined = appName
@@ -97,55 +31,39 @@ export const proxyConnectionForId = (
   }
   return {
     type: "HTTP",
-    url: createIntegrationsUrl({
-      integrationId,
-      workspace: ctx.workspace,
-      decoCmsApiUrl: decoChatApiUrl,
-      branch: ctx.branch,
-    }),
+    url: new URL(`/mcp/${connectionId}`, ctx.meshUrl).href,
     token: ctx.token,
     headers,
   };
 };
-const mcpClientForIntegrationId = (
-  integrationId: string,
-  ctx: WorkspaceClientContext,
-  decoChatApiUrl?: string,
+const mcpClientForConnectionId = (
+  connectionId: string,
+  ctx: ClientContext,
   appName?: string,
 ) => {
-  const mcpConnection = proxyConnectionForId(
-    integrationId,
-    ctx,
-    decoChatApiUrl,
-    appName,
-  );
+  const mcpConnection = proxyConnectionForId(connectionId, ctx, 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,
+  binding: BindingBase | MCPAppBinding,
   env: DefaultEnv,
 ) {
-  const ctx = env.DECO_REQUEST_CONTEXT;
+  const ctx = env.MESH_REQUEST_CONTEXT;
   const bindingFromState = ctx?.state?.[binding.name];
-  const integrationId =
+  const connectionId =
     bindingFromState &&
     typeof bindingFromState === "object" &&
     "value" in bindingFromState
       ? bindingFromState.value
       : undefined;
-  if (typeof integrationId !== "string" && "integration_name" in binding) {
+  if (typeof connectionId !== "string" && "app_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);
+    throw new Error("Binding to an app name is not supported");
   }
-  return mcpClientForIntegrationId(
-    integrationId,
-    ctx,
-    env.DECO_API_URL,
-    env.DECO_APP_NAME,
-  );
+  return mcpClientForConnectionId(connectionId, ctx);
 }
 
 export const createContractBinding = (
@@ -159,20 +77,24 @@ export const createIntegrationBinding = (
   binding: MCPBinding,
   env: DefaultEnv,
 ) => {
-  const integrationId =
-    "integration_id" in binding ? binding.integration_id : undefined;
-  if (!integrationId) {
+  const connectionId =
+    "connection_id" in binding ? binding.connection_id : undefined;
+  if (!connectionId) {
     return mcpClientFromState(binding, env);
   }
+  if (!env.MESH_RUNTIME_TOKEN) {
+    throw new Error("MESH_RUNTIME_TOKEN is required");
+  }
+  if (!env.MESH_URL) {
+    throw new Error("MESH_URL is required");
+  }
   // bindings pointed to an specific integration id are binded using the app deployment workspace
-  return mcpClientForIntegrationId(
-    integrationId,
+  return mcpClientForConnectionId(
+    connectionId,
     {
-      workspace: env.DECO_WORKSPACE,
-      token: env.DECO_API_TOKEN,
-      branch: env.DECO_REQUEST_CONTEXT?.branch,
+      token: env.MESH_RUNTIME_TOKEN,
+      meshUrl: env.MESH_URL,
     },
-    env.DECO_API_URL,
-    env.DECO_APP_NAME,
+    env.MESH_APP_NAME,
   );
 };