life/dist/chunk-MLK5YGGI.mjs

Life.js is the first fullstack framework to build agentic web applications. It is minimal, extensible, and typesafe. Well, everything you love.

import {
  TelemetryClient,
  defineScopes,
  package_default
} from "./chunk-6CBODJTF.mjs";
import {
  agentServerConfig
} from "./chunk-XNMZQAOR.mjs";
import {
  failure,
  success
} from "./chunk-ZHBK6UTM.mjs";
import {
  __name
} from "./chunk-2D3UJWOA.mjs";

// telemetry/clients/node.ts
import { AsyncLocalStorage } from "async_hooks";
import os from "os";
import z from "zod";
var baseAgentServerAttributesSchema = z.object({
  agentName: z.string(),
  agentId: z.string(),
  agentSha: z.string(),
  agentConfig: agentServerConfig.schema.transform((c) => agentServerConfig.toTelemetry(c)),
  transportProviderName: z.string(),
  llmProviderName: z.string(),
  sttProviderName: z.string(),
  eouProviderName: z.string(),
  ttsProviderName: z.string(),
  vadProviderName: z.string()
});
var telemetryNodeScopesDefinition = defineScopes({
  compiler: {
    displayName: "Compiler",
    requiredAttributesSchema: z.object({
      watch: z.boolean()
    })
  },
  cli: {
    displayName: "CLI",
    requiredAttributesSchema: z.object({
      command: z.string(),
      // e.g. "dev", "build", "start", "init"
      args: z.array(z.string())
    })
  },
  server: {
    displayName: "Server",
    requiredAttributesSchema: z.object({
      watch: z.boolean()
    })
  },
  webrtc: {
    displayName: "WebRTC",
    requiredAttributesSchema: z.object()
  },
  "agent.process": {
    displayName: /* @__PURE__ */ __name((attributes) => `Agent Process (${attributes?.agentId?.replace("agent_", "").slice(0, 6)})`, "displayName"),
    requiredAttributesSchema: z.object({
      agentId: z.string()
    })
  },
  "agent.server": {
    displayName: /* @__PURE__ */ __name((attributes) => `Agent (${attributes?.agentName} - ${attributes?.agentId?.replace("agent_", "").slice(0, 6)})`, "displayName"),
    requiredAttributesSchema: baseAgentServerAttributesSchema
  },
  "plugin.server": {
    displayName: /* @__PURE__ */ __name((attributes) => `Plugin (${attributes?.pluginName})`, "displayName"),
    requiredAttributesSchema: baseAgentServerAttributesSchema.extend({
      pluginName: z.string(),
      pluginServerConfig: z.any()
    })
  }
});
var TelemetryNodeClient = class extends TelemetryClient {
  static {
    __name(this, "TelemetryNodeClient");
  }
  #spanDataContext = new AsyncLocalStorage();
  constructor(scope) {
    super(telemetryNodeScopesDefinition, scope);
  }
  getResource() {
    return {
      platform: "node",
      environment: process.env.NODE_ENV || "development",
      isCi: Boolean(process.env.CI),
      nodeVersion: process.version,
      lifeVersion: package_default.version,
      osName: os.platform(),
      osVersion: os.release(),
      cpuCount: os.cpus().length,
      cpuArchitecture: os.arch(),
      schemaVersion: "1"
    };
  }
  getCurrentSpanData() {
    return this.#spanDataContext.getStore();
  }
  runWithSpanData(spanData, fn) {
    return this.#spanDataContext.run(spanData, fn);
  }
};
function createTelemetryClient(scope, requiredAttributes) {
  const client = new TelemetryNodeClient(scope);
  for (const [key, value] of Object.entries(requiredAttributes)) client.setAttribute(key, value);
  return client;
}
__name(createTelemetryClient, "createTelemetryClient");

// telemetry/helpers/patch-console.ts
import chalk from "chalk";
var pipeConsoleToTelemetryClient = /* @__PURE__ */ __name((telemetry) => {
  const consoleMethods = ["log", "error", "warn", "info", "debug"];
  for (const method of consoleMethods) {
    console[method] = (...args) => {
      const logLine = args.map((arg) => String(arg)).join(" ");
      let logFn;
      if (method === "error") logFn = telemetry.log.error;
      else if (method === "warn") logFn = telemetry.log.warn;
      else if (method === "info") logFn = telemetry.log.info;
      else if (method === "debug") logFn = telemetry.log.debug;
      else logFn = telemetry.log.info;
      logFn({ message: `${chalk.italic.gray(`(from console.${method})`)} ${logLine}` });
    };
  }
}, "pipeConsoleToTelemetryClient");

// shared/process-stats.ts
import os2 from "os";
var ProcessStats = class {
  static {
    __name(this, "ProcessStats");
  }
  #lastCpuUsage = process.cpuUsage();
  #lastSampleTime = Date.now();
  #cpu = {
    usedPercent: 0,
    usedNs: 0
  };
  constructor() {
    this.#updateCpuStats();
    const interval = setInterval(() => this.#updateCpuStats(), 1e3);
    interval.unref();
  }
  #updateCpuStats() {
    const currentCpuUsage = process.cpuUsage();
    const currentTime = Date.now();
    const deltaTime = currentTime - this.#lastSampleTime;
    if (deltaTime > 0) {
      const deltaCpu = currentCpuUsage.user - this.#lastCpuUsage.user + (currentCpuUsage.system - this.#lastCpuUsage.system);
      const cpuPercent = deltaCpu / (deltaTime * 1e3) * 100;
      this.#cpu.usedPercent = Math.min(100, Math.max(0, cpuPercent));
    }
    this.#cpu.usedNs = (currentCpuUsage.user + currentCpuUsage.system) * 1e3;
    this.#lastCpuUsage = currentCpuUsage;
    this.#lastSampleTime = currentTime;
  }
  get() {
    try {
      const memoryUsed = process.memoryUsage().rss;
      const totalMemory = os2.totalmem();
      const freeMemory = os2.freemem();
      return success({
        cpu: this.#cpu,
        memory: {
          usedPercent: memoryUsed / totalMemory * 100,
          totalBytes: totalMemory,
          freeBytes: freeMemory,
          usedBytes: memoryUsed
        }
      });
    } catch (error) {
      return failure({ code: "Unknown", cause: error });
    }
  }
};

export {
  telemetryNodeScopesDefinition,
  TelemetryNodeClient,
  createTelemetryClient,
  pipeConsoleToTelemetryClient,
  ProcessStats
};
//# sourceMappingURL=chunk-MLK5YGGI.mjs.map