@mastra/deployer-cloud 0.14.2-alpha.2

package/LICENSE.md

@@ -0,0 +1,15 @@
+# Apache License 2.0
+
+Copyright (c) 2025 Kepler Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,176 @@
+# @mastra/deployer-cloud
+
+A cloud-optimized deployer for Mastra applications with built-in telemetry, logging, and storage integration.
+
+## Features
+
+- **Cloud-Native Integration**: Automatic setup for LibSQL storage and vector databases
+- **Advanced Logging**: Built-in PinoLogger with HTTP transport for cloud logging endpoints
+- **Telemetry & Monitoring**: OpenTelemetry instrumentation with readiness logging
+- **Evaluation Hooks**: Automatic agent evaluation tracking and storage
+- **Multi-Logger Support**: Combines cloud logging with existing application loggers
+- **Environment-Based Configuration**: Smart configuration based on deployment environment
+
+## Installation
+
+```bash
+pnpm add @mastra/deployer-cloud
+```
+
+## Usage
+
+The cloud deployer is used as part of the Mastra build process:
+
+```typescript
+import { CloudDeployer } from '@mastra/deployer-cloud';
+
+const deployer = new CloudDeployer();
+
+// Bundle your Mastra application
+await deployer.bundle(mastraDir, outputDirectory);
+
+// The deployer automatically:
+// - Adds cloud dependencies
+// - Sets up instrumentation
+// - Configures logging and storage
+```
+
+## What It Does
+
+### 1. Dependency Management
+
+Automatically adds cloud-specific dependencies to your package.json:
+
+- `@mastra/loggers` - Cloud-optimized logging
+- `@mastra/libsql` - Serverless SQL storage
+- `@mastra/cloud` - Cloud platform utilities
+
+### 2. Server Entry Generation
+
+Creates a production-ready server entry point with:
+
+- Cloud storage initialization (LibSQL)
+- Vector database setup
+- Multi-transport logging
+- Telemetry and monitoring
+- Evaluation hooks for agent metrics
+
+### 3. Instrumentation
+
+Provides OpenTelemetry instrumentation for:
+
+- Distributed tracing
+- Performance monitoring
+- Custom telemetry configuration
+
+## Environment Variables
+
+The deployer configures your application to use these environment variables:
+
+```bash
+# Storage Configuration
+MASTRA_STORAGE_URL=your-libsql-url
+MASTRA_STORAGE_AUTH_TOKEN=your-auth-token
+
+# Logging Configuration
+BUSINESS_API_RUNNER_LOGS_ENDPOINT=your-logs-endpoint
+BUSINESS_JWT_TOKEN=your-jwt-token
+
+# Runtime Configuration
+RUNNER_START_TIME=deployment-start-time
+CI=true|false
+
+# Deployment Metadata
+TEAM_ID=your-team-id
+PROJECT_ID=your-project-id
+BUILD_ID=your-build-id
+```
+
+## Generated Server Code
+
+The deployer generates a server entry that:
+
+1. **Initializes Logging**:
+   - Sets up PinoLogger with cloud transports
+   - Combines with existing application loggers
+   - Provides structured JSON logging
+
+2. **Configures Storage**:
+   - Initializes LibSQL store when credentials are provided
+   - Sets up vector database for semantic search
+   - Integrates with Mastra's memory system
+
+3. **Registers Hooks**:
+   - `ON_GENERATION` - Tracks agent generation metrics
+   - `ON_EVALUATION` - Stores evaluation results
+
+4. **Starts Server**:
+   - Creates Node.js server with Mastra configuration
+   - Disables playground and Swagger UI for production
+   - Exports tools for API access
+
+## Project Structure
+
+After deployment, your project will have:
+
+```
+output/
+├── instrumentation.mjs    # OpenTelemetry setup
+├── package.json          # With cloud dependencies
+├── index.mjs            # Main server entry
+├── mastra.mjs          # Your Mastra configuration
+└── tools/              # Exported tools
+```
+
+## Readiness Logging
+
+The deployer includes structured readiness logs for monitoring:
+
+```json
+{
+  "message": "Server starting|Server started|Runner Initialized",
+  "type": "READINESS",
+  "startTime": 1234567890,
+  "durationMs": 123,
+  "metadata": {
+    "teamId": "your-team-id",
+    "projectId": "your-project-id",
+    "buildId": "your-build-id"
+  }
+}
+```
+
+## Testing
+
+The cloud deployer includes comprehensive tests covering:
+
+- Build pipeline functionality
+- Server runtime generation
+- Dependency management
+- Error handling
+- Integration scenarios
+
+Run tests with:
+
+```bash
+pnpm test
+```
+
+## Development
+
+For local development:
+
+```bash
+# Build the deployer
+pnpm build
+
+# Run tests
+pnpm test
+
+# Lint code
+pnpm lint
+```
+
+## License
+
+Apache-2.0

package/dist/index.cjs

@@ -0,0 +1,488 @@
+'use strict';
+
+var url = require('url');
+var path = require('path');
+var deployer = require('@mastra/deployer');
+var fsExtra = require('fs-extra');
+var os = require('os');
+var fs = require('fs');
+var error = require('@mastra/core/error');
+var stream = require('stream');
+var execa = require('execa');
+var logger$1 = require('@mastra/core/logger');
+var loggers = require('@mastra/loggers');
+var redis = require('redis');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var os__default = /*#__PURE__*/_interopDefault(os);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+
+// src/index.ts
+
+// src/utils/auth.ts
+function getAuthEntrypoint() {
+  return `
+  import { MastraAuthProvider } from '@mastra/core/server';
+
+  class MastraCloudAuth extends MastraAuthProvider {
+    constructor (auth) {
+      super()
+      this.auth = auth
+    }
+
+    async authenticateToken (...args) {
+      if (typeof args[0] === 'string' && args[0].replace('Bearer ', '') === '${process.env.BUSINESS_JWT_TOKEN}') {
+        return { id: 'business-api' }
+      }
+      return this.auth.authenticateToken(...args)
+    }
+
+    async authorizeUser (...args) {
+      if (args[1] && args[1].path === '/api') {
+        return true
+      }
+      if (args[0] && args[0].id === 'business-api') {
+        return true
+      }
+      return this.auth.authorizeUser(...args)
+    }
+  }
+
+  const serverConfig = mastra.getServer()
+  if (serverConfig && serverConfig.experimental_auth) {
+    const auth = serverConfig.experimental_auth
+    serverConfig.experimental_auth = new MastraCloudAuth(auth)
+  }
+  `;
+}
+var LOCAL = process.env.LOCAL === "true";
+var TEAM_ID = process.env.TEAM_ID ?? "";
+var PROJECT_ID = process.env.PROJECT_ID ?? "";
+var BUILD_ID = process.env.BUILD_ID ?? "";
+var BUILD_URL = process.env.BUILD_URL ?? "";
+var LOG_REDIS_URL = process.env.LOG_REDIS_URL ?? "redis://localhost:6379";
+var USER_IP_ADDRESS = process.env.USER_IP_ADDRESS ?? "";
+var MASTRA_DIRECTORY = process.env.MASTRA_DIRECTORY ?? "src/mastra";
+var PROJECT_ENV_VARS = safelyParseJson(process.env.PROJECT_ENV_VARS ?? "{}");
+LOCAL ? os__default.default.tmpdir() + "/project" : process.env.PROJECT_ROOT ?? "/project";
+function safelyParseJson(json) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return {};
+  }
+}
+var redisClient = redis.createClient({
+  url: LOG_REDIS_URL
+});
+var RedisTransport = class extends logger$1.LoggerTransport {
+  _transform(chunk, _encoding, callback) {
+    chunk = chunk.toString();
+    const logKey = `builder:logs:${TEAM_ID}:${PROJECT_ID}:${BUILD_ID}`;
+    const ttl = 2 * 24 * 60 * 60;
+    const logData = typeof chunk === "string" ? chunk : JSON.stringify(chunk);
+    process.nextTick(async () => {
+      try {
+        if (!redisClient.isOpen) {
+          await redisClient.connect().catch((err) => {
+            console.error("Redis connection error:", err);
+          });
+        }
+        const pipeline = redisClient.multi();
+        pipeline.rPush(logKey, logData);
+        pipeline.expire(logKey, ttl);
+        await pipeline.exec();
+      } catch (err) {
+        console.error("Redis logging error:", err);
+      }
+    });
+    callback(null, chunk);
+  }
+  _write(chunk, encoding, callback) {
+    if (typeof callback === "function") {
+      this._transform(chunk, encoding || "utf8", callback);
+      return true;
+    }
+    this._transform(chunk, encoding || "utf8", (error) => {
+      if (error) console.error("Transform error in write:", error);
+    });
+    return true;
+  }
+  async _flush() {
+    await new Promise((resolve2) => setTimeout(resolve2, 10));
+  }
+  async _destroy(err, cb) {
+    await closeLogger();
+    cb(err);
+  }
+  getLogs(_args) {
+    return Promise.resolve({
+      logs: [],
+      total: 0,
+      page: _args?.page ?? 1,
+      perPage: _args?.perPage ?? 100,
+      hasMore: false
+    });
+  }
+  getLogsByRunId(_args) {
+    return Promise.resolve({
+      logs: [],
+      total: 0,
+      page: _args?.page ?? 1,
+      perPage: _args?.perPage ?? 100,
+      hasMore: false
+    });
+  }
+};
+var transport = new RedisTransport();
+var closeLogger = async () => {
+  if (redisClient.isOpen) {
+    setTimeout(async () => {
+      await redisClient.quit();
+    }, 10);
+  }
+};
+var logger = new loggers.PinoLogger({
+  level: "info",
+  transports: {
+    redis: transport
+  }
+});
+
+// src/utils/execa.ts
+var createPinoStream = () => {
+  return new stream.Transform({
+    transform(chunk, encoding, callback) {
+      const line = chunk.toString().trim();
+      if (line) {
+        logger.info(line);
+      }
+      callback(null, chunk);
+    }
+  });
+};
+async function runWithExeca({
+  cmd,
+  args,
+  cwd = process.cwd(),
+  env = PROJECT_ENV_VARS
+}) {
+  const pinoStream = createPinoStream();
+  try {
+    const subprocess = execa.execa(cmd, args, {
+      cwd,
+      env: {
+        ...process.env,
+        ...env
+      }
+    });
+    subprocess.stdout?.pipe(pinoStream);
+    subprocess.stderr?.pipe(pinoStream);
+    const { stdout, stderr, exitCode } = await subprocess;
+    return { stdout, stderr, success: exitCode === 0 };
+  } catch (error) {
+    logger.error(`Process failed: ${error}`);
+    return { success: false, error: error instanceof Error ? error : new Error(String(error)) };
+  }
+}
+
+// src/utils/deps.ts
+var MEMOIZED = /* @__PURE__ */ new Map();
+function findLockFile(dir) {
+  const lockFiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock"];
+  for (const file of lockFiles) {
+    if (fs__namespace.existsSync(path.join(dir, file))) {
+      return file;
+    }
+  }
+  const parentDir = path.resolve(dir, "..");
+  if (parentDir !== dir) {
+    return findLockFile(parentDir);
+  }
+  return null;
+}
+function detectPm({ path }) {
+  const cached = MEMOIZED.get(path);
+  if (cached) {
+    return cached;
+  }
+  const lockFile = findLockFile(path);
+  let pm = "npm";
+  switch (lockFile) {
+    case "pnpm-lock.yaml":
+      pm = "pnpm";
+      break;
+    case "package-lock.json":
+      pm = "npm";
+      break;
+    case "yarn.lock":
+      pm = "yarn";
+      break;
+    case "bun.lock":
+      pm = "bun";
+      break;
+    default:
+      pm = "npm";
+  }
+  MEMOIZED.set(path, pm);
+  return pm;
+}
+async function installDeps({ path, pm }) {
+  pm = pm ?? detectPm({ path });
+  logger.info(`Installing dependencies with ${pm} in ${path}`);
+  const args = ["install"];
+  const { success, error: error$1 } = await runWithExeca({ cmd: pm, args, cwd: path });
+  if (!success) {
+    throw new error.MastraError(
+      {
+        id: "FAIL_INSTALL_DEPS",
+        category: "USER",
+        domain: "DEPLOYER"
+      },
+      error$1
+    );
+  }
+}
+function getMastraEntryFile(mastraDir) {
+  try {
+    const fileService = new deployer.FileService();
+    return fileService.getFirstExistingFile([
+      path.join(mastraDir, MASTRA_DIRECTORY, "index.ts"),
+      path.join(mastraDir, MASTRA_DIRECTORY, "index.js")
+    ]);
+  } catch (error$1) {
+    throw new error.MastraError(
+      {
+        id: "MASTRA_ENTRY_FILE_NOT_FOUND",
+        category: "USER",
+        domain: "DEPLOYER"
+      },
+      error$1
+    );
+  }
+}
+
+// src/utils/report.ts
+function successEntrypoint() {
+  return `
+  if (process.env.CI !== 'true' && process.env.REPORTER_API_URL && process.env.REPORTER_API_URL_AUTH_TOKEN) {
+    await fetch(process.env.REPORTER_API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: \`Bearer \${process.env.REPORTER_API_URL_AUTH_TOKEN}\`,
+      },
+      body: JSON.stringify(${JSON.stringify({
+    projectId: PROJECT_ID,
+    buildId: BUILD_ID,
+    status: "success",
+    url: BUILD_URL,
+    userIpAddress: USER_IP_ADDRESS
+  })}),
+    }).catch(err => {
+      console.error('Failed to report build status to monitoring service', {
+        error: err,
+      });
+    })
+  }
+  `;
+}
+
+// src/index.ts
+var CloudDeployer = class extends deployer.Deployer {
+  constructor() {
+    super({ name: "cloud" });
+  }
+  async deploy(_outputDirectory) {
+  }
+  async writeInstrumentationFile(outputDirectory) {
+    const instrumentationFile = path.join(outputDirectory, "instrumentation.mjs");
+    const __dirname = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+    await fsExtra.copy(path.join(__dirname, "../templates", "instrumentation-template.js"), instrumentationFile);
+  }
+  writePackageJson(outputDirectory, dependencies) {
+    dependencies.set("@mastra/loggers", "0.10.6");
+    dependencies.set("@mastra/libsql", "0.13.1");
+    dependencies.set("@mastra/cloud", "0.1.7");
+    return super.writePackageJson(outputDirectory, dependencies);
+  }
+  async lint() {
+  }
+  async installDependencies(outputDirectory, _rootDir = process.cwd()) {
+    await installDeps({ path: path.join(outputDirectory, "output"), pm: "npm" });
+  }
+  async bundle(mastraDir, outputDirectory) {
+    const currentCwd = process.cwd();
+    process.chdir(mastraDir);
+    const mastraEntryFile = getMastraEntryFile(mastraDir);
+    const defaultToolsPath = path.join(mastraDir, MASTRA_DIRECTORY, "tools");
+    await this._bundle(this.getEntry(), mastraEntryFile, outputDirectory, [defaultToolsPath]);
+    process.chdir(currentCwd);
+  }
+  getAuthEntrypoint() {
+    return getAuthEntrypoint();
+  }
+  getEntry() {
+    return `
+import { createNodeServer, getToolExports } from '#server';
+import { tools } from '#tools';
+import { mastra } from '#mastra';
+import { MultiLogger } from '@mastra/core/logger';
+import { PinoLogger } from '@mastra/loggers';
+import { UpstashTransport } from '@mastra/loggers/upstash';
+import { HttpTransport } from '@mastra/loggers/http';
+import { evaluate } from '@mastra/core/eval';
+import { AvailableHooks, registerHook } from '@mastra/core/hooks';
+import { LibSQLStore, LibSQLVector } from '@mastra/libsql';
+
+const startTime = process.env.RUNNER_START_TIME ? new Date(process.env.RUNNER_START_TIME).getTime() : Date.now();
+const createNodeServerStartTime = Date.now();
+
+console.log(JSON.stringify({
+  message: "Server starting",
+  operation: 'builder.createNodeServer',
+  operation_startTime: createNodeServerStartTime,
+  type: "READINESS",
+  startTime,
+  metadata: {
+    teamId: "${TEAM_ID}",
+    projectId: "${PROJECT_ID}",
+    buildId: "${BUILD_ID}",
+  },
+}));
+
+const transports = {}
+if (process.env.CI !== 'true') {
+  if (process.env.BUSINESS_API_RUNNER_LOGS_ENDPOINT) {
+    transports.default = new HttpTransport({
+      url: process.env.BUSINESS_API_RUNNER_LOGS_ENDPOINT,
+      headers: {
+        Authorization: 'Bearer ' + process.env.BUSINESS_JWT_TOKEN,
+      },
+    });
+  }
+}
+
+const logger = new PinoLogger({
+  name: 'MastraCloud',
+  transports,
+  level: 'debug',
+});
+const existingLogger = mastra?.getLogger();
+const combinedLogger = existingLogger ? new MultiLogger([logger, existingLogger]) : logger;
+
+mastra.setLogger({ logger: combinedLogger });
+
+if (mastra?.storage) {
+  mastra.storage.init()
+}
+
+if (process.env.MASTRA_STORAGE_URL && process.env.MASTRA_STORAGE_AUTH_TOKEN) {
+  const { MastraStorage } = await import('@mastra/core/storage');
+  logger.info('Using Mastra Cloud Storage: ' + process.env.MASTRA_STORAGE_URL)
+  const storage = new LibSQLStore({
+    url: process.env.MASTRA_STORAGE_URL,
+    authToken: process.env.MASTRA_STORAGE_AUTH_TOKEN,
+  })
+  const vector = new LibSQLVector({
+    connectionUrl: process.env.MASTRA_STORAGE_URL,
+    authToken: process.env.MASTRA_STORAGE_AUTH_TOKEN,
+  })
+
+  await storage.init()
+  mastra?.setStorage(storage)
+
+  mastra?.memory?.setStorage(storage)
+  mastra?.memory?.setVector(vector)
+
+  registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
+    evaluate({
+      agentName,
+      input,
+      metric,
+      output,
+      runId,
+      globalRunId: runId,
+      instructions,
+    });
+  });
+  registerHook(AvailableHooks.ON_EVALUATION, async traceObject => {
+    if (mastra?.storage) {
+      await mastra.storage.insert({
+        tableName: MastraStorage.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(),
+        },
+      });
+    }
+  });
+}
+
+${getAuthEntrypoint()}
+
+await createNodeServer(mastra, { playground: false, swaggerUI: false, tools: getToolExports(tools) });
+
+${successEntrypoint()}
+
+console.log(JSON.stringify({
+  message: "Server started",
+  operation: 'builder.createNodeServer',
+  operation_startTime: createNodeServerStartTime,
+  operation_durationMs: Date.now() - createNodeServerStartTime,
+  type: "READINESS",
+  startTime,
+  metadata: {
+    teamId: "${TEAM_ID}",
+    projectId: "${PROJECT_ID}",
+    buildId: "${BUILD_ID}",
+  },
+}));
+
+
+console.log(JSON.stringify({
+  message: "Runner Initialized",
+  type: "READINESS",
+  startTime,
+  durationMs: Date.now() - startTime,
+  metadata: {
+    teamId: "${TEAM_ID}",
+    projectId: "${PROJECT_ID}",
+    buildId: "${BUILD_ID}",
+  },
+}));
+`;
+  }
+};
+
+exports.CloudDeployer = CloudDeployer;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map