mastra 0.2.0-alpha.159 → 0.2.0-alpha.160

package/dist/analytics/index.d.ts

@@ -0,0 +1,32 @@
+declare class PosthogAnalytics {
+    private sessionId;
+    private client?;
+    private distinctId;
+    private version;
+    constructor({ version, apiKey, host, }: {
+        version: string;
+        apiKey: string;
+        host: string;
+    });
+    private writeCliConfig;
+    private initializePostHog;
+    private isTelemetryEnabled;
+    private getDistinctId;
+    private getSystemProperties;
+    private captureSessionStart;
+    trackCommand(options: {
+        command: string;
+        args?: Record<string, unknown>;
+        durationMs?: number;
+        status?: 'success' | 'error';
+        error?: string;
+    }): void;
+    trackCommandExecution<T>({ command, args, execution, }: {
+        command: string;
+        args: Record<string, unknown>;
+        execution: () => Promise<T>;
+    }): Promise<T>;
+    shutdown(): Promise<void>;
+}
+
+export { PosthogAnalytics };

package/dist/analytics/index.js

@@ -0,0 +1 @@
+export { PosthogAnalytics } from '../chunk-K5HPNH5H.js';

package/dist/chunk-K5HPNH5H.js

@@ -0,0 +1,170 @@
+import { randomUUID } from 'crypto';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import os from 'os';
+import path from 'path';
+import { PostHog } from 'posthog-node';
+import { fileURLToPath } from 'url';
+
+// src/analytics/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var PosthogAnalytics = class {
+  sessionId;
+  client;
+  distinctId;
+  version;
+  constructor({
+    version,
+    apiKey,
+    host = "https://app.posthog.com"
+  }) {
+    this.version = version;
+    const cliConfigPath = path.join(__dirname, "mastra-cli.json");
+    if (existsSync(cliConfigPath)) {
+      try {
+        const { distinctId, sessionId } = JSON.parse(readFileSync(cliConfigPath, "utf-8"));
+        this.distinctId = distinctId;
+        this.sessionId = sessionId;
+      } catch (e) {
+        this.sessionId = randomUUID();
+        this.distinctId = this.getDistinctId();
+      }
+      this.writeCliConfig({
+        distinctId: this.distinctId,
+        sessionId: this.sessionId
+      });
+    } else {
+      this.sessionId = randomUUID();
+      this.distinctId = this.getDistinctId();
+      this.writeCliConfig({
+        distinctId: this.distinctId,
+        sessionId: this.sessionId
+      });
+    }
+    if (this.isTelemetryEnabled()) {
+      this.initializePostHog(apiKey, host);
+    }
+  }
+  writeCliConfig({ distinctId, sessionId }) {
+    try {
+      writeFileSync(path.join(__dirname, "mastra-cli.json"), JSON.stringify({ distinctId, sessionId }));
+    } catch (e) {
+    }
+  }
+  initializePostHog(apiKey, host) {
+    this.client = new PostHog(apiKey, {
+      host,
+      flushAt: 1,
+      flushInterval: 0
+    });
+    this.captureSessionStart();
+    process.on("exit", () => {
+      this.client?.flush();
+    });
+  }
+  isTelemetryEnabled() {
+    if (process.env.NO_MASTRA_TELEMETRY) {
+      return false;
+    }
+    return true;
+  }
+  getDistinctId() {
+    const machineId = os.hostname();
+    return `mastra-${machineId}`;
+  }
+  getSystemProperties() {
+    return {
+      os: process.platform,
+      os_version: os.release(),
+      node_version: process.version,
+      platform: process.arch,
+      session_id: this.sessionId,
+      cli_version: this.version || "unknown",
+      machine_id: os.hostname()
+    };
+  }
+  captureSessionStart() {
+    if (!this.client) {
+      return;
+    }
+    this.client.capture({
+      distinctId: this.distinctId,
+      event: "cli_session_start",
+      properties: {
+        ...this.getSystemProperties()
+      }
+    });
+  }
+  trackCommand(options) {
+    try {
+      if (!this.client) {
+        return;
+      }
+      const commandData = {
+        command: options.command,
+        status: options.status || "success"
+      };
+      if (options.args) {
+        commandData.args = options.args;
+      }
+      if (options.durationMs) {
+        commandData.durationMs = options.durationMs;
+      }
+      if (options.error) {
+        commandData.error = options.error;
+      }
+      this.client.capture({
+        distinctId: this.distinctId,
+        event: "cli_command",
+        properties: {
+          ...this.getSystemProperties(),
+          ...commandData
+        }
+      });
+    } catch (e) {
+    }
+  }
+  // Helper method to wrap command execution with timing
+  async trackCommandExecution({
+    command,
+    args,
+    execution
+  }) {
+    const startTime = process.hrtime();
+    try {
+      const result = await execution();
+      const [seconds, nanoseconds] = process.hrtime(startTime);
+      const durationMs = seconds * 1e3 + nanoseconds / 1e6;
+      this.trackCommand({
+        command,
+        args,
+        durationMs,
+        status: "success"
+      });
+      return result;
+    } catch (error) {
+      const [seconds, nanoseconds] = process.hrtime(startTime);
+      const durationMs = seconds * 1e3 + nanoseconds / 1e6;
+      this.trackCommand({
+        command,
+        args,
+        durationMs,
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  // Ensure PostHog client is shutdown properly
+  async shutdown() {
+    if (!this.client) {
+      return;
+    }
+    try {
+      await this.client.shutdown();
+    } catch (e) {
+    }
+  }
+};
+
+export { PosthogAnalytics };