@mastra/deployer-netlify 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/README.md

@@ -26,6 +26,7 @@ import { NetlifyDeployer } from '@mastra/deployer-netlify';
 const deployer = new NetlifyDeployer({
   scope: 'your-team-id',
   projectName: 'your-project-name',
+  token: 'your-netlify-token',
 });
 
 const mastra = new Mastra({
@@ -38,8 +39,9 @@ const mastra = new Mastra({
 
 ### Constructor Options
 
-- `scope` (required): Your Netlify team ID
+- `scope` (required): Your Netlify team slug or ID
 - `projectName`: Name of your Netlify site (will be created if it doesn't exist)
+- `token`: Your Netlify authentication token
 
 ## Project Structure
 

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

@@ -0,0 +1,40 @@
+import { Deployer } from '@mastra/deployer';
+
+export declare function getOrCreateSite({ token, name, scope }: {
+    token: string;
+    name: string;
+    scope: string;
+}): Promise<{
+    id: string | undefined;
+    name: string | undefined;
+    url: string | undefined;
+    adminUrl: string | undefined;
+} | {
+    id: string;
+    name: string;
+    ssl_url: string;
+    url: string;
+    admin_url: string;
+}>;
+
+export declare class NetlifyDeployer extends Deployer {
+    protected scope: string;
+    protected projectName: string;
+    protected token: string;
+    constructor({ scope, projectName, token }: {
+        scope: string;
+        projectName: string;
+        token: string;
+    });
+    writeFiles({ dir }: {
+        dir: string;
+    }): void;
+    protected installDependencies(outputDirectory: string, rootDir?: string): Promise<void>;
+    deploy(outputDirectory: string): Promise<void>;
+    prepare(outputDirectory: string): Promise<void>;
+    bundle(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
+    private getEntry;
+    lint(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
+}
+
+export { }

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

@@ -29,10 +29,12 @@ export declare class NetlifyDeployer extends Deployer {
     writeFiles({ dir }: {
         dir: string;
     }): void;
+    protected installDependencies(outputDirectory: string, rootDir?: string): Promise<void>;
     deploy(outputDirectory: string): Promise<void>;
     prepare(outputDirectory: string): Promise<void>;
-    bundle(entryFile: string, outputDirectory: string): Promise<void>;
+    bundle(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
     private getEntry;
+    lint(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
 }
 
 export { }

package/dist/index.cjs

@@ -0,0 +1,204 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var deployer = require('@mastra/deployer');
+var services = require('@mastra/deployer/services');
+var execa = require('execa');
+
+// src/index.ts
+
+// src/helpers.ts
+async function createNetlifySite({ token, name, scope }) {
+  const response = await fetch("https://api.netlify.com/api/v1/sites", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      name,
+      account_slug: scope,
+      // Optional - if not provided, creates in user's default account
+      force_ssl: true
+      // Enable HTTPS
+    })
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    console.error(JSON.stringify(data));
+    throw new Error(`Failed to create site: ${data.message || "Unknown error"}`);
+  }
+  return {
+    id: data.id,
+    name: data.name,
+    url: data.ssl_url || data.url,
+    adminUrl: data.admin_url
+  };
+}
+async function findNetlifySite({ token, name, scope }) {
+  const response = await fetch(`https://api.netlify.com/api/v1/${scope}/sites?filter=all&name=${name}`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    }
+  });
+  const data = await response.json();
+  if (!response.ok || !Array.isArray(data)) {
+    throw new Error(`Failed to search sites: ${data.message || "Unknown error"}`);
+  }
+  return data.find((site) => site.name === name);
+}
+async function getOrCreateSite({ token, name, scope }) {
+  let existingSite;
+  try {
+    existingSite = await findNetlifySite({ token, name, scope });
+  } catch {
+  }
+  if (existingSite) {
+    return existingSite;
+  }
+  return createNetlifySite({ token, name, scope });
+}
+
+// src/index.ts
+var NetlifyDeployer = class extends deployer.Deployer {
+  scope;
+  projectName;
+  token;
+  constructor({ scope, projectName, token }) {
+    super({ name: "NETLIFY" });
+    this.scope = scope;
+    this.projectName = projectName;
+    this.token = token;
+  }
+  writeFiles({ dir }) {
+    if (!fs.existsSync(path.join(dir, "netlify/functions/api"))) {
+      fs.mkdirSync(path.join(dir, "netlify/functions/api"), { recursive: true });
+    }
+    fs.writeFileSync(
+      path.join(dir, "netlify.toml"),
+      `[functions]
+node_bundler = "esbuild"            
+directory = "netlify/functions"
+
+[[redirects]]
+force = true
+from = "/*"
+status = 200
+to = "/.netlify/functions/api/:splat"
+`
+    );
+  }
+  async installDependencies(outputDirectory, rootDir = process.cwd()) {
+    const deps = new services.DepsService(rootDir);
+    deps.__setLogger(this.logger);
+    await deps.install({
+      dir: path.join(outputDirectory, this.outputDir),
+      architecture: {
+        os: ["linux"],
+        cpu: ["x64"],
+        libc: ["gnu"]
+      }
+    });
+  }
+  async deploy(outputDirectory) {
+    const site = await getOrCreateSite({ token: this.token, name: this.projectName || `mastra`, scope: this.scope });
+    const p2 = execa.execa(
+      "npx",
+      [
+        "netlify-cli",
+        "deploy",
+        "--site",
+        site.id,
+        "--auth",
+        this.token,
+        "--dir",
+        ".",
+        "--functions",
+        "./netlify/functions"
+      ],
+      {
+        cwd: path.join(outputDirectory, this.outputDir)
+      }
+    );
+    p2.stdout.pipe(process.stdout);
+    await p2;
+  }
+  async prepare(outputDirectory) {
+    await super.prepare(outputDirectory);
+    this.writeFiles({ dir: path.join(outputDirectory, this.outputDir) });
+  }
+  async bundle(entryFile, outputDirectory, toolsPaths) {
+    return this._bundle(
+      this.getEntry(),
+      entryFile,
+      outputDirectory,
+      toolsPaths,
+      path.join(outputDirectory, this.outputDir, "netlify", "functions", "api")
+    );
+  }
+  getEntry() {
+    return `
+    import { handle } from 'hono/netlify'
+    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(),
+          },
+        });
+      }
+    });
+
+    const app = await createHonoServer(mastra);
+
+    export default handle(app)
+`;
+  }
+  async lint(entryFile, outputDirectory, toolsPaths) {
+    await super.lint(entryFile, outputDirectory, toolsPaths);
+  }
+};
+
+exports.NetlifyDeployer = NetlifyDeployer;

package/dist/index.d.cts

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

package/dist/index.js

@@ -1,7 +1,8 @@
-import { Deployer } from '@mastra/deployer';
-import { execa } from 'execa';
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
+import { Deployer } from '@mastra/deployer';
+import { DepsService } from '@mastra/deployer/services';
+import { execa } from 'execa';
 
 // src/index.ts
 
@@ -50,7 +51,7 @@ async function getOrCreateSite({ token, name, scope }) {
   let existingSite;
   try {
     existingSite = await findNetlifySite({ token, name, scope });
-  } catch (e) {
+  } catch {
   }
   if (existingSite) {
     return existingSite;
@@ -87,6 +88,18 @@ to = "/.netlify/functions/api/:splat"
 `
     );
   }
+  async installDependencies(outputDirectory, rootDir = process.cwd()) {
+    const deps = new DepsService(rootDir);
+    deps.__setLogger(this.logger);
+    await deps.install({
+      dir: join(outputDirectory, this.outputDir),
+      architecture: {
+        os: ["linux"],
+        cpu: ["x64"],
+        libc: ["gnu"]
+      }
+    });
+  }
   async deploy(outputDirectory) {
     const site = await getOrCreateSite({ token: this.token, name: this.projectName || `mastra`, scope: this.scope });
     const p2 = execa(
@@ -114,25 +127,76 @@ to = "/.netlify/functions/api/:splat"
     await super.prepare(outputDirectory);
     this.writeFiles({ dir: join(outputDirectory, this.outputDir) });
   }
-  async bundle(entryFile, outputDirectory) {
+  async bundle(entryFile, outputDirectory, toolsPaths) {
     return this._bundle(
       this.getEntry(),
       entryFile,
       outputDirectory,
+      toolsPaths,
       join(outputDirectory, this.outputDir, "netlify", "functions", "api")
     );
   }
   getEntry() {
     return `
-import { handle } from 'hono/netlify'
-import { mastra } from '#mastra';
-import { createHonoServer } from '#server';
+    import { handle } from 'hono/netlify'
+    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 app = await createHonoServer(mastra);
+    registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
+      evaluate({
+        agentName,
+        input,
+        metric,
+        output,
+        runId,
+        globalRunId: runId,
+        instructions,
+      });
+    });
 
-export default handle(app)
+    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(),
+          },
+        });
+      }
+    });
+
+    const app = await createHonoServer(mastra);
+
+    export default handle(app)
 `;
   }
+  async lint(entryFile, outputDirectory, toolsPaths) {
+    await super.lint(entryFile, outputDirectory, toolsPaths);
+  }
 };
 
 export { NetlifyDeployer };

package/package.json

@@ -1,39 +1,51 @@
 {
   "name": "@mastra/deployer-netlify",
-  "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"
+      }
     },
     "./package.json": "./package.json"
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
+  "license": "Elastic-2.0",
   "dependencies": {
     "@rollup/plugin-virtual": "^3.0.2",
     "date-fns": "^4.1.0",
-    "execa": "^9.3.1",
-    "netlify-cli": "^18.0.1",
-    "zod": "^3.24.1",
-    "@mastra/core": "^0.0.0-storage-20250225005900",
-    "@mastra/deployer": "^0.0.0-storage-20250225005900"
+    "execa": "^9.5.2",
+    "netlify-cli": "^19.0.3",
+    "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 --format esm --experimental-dts --clean --treeshake",
+    "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
     "build:watch": "pnpm build --watch",
-    "test": "vitest run"
+    "test": "vitest run",
+    "lint": "eslint ."
   }
 }

package/.turbo/turbo-build.log

@@ -1,19 +0,0 @@
-
-
-> @mastra/deployer-netlify@0.1.5-alpha.1 build /Users/ward/projects/mastra/mastra/deployers/netlify
-> tsup src/index.ts --format esm --experimental-dts --clean --treeshake
-
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.3.6
-TSC Build start
-TSC ⚡️ Build success in 1897ms
-DTS Build start
-CLI Target: es2022
-Analysis will use the bundled TypeScript version 5.7.3
-Writing package typings: /Users/ward/projects/mastra/mastra/deployers/netlify/dist/_tsup-dts-rollup.d.ts
-DTS ⚡️ Build success in 1236ms
-CLI Cleaning output folder
-ESM Build start
-ESM dist/index.js 3.47 KB
-ESM ⚡️ Build success in 67ms