@mastra/deployer 0.10.13 → 0.10.15-alpha.0

package/dist/services/index.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunkKCP5ITLV_cjs = require('../chunk-KCP5ITLV.cjs');
+
+
+
+Object.defineProperty(exports, "DepsService", {
+  enumerable: true,
+  get: function () { return chunkKCP5ITLV_cjs.DepsService; }
+});
+Object.defineProperty(exports, "EnvService", {
+  enumerable: true,
+  get: function () { return chunkKCP5ITLV_cjs.EnvService; }
+});
+Object.defineProperty(exports, "FileService", {
+  enumerable: true,
+  get: function () { return chunkKCP5ITLV_cjs.FileService; }
+});

package/dist/services/index.d.cts

@@ -0,0 +1,3 @@
+export { DepsService_alias_1 as DepsService } from '../_tsup-dts-rollup.cjs';
+export { EnvService_alias_1 as EnvService } from '../_tsup-dts-rollup.cjs';
+export { FileService_alias_3 as FileService } from '../_tsup-dts-rollup.cjs';

package/dist/services/index.d.ts

@@ -0,0 +1,3 @@
+export { DepsService_alias_1 as DepsService } from '../_tsup-dts-rollup.js';
+export { EnvService_alias_1 as EnvService } from '../_tsup-dts-rollup.js';
+export { FileService_alias_3 as FileService } from '../_tsup-dts-rollup.js';

package/dist/services/index.js

@@ -0,0 +1 @@
+export { DepsService, EnvService, FileService } from '../chunk-GPD54HBC.js';

package/dist/templates/instrumentation-template.js

@@ -0,0 +1,137 @@
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { ExportResultCode } from '@opentelemetry/core';
+import { OTLPTraceExporter as OTLPGrpcExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
+import { OTLPTraceExporter as OTLPHttpExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import {
+  ParentBasedSampler,
+  TraceIdRatioBasedSampler,
+  AlwaysOnSampler,
+  AlwaysOffSampler,
+} from '@opentelemetry/sdk-trace-base';
+import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import { telemetry } from './telemetry-config.mjs';
+
+class CompositeExporter {
+  constructor(exporters) {
+    this.exporters = exporters;
+  }
+  export(spans, resultCallback) {
+    const telemetryTraceIds = new Set(
+      spans.filter((span) => {
+        const attrs = span.attributes || {};
+        const httpTarget = attrs["http.target"];
+        return httpTarget === "/api/telemetry";
+      }).map((span) => span.spanContext().traceId)
+    );
+    const filteredSpans = spans.filter((span) => !telemetryTraceIds.has(span.spanContext().traceId));
+    if (filteredSpans.length === 0) {
+      resultCallback({ code: ExportResultCode.SUCCESS });
+      return;
+    }
+    void Promise.all(
+      this.exporters.map(
+        (exporter) => new Promise((resolve) => {
+          if (exporter.export) {
+            exporter.export(filteredSpans, resolve);
+          } else {
+            resolve({ code: ExportResultCode.FAILED });
+          }
+        })
+      )
+    ).then((results) => {
+      const hasError = results.some((r) => r.code === ExportResultCode.FAILED);
+      resultCallback({
+        code: hasError ? ExportResultCode.FAILED : ExportResultCode.SUCCESS
+      });
+    }).catch((error) => {
+      console.error("[CompositeExporter] Export error:", error);
+      resultCallback({ code: ExportResultCode.FAILED, error });
+    });
+  }
+  shutdown() {
+    return Promise.all(this.exporters.map((e) => e.shutdown?.() ?? Promise.resolve())).then(() => void 0);
+  }
+  forceFlush() {
+    return Promise.all(this.exporters.map((e) => e.forceFlush?.() ?? Promise.resolve())).then(() => void 0);
+  }
+};
+
+function getSampler(config) {
+  if (!config.sampling) {
+    return new AlwaysOnSampler();
+  }
+
+  if (!config.enabled) {
+    return new AlwaysOffSampler();
+  }
+
+  switch (config.sampling.type) {
+    case 'ratio':
+      return new TraceIdRatioBasedSampler(config.sampling.probability);
+    case 'always_on':
+      return new AlwaysOnSampler();
+    case 'always_off':
+      return new AlwaysOffSampler();
+    case 'parent_based':
+      const rootSampler = new TraceIdRatioBasedSampler(config.sampling.root?.probability || 1.0);
+      return new ParentBasedSampler({ root: rootSampler });
+    default:
+      return new AlwaysOnSampler();
+  }
+}
+
+async function getExporters(config) {
+  const exporters = [];
+
+  // Add local exporter by default
+  if (!config.disableLocalExport) {
+    exporters.push(new OTLPHttpExporter({
+      url: `http://localhost:${process.env.PORT ?? 4111}/api/telemetry`,
+      headers: process.env.MASTRA_DEV ? {
+        'x-mastra-dev-playground': 'true',
+      } : {},
+    }));
+  }
+
+  if (config.export?.type === 'otlp') {
+    if (config.export?.protocol === 'grpc') {
+      exporters.push(new OTLPGrpcExporter({
+        url: config.export.endpoint,
+        headers: config.export.headers,
+      }));
+    } else {
+      exporters.push(new OTLPHttpExporter({
+        url: config.export.endpoint,
+        headers: config.export.headers,
+      }));
+    }
+  } else if (config.export?.type === 'custom') {
+    exporters.push(config.export.exporter);
+  }
+
+  return exporters
+}
+
+const sampler = getSampler(telemetry);
+const exporters = await getExporters(telemetry);
+const compositeExporter = new CompositeExporter(exporters);
+
+const sdk = new NodeSDK({
+  resource: resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: telemetry.serviceName || 'default-service',
+  }),
+  sampler,
+  traceExporter: compositeExporter,
+  instrumentations: [getNodeAutoInstrumentations()],
+});
+
+sdk.start();
+
+// gracefully shut down the SDK on process exit
+process.on('SIGTERM', () => {
+  sdk.shutdown().catch(() => {
+    // do nothing
+  });
+});

package/dist/validator/custom-resolver.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var promises = require('fs/promises');
+var module$1 = require('module');
+var path = require('path');
+var url = require('url');
+
+// src/validator/custom-resolver.ts
+var cache = /* @__PURE__ */ new Map();
+function isBuiltinModule(specifier) {
+  return module$1.builtinModules.includes(specifier) || specifier.startsWith("node:") || module$1.builtinModules.includes(specifier.replace(/^node:/, ""));
+}
+function isRelativePath(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || /^[a-zA-Z]:\\/.test(specifier);
+}
+async function getParentPath(specifier, url$1) {
+  if (!cache.size) {
+    const moduleResolveMap = JSON.parse(
+      // cwd refers to the output/build directory
+      await promises.readFile(path.join(process.cwd(), "module-resolve-map.json"), "utf-8")
+    );
+    for (const [id, rest] of Object.entries(moduleResolveMap)) {
+      cache.set(url.pathToFileURL(id).toString(), rest);
+    }
+  }
+  const importers = cache.get(url$1);
+  if (!importers || !importers[specifier]) {
+    return null;
+  }
+  const specifierParent = importers[specifier];
+  return url.pathToFileURL(specifierParent).toString();
+}
+async function resolve(specifier, context, nextResolve) {
+  if (isBuiltinModule(specifier)) {
+    return nextResolve(specifier, context);
+  }
+  if (isRelativePath(specifier)) {
+    return nextResolve(specifier, context);
+  }
+  if (context.parentURL) {
+    const parentPath = await getParentPath(specifier, context.parentURL);
+    if (parentPath) {
+      return nextResolve(specifier, {
+        ...context,
+        parentURL: parentPath
+      });
+    }
+  }
+  return nextResolve(specifier, context);
+}
+
+exports.resolve = resolve;

package/dist/validator/custom-resolver.d.cts

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

package/dist/validator/custom-resolver.d.ts

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

package/dist/validator/custom-resolver.js

@@ -0,0 +1,50 @@
+import { readFile } from 'fs/promises';
+import { builtinModules } from 'module';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+
+// src/validator/custom-resolver.ts
+var cache = /* @__PURE__ */ new Map();
+function isBuiltinModule(specifier) {
+  return builtinModules.includes(specifier) || specifier.startsWith("node:") || builtinModules.includes(specifier.replace(/^node:/, ""));
+}
+function isRelativePath(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || /^[a-zA-Z]:\\/.test(specifier);
+}
+async function getParentPath(specifier, url) {
+  if (!cache.size) {
+    const moduleResolveMap = JSON.parse(
+      // cwd refers to the output/build directory
+      await readFile(join(process.cwd(), "module-resolve-map.json"), "utf-8")
+    );
+    for (const [id, rest] of Object.entries(moduleResolveMap)) {
+      cache.set(pathToFileURL(id).toString(), rest);
+    }
+  }
+  const importers = cache.get(url);
+  if (!importers || !importers[specifier]) {
+    return null;
+  }
+  const specifierParent = importers[specifier];
+  return pathToFileURL(specifierParent).toString();
+}
+async function resolve(specifier, context, nextResolve) {
+  if (isBuiltinModule(specifier)) {
+    return nextResolve(specifier, context);
+  }
+  if (isRelativePath(specifier)) {
+    return nextResolve(specifier, context);
+  }
+  if (context.parentURL) {
+    const parentPath = await getParentPath(specifier, context.parentURL);
+    if (parentPath) {
+      return nextResolve(specifier, {
+        ...context,
+        parentURL: parentPath
+      });
+    }
+  }
+  return nextResolve(specifier, context);
+}
+
+export { resolve };

package/dist/validator/loader.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/validator/loader.ts
+module$1.register("./custom-resolver.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('loader.cjs', document.baseURI).href)));

package/dist/validator/loader.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/validator/loader.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validator/loader.js

@@ -0,0 +1,4 @@
+import { register } from 'module';
+
+// src/validator/loader.ts
+register("./custom-resolver.js", import.meta.url);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/deployer",
-  "version": "0.10.13",
+  "version": "0.10.15-alpha.0",
   "description": "",
   "type": "module",
   "files": [
@@ -108,7 +108,7 @@
     "rollup-plugin-node-externals": "^8.0.1",
     "typescript-paths": "^1.5.1",
     "zod": "^3.25.67",
-    "@mastra/server": "^0.10.13"
+    "@mastra/server": "^0.10.15-alpha.0"
   },
   "devDependencies": {
     "@hono/node-server": "^1.14.4",
@@ -118,7 +118,7 @@
     "@types/babel__helper-module-imports": "^7.18.3",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.19.0",
-    "eslint": "^9.29.0",
+    "eslint": "^9.30.1",
     "fetch-to-node": "^2.1.0",
     "hono-openapi": "^0.4.8",
     "rollup-plugin-visualizer": "^5.14.0",
@@ -127,9 +127,9 @@
     "type-fest": "^4.41.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@mastra/core": "0.10.13",
     "@internal/lint": "0.0.19",
-    "@mastra/mcp": "^0.10.6"
+    "@mastra/mcp": "^0.10.6",
+    "@mastra/core": "0.10.15-alpha.0"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.9-0 <0.11.0-0"