@mastra/deployer-cloudflare 0.0.0-storage-20250225005900 → 0.0.0-trigger-playground-ui-package-20250506151043

package/{LICENSE → LICENSE.md}

@@ -1,4 +1,6 @@
-Elastic License 2.0 (ELv2)
+# Elastic License 2.0 (ELv2)
+
+Copyright (c) 2025 Mastra AI, Inc.
 
 **Acceptance**
 By using the software, you agree to all of the terms and conditions below.

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,69 @@
+import type { analyzeBundle } from '@mastra/deployer/analyze';
+import { Deployer } from '@mastra/deployer';
+import { InputOptions } from 'rollup';
+
+declare interface CFRoute {
+    pattern: string;
+    zone_name: string;
+    custom_domain?: boolean;
+}
+
+export declare class CloudflareDeployer extends Deployer {
+    private cloudflare;
+    routes?: CFRoute[];
+    workerNamespace?: string;
+    scope: string;
+    env?: Record<string, any>;
+    projectName?: string;
+    constructor({ scope, env, projectName, routes, workerNamespace, auth, }: {
+        env?: Record<string, any>;
+        scope: string;
+        projectName?: string;
+        routes?: CFRoute[];
+        workerNamespace?: string;
+        auth: {
+            apiToken: string;
+            apiEmail?: string;
+        };
+    });
+    writeFiles(outputDirectory: string): Promise<void>;
+    private getEntry;
+    prepare(outputDirectory: string): Promise<void>;
+    getBundlerOptions(serverFile: string, mastraEntryFile: string, analyzedBundleInfo: Awaited<ReturnType<typeof analyzeBundle>>, toolsPaths: string[]): Promise<InputOptions>;
+    bundle(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
+    deploy(outputDirectory: string): Promise<void>;
+    tagWorker({ workerName, namespace, tags, scope, }: {
+        scope: string;
+        workerName: string;
+        namespace: string;
+        tags: string[];
+    }): Promise<void>;
+    lint(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
+}
+
+export declare class CloudflareSecretsManager {
+    accountId: string;
+    apiToken: string;
+    baseUrl: string;
+    constructor({ accountId, apiToken }: {
+        accountId: string;
+        apiToken: string;
+    });
+    createSecret({ workerId, secretName, secretValue, }: {
+        workerId: string;
+        secretName: string;
+        secretValue: string;
+    }): Promise<any>;
+    createProjectSecrets({ workerId, customerId, envVars, }: {
+        workerId: string;
+        customerId: string;
+        envVars: Record<string, string>;
+    }): Promise<any>;
+    deleteSecret({ workerId, secretName }: {
+        workerId: string;
+        secretName: string;
+    }): Promise<any>;
+    listSecrets(workerId: string): Promise<any>;
+}
+
+export { }

package/dist/_tsup-dts-rollup.d.ts

@@ -1,4 +1,6 @@
+import type { analyzeBundle } from '@mastra/deployer/analyze';
 import { Deployer } from '@mastra/deployer';
+import { InputOptions } from 'rollup';
 
 declare interface CFRoute {
     pattern: string;
@@ -27,7 +29,8 @@ export declare class CloudflareDeployer extends Deployer {
     writeFiles(outputDirectory: string): Promise<void>;
     private getEntry;
     prepare(outputDirectory: string): Promise<void>;
-    bundle(entryFile: string, outputDirectory: string): Promise<void>;
+    getBundlerOptions(serverFile: string, mastraEntryFile: string, analyzedBundleInfo: Awaited<ReturnType<typeof analyzeBundle>>, toolsPaths: string[]): Promise<InputOptions>;
+    bundle(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
     deploy(outputDirectory: string): Promise<void>;
     tagWorker({ workerName, namespace, tags, scope, }: {
         scope: string;
@@ -35,6 +38,7 @@ export declare class CloudflareDeployer extends Deployer {
         namespace: string;
         tags: string[];
     }): Promise<void>;
+    lint(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
 }
 
 export declare class CloudflareSecretsManager {

package/dist/index.cjs

@@ -0,0 +1,186 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var deployer = require('@mastra/deployer');
+var virtual = require('@rollup/plugin-virtual');
+var cloudflare = require('cloudflare');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var virtual__default = /*#__PURE__*/_interopDefault(virtual);
+
+// src/index.ts
+var CloudflareDeployer = class extends deployer.Deployer {
+  cloudflare;
+  routes = [];
+  workerNamespace;
+  scope;
+  env;
+  projectName;
+  constructor({
+    scope,
+    env,
+    projectName = "mastra",
+    routes,
+    workerNamespace,
+    auth
+  }) {
+    super({ name: "CLOUDFLARE" });
+    this.scope = scope;
+    this.projectName = projectName;
+    this.routes = routes;
+    this.workerNamespace = workerNamespace;
+    if (env) {
+      this.env = env;
+    }
+    this.cloudflare = new cloudflare.Cloudflare(auth);
+  }
+  async writeFiles(outputDirectory) {
+    const env = await this.loadEnvVars();
+    const envsAsObject = Object.assign({}, Object.fromEntries(env.entries()), this.env);
+    const cfWorkerName = this.projectName;
+    const wranglerConfig = {
+      name: cfWorkerName,
+      main: "./index.mjs",
+      compatibility_date: "2025-04-01",
+      compatibility_flags: ["nodejs_compat", "nodejs_compat_populate_process_env"],
+      observability: {
+        logs: {
+          enabled: true
+        }
+      },
+      vars: envsAsObject
+    };
+    if (!this.workerNamespace && this.routes) {
+      wranglerConfig.routes = this.routes;
+    }
+    await promises.writeFile(path.join(outputDirectory, this.outputDir, "wrangler.json"), JSON.stringify(wranglerConfig));
+  }
+  getEntry() {
+    return `
+    import '#polyfills';
+    import { mastra } from '#mastra';
+    import { createHonoServer } from '#server';
+    import { evaluate } from '@mastra/core/eval';
+    import { AvailableHooks, registerHook } from '@mastra/core/hooks';
+    import { TABLE_EVALS } from '@mastra/core/storage';
+    import { checkEvalStorageFields } from '@mastra/core/utils';
+
+    registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
+      evaluate({
+        agentName,
+        input,
+        metric,
+        output,
+        runId,
+        globalRunId: runId,
+        instructions,
+      });
+    });
+
+    if (mastra.getStorage()) {
+      // start storage init in the background
+      mastra.getStorage().init();
+    }
+
+    registerHook(AvailableHooks.ON_EVALUATION, async traceObject => {
+      const storage = mastra.getStorage();
+      if (storage) {
+        // Check for required fields
+        const logger = mastra?.getLogger();
+        const areFieldsValid = checkEvalStorageFields(traceObject, logger);
+        if (!areFieldsValid) return;
+
+        await storage.insert({
+          tableName: TABLE_EVALS,
+          record: {
+            input: traceObject.input,
+            output: traceObject.output,
+            result: JSON.stringify(traceObject.result || {}),
+            agent_name: traceObject.agentName,
+            metric_name: traceObject.metricName,
+            instructions: traceObject.instructions,
+            test_info: null,
+            global_run_id: traceObject.globalRunId,
+            run_id: traceObject.runId,
+            created_at: new Date().toISOString(),
+          },
+        });
+      }
+    });
+
+    export default {
+      fetch: async (request, env, context) => {
+        const app = await createHonoServer(mastra)
+        return app.fetch(request, env, context);
+      }
+    }
+`;
+  }
+  async prepare(outputDirectory) {
+    await super.prepare(outputDirectory);
+    await this.writeFiles(outputDirectory);
+  }
+  async getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths) {
+    const inputOptions = await super.getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths);
+    if (Array.isArray(inputOptions.plugins)) {
+      inputOptions.plugins = [
+        virtual__default.default({
+          "#polyfills": `
+process.versions = process.versions || {};
+process.versions.node = '${process.versions.node}';
+      `
+        }),
+        ...inputOptions.plugins
+      ];
+    }
+    return inputOptions;
+  }
+  async bundle(entryFile, outputDirectory, toolsPaths) {
+    return this._bundle(this.getEntry(), entryFile, outputDirectory, toolsPaths);
+  }
+  async deploy(outputDirectory) {
+    const cmd = this.workerNamespace ? `npm exec -- wrangler@latest deploy --dispatch-namespace ${this.workerNamespace}` : "npm exec -- wrangler@latest deploy";
+    const cpLogger = deployer.createChildProcessLogger({
+      logger: this.logger,
+      root: path.join(outputDirectory, this.outputDir)
+    });
+    await cpLogger({
+      cmd,
+      args: [],
+      env: {
+        CLOUDFLARE_API_TOKEN: this.cloudflare.apiToken,
+        CLOUDFLARE_ACCOUNT_ID: this.scope,
+        ...this.env,
+        PATH: process.env.PATH
+      }
+    });
+  }
+  async tagWorker({
+    workerName,
+    namespace,
+    tags,
+    scope
+  }) {
+    if (!this.cloudflare) {
+      throw new Error("Cloudflare Deployer not initialized");
+    }
+    await this.cloudflare.workersForPlatforms.dispatch.namespaces.scripts.tags.update(namespace, workerName, {
+      account_id: scope,
+      body: tags
+    });
+  }
+  async lint(entryFile, outputDirectory, toolsPaths) {
+    await super.lint(entryFile, outputDirectory, toolsPaths);
+    const hasLibsql = await this.deps.checkDependencies(["@mastra/libsql"]) === `ok`;
+    if (hasLibsql) {
+      this.logger.error(
+        "Cloudflare Deployer does not support @libsql/client(which may have been installed by @mastra/libsql) as a dependency. Please use Cloudflare D1 instead @mastra/cloudflare-d1"
+      );
+      process.exit(1);
+    }
+  }
+};
+
+exports.CloudflareDeployer = CloudflareDeployer;

package/dist/index.d.cts

@@ -0,0 +1 @@
+export { CloudflareDeployer } from './_tsup-dts-rollup.cjs';

package/dist/index.js

@@ -1,9 +1,8 @@
+import { writeFile } from 'fs/promises';
+import { join } from 'path';
 import { Deployer, createChildProcessLogger } from '@mastra/deployer';
-import '@mastra/deployer/build';
-import '@rollup/plugin-virtual';
+import virtual from '@rollup/plugin-virtual';
 import { Cloudflare } from 'cloudflare';
-import { writeFileSync } from 'fs';
-import { join } from 'path';
 
 // src/index.ts
 var CloudflareDeployer = class extends Deployer {
@@ -37,9 +36,9 @@ var CloudflareDeployer = class extends Deployer {
     const cfWorkerName = this.projectName;
     const wranglerConfig = {
       name: cfWorkerName,
-      main: "index.mjs",
-      compatibility_date: "2024-12-02",
-      compatibility_flags: ["nodejs_compat"],
+      main: "./index.mjs",
+      compatibility_date: "2025-04-01",
+      compatibility_flags: ["nodejs_compat", "nodejs_compat_populate_process_env"],
       observability: {
         logs: {
           enabled: true
@@ -50,36 +49,96 @@ var CloudflareDeployer = class extends Deployer {
     if (!this.workerNamespace && this.routes) {
       wranglerConfig.routes = this.routes;
     }
-    writeFileSync(join(outputDirectory, "wrangler.json"), JSON.stringify(wranglerConfig));
+    await writeFile(join(outputDirectory, this.outputDir, "wrangler.json"), JSON.stringify(wranglerConfig));
   }
   getEntry() {
     return `
-export default {
-  fetch: async (request, env, context) => {
-    Object.keys(env).forEach(key => {
-      process.env[key] = env[key]
-    })
+    import '#polyfills';
+    import { mastra } from '#mastra';
+    import { createHonoServer } from '#server';
+    import { evaluate } from '@mastra/core/eval';
+    import { AvailableHooks, registerHook } from '@mastra/core/hooks';
+    import { TABLE_EVALS } from '@mastra/core/storage';
+    import { checkEvalStorageFields } from '@mastra/core/utils';
 
-    const { mastra } = await import('#mastra')
-    const { createHonoServer } = await import('#server')
-    const app = await createHonoServer(mastra)
-    return app.fetch(request, env, context);
-  }
-}
+    registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
+      evaluate({
+        agentName,
+        input,
+        metric,
+        output,
+        runId,
+        globalRunId: runId,
+        instructions,
+      });
+    });
+
+    if (mastra.getStorage()) {
+      // start storage init in the background
+      mastra.getStorage().init();
+    }
+
+    registerHook(AvailableHooks.ON_EVALUATION, async traceObject => {
+      const storage = mastra.getStorage();
+      if (storage) {
+        // Check for required fields
+        const logger = mastra?.getLogger();
+        const areFieldsValid = checkEvalStorageFields(traceObject, logger);
+        if (!areFieldsValid) return;
+
+        await storage.insert({
+          tableName: TABLE_EVALS,
+          record: {
+            input: traceObject.input,
+            output: traceObject.output,
+            result: JSON.stringify(traceObject.result || {}),
+            agent_name: traceObject.agentName,
+            metric_name: traceObject.metricName,
+            instructions: traceObject.instructions,
+            test_info: null,
+            global_run_id: traceObject.globalRunId,
+            run_id: traceObject.runId,
+            created_at: new Date().toISOString(),
+          },
+        });
+      }
+    });
+
+    export default {
+      fetch: async (request, env, context) => {
+        const app = await createHonoServer(mastra)
+        return app.fetch(request, env, context);
+      }
+    }
 `;
   }
   async prepare(outputDirectory) {
     await super.prepare(outputDirectory);
     await this.writeFiles(outputDirectory);
   }
-  async bundle(entryFile, outputDirectory) {
-    return this._bundle(this.getEntry(), entryFile, outputDirectory);
+  async getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths) {
+    const inputOptions = await super.getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths);
+    if (Array.isArray(inputOptions.plugins)) {
+      inputOptions.plugins = [
+        virtual({
+          "#polyfills": `
+process.versions = process.versions || {};
+process.versions.node = '${process.versions.node}';
+      `
+        }),
+        ...inputOptions.plugins
+      ];
+    }
+    return inputOptions;
+  }
+  async bundle(entryFile, outputDirectory, toolsPaths) {
+    return this._bundle(this.getEntry(), entryFile, outputDirectory, toolsPaths);
   }
   async deploy(outputDirectory) {
-    const cmd = this.workerNamespace ? `npm exec -- wrangler deploy --dispatch-namespace ${this.workerNamespace}` : "npm exec -- wrangler deploy";
+    const cmd = this.workerNamespace ? `npm exec -- wrangler@latest deploy --dispatch-namespace ${this.workerNamespace}` : "npm exec -- wrangler@latest deploy";
     const cpLogger = createChildProcessLogger({
       logger: this.logger,
-      root: outputDirectory
+      root: join(outputDirectory, this.outputDir)
     });
     await cpLogger({
       cmd,
@@ -106,6 +165,16 @@ export default {
       body: tags
     });
   }
+  async lint(entryFile, outputDirectory, toolsPaths) {
+    await super.lint(entryFile, outputDirectory, toolsPaths);
+    const hasLibsql = await this.deps.checkDependencies(["@mastra/libsql"]) === `ok`;
+    if (hasLibsql) {
+      this.logger.error(
+        "Cloudflare Deployer does not support @libsql/client(which may have been installed by @mastra/libsql) as a dependency. Please use Cloudflare D1 instead @mastra/cloudflare-d1"
+      );
+      process.exit(1);
+    }
+  }
 };
 
 export { CloudflareDeployer };

package/{src/secrets-manager/index.ts → dist/secrets-manager/index.cjs}

@@ -1,110 +1,89 @@
-export class CloudflareSecretsManager {
-  accountId: string;
-  apiToken: string;
-  baseUrl: string;
-
-  constructor({ accountId, apiToken }: { accountId: string; apiToken: string }) {
+'use strict';
+
+// src/secrets-manager/index.ts
+var CloudflareSecretsManager = class {
+  accountId;
+  apiToken;
+  baseUrl;
+  constructor({ accountId, apiToken }) {
     this.accountId = accountId;
     this.apiToken = apiToken;
-    this.baseUrl = 'https://api.cloudflare.com/client/v4';
+    this.baseUrl = "https://api.cloudflare.com/client/v4";
   }
-
   async createSecret({
     workerId,
     secretName,
-    secretValue,
-  }: {
-    workerId: string;
-    secretName: string;
-    secretValue: string;
+    secretValue
   }) {
     const url = `${this.baseUrl}/accounts/${this.accountId}/workers/scripts/${workerId}/secrets`;
-
     try {
       const response = await fetch(url, {
-        method: 'PUT',
+        method: "PUT",
         headers: {
           Authorization: `Bearer ${this.apiToken}`,
-          'Content-Type': 'application/json',
+          "Content-Type": "application/json"
         },
         body: JSON.stringify({
           name: secretName,
-          text: secretValue,
-        }),
+          text: secretValue
+        })
       });
-
-      const data = (await response.json()) as { success: boolean; result: any; errors: any[] };
-
+      const data = await response.json();
       if (!data.success) {
         throw new Error(data.errors[0].message);
       }
-
       return data.result;
     } catch (error) {
-      console.error('Failed to create secret:', error);
+      console.error("Failed to create secret:", error);
       throw error;
     }
   }
-
   async createProjectSecrets({
     workerId,
     customerId,
-    envVars,
-  }: {
-    workerId: string;
-    customerId: string;
-    envVars: Record<string, string>;
+    envVars
   }) {
     const secretName = `PROJECT_${customerId.toUpperCase()}`;
     const secretValue = JSON.stringify(envVars);
-
     return this.createSecret({ workerId, secretName, secretValue });
   }
-
-  async deleteSecret({ workerId, secretName }: { workerId: string; secretName: string }) {
+  async deleteSecret({ workerId, secretName }) {
     const url = `${this.baseUrl}/accounts/${this.accountId}/workers/scripts/${workerId}/secrets/${secretName}`;
-
     try {
       const response = await fetch(url, {
-        method: 'DELETE',
+        method: "DELETE",
         headers: {
-          Authorization: `Bearer ${this.apiToken}`,
-        },
+          Authorization: `Bearer ${this.apiToken}`
+        }
       });
-
-      const data = (await response.json()) as { success: boolean; result: any; errors: any[] };
-
+      const data = await response.json();
       if (!data.success) {
         throw new Error(data.errors[0].message);
       }
-
       return data.result;
     } catch (error) {
-      console.error('Failed to delete secret:', error);
+      console.error("Failed to delete secret:", error);
       throw error;
     }
   }
-
-  async listSecrets(workerId: string) {
+  async listSecrets(workerId) {
     const url = `${this.baseUrl}/accounts/${this.accountId}/workers/scripts/${workerId}/secrets`;
-
     try {
       const response = await fetch(url, {
         headers: {
-          Authorization: `Bearer ${this.apiToken}`,
-        },
+          Authorization: `Bearer ${this.apiToken}`
+        }
       });
-
-      const data = (await response.json()) as { success: boolean; result: any; errors: any[] };
-
+      const data = await response.json();
       if (!data.success) {
         throw new Error(data.errors[0].message);
       }
-
       return data.result;
     } catch (error) {
-      console.error('Failed to list secrets:', error);
+      console.error("Failed to list secrets:", error);
       throw error;
     }
   }
-}
+};
+
+exports.CloudflareSecretsManager = CloudflareSecretsManager;

package/dist/secrets-manager/index.d.cts

@@ -0,0 +1 @@
+export { CloudflareSecretsManager } from '../_tsup-dts-rollup.cjs';

package/package.json

@@ -1,46 +1,62 @@
 {
   "name": "@mastra/deployer-cloudflare",
-  "version": "0.0.0-storage-20250225005900",
+  "version": "0.0.0-trigger-playground-ui-package-20250506151043",
   "description": "",
   "type": "module",
+  "files": [
+    "dist"
+  ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./secrets-manager": {
-      "types": "./dist/secrets-manager/index.d.ts",
-      "default": "./dist/secrets-manager/index.js"
+      "import": {
+        "types": "./dist/secrets-manager/index.d.ts",
+        "default": "./dist/secrets-manager/index.js"
+      },
+      "require": {
+        "types": "./dist/secrets-manager/index.d.cts",
+        "default": "./dist/secrets-manager/index.cjs"
+      }
     },
     "./package.json": "./package.json"
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
+  "license": "Elastic-2.0",
   "dependencies": {
+    "@babel/core": "^7.26.10",
     "@rollup/plugin-virtual": "^3.0.2",
-    "cloudflare": "^4.0.0",
-    "date-fns": "^4.1.0",
-    "execa": "^9.3.1",
-    "rollup-plugin-polyfill-node": "^0.13.0",
-    "rollup-plugin-shim": "^1.0.0",
-    "wrangler": "^3.103.2",
-    "zod": "^3.24.1",
-    "@mastra/core": "^0.0.0-storage-20250225005900",
-    "@mastra/deployer": "^0.0.0-storage-20250225005900"
+    "cloudflare": "^4.1.0",
+    "rollup": "^4.35.0",
+    "wrangler": "^4.4.0",
+    "zod": "^3.24.2",
+    "@mastra/core": "0.0.0-trigger-playground-ui-package-20250506151043",
+    "@mastra/deployer": "0.0.0-trigger-playground-ui-package-20250506151043"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.49.2",
-    "@types/node": "^22.13.1",
-    "tsup": "^8.0.1",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.4"
+    "@microsoft/api-extractor": "^7.52.5",
+    "@types/node": "^20.17.27",
+    "eslint": "^9.23.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2",
+    "vitest": "^3.1.2",
+    "@internal/lint": "0.0.0-trigger-playground-ui-package-20250506151043"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/secrets-manager/index.ts --format esm --experimental-dts --clean --treeshake",
+    "build": "tsup src/index.ts src/secrets-manager/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
     "build:watch": "pnpm build --watch",
-    "test": "vitest run"
+    "test": "vitest run",
+    "lint": "eslint ."
   }
 }