@ai-setting/roy-agent-core 1.5.15-test → 1.5.16-test

package/dist/shared/@ai-setting/roy-agent-core-xq8hhqb8.js

@@ -0,0 +1,419 @@
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  init_decorator
+} from "./roy-agent-core-zgypchmt.js";
+import {
+  createLogger,
+  init_logger,
+  setConfigComponent,
+  setQuietMode
+} from "./roy-agent-core-44hnfb02.js";
+import {
+  getTracerProvider,
+  init_propagation,
+  init_tracer_provider,
+  init_types,
+  propagation
+} from "./roy-agent-core-xs5rsgat.js";
+import {
+  SQLiteSpanStorage,
+  init_span_storage
+} from "./roy-agent-core-psv4v63c.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/log-trace/index.ts
+init_types();
+init_span_storage();
+
+// src/env/log-trace/log-trace-component.ts
+init_logger();
+init_tracer_provider();
+init_span_storage();
+import { z } from "zod";
+import { join } from "path";
+
+// src/env/log-trace/trace-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var contextStore = new AsyncLocalStorage;
+function createLightweightContext() {
+  return new LightweightTraceContext;
+}
+
+class LightweightTraceContext {
+  getRequestId() {
+    return contextStore.getStore()?.requestId;
+  }
+  getSpanContext() {
+    return contextStore.getStore()?.spanContext;
+  }
+  setSpanContext(spanContext) {
+    const store = contextStore.getStore();
+    if (store) {
+      store.spanContext = spanContext;
+    }
+  }
+  runWithContext(fn) {
+    const store = contextStore.getStore();
+    if (store) {
+      return contextStore.run(store, fn);
+    }
+    return fn();
+  }
+  runWithNewContext(requestId, sessionId, fn) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    return contextStore.run(context, fn);
+  }
+  async runWithContextAsync(fn) {
+    const store = contextStore.getStore();
+    if (store) {
+      return contextStore.run(store, fn);
+    }
+    return fn();
+  }
+  async runWithNewContextAsync(requestId, sessionId, fn) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    return contextStore.run(context, fn);
+  }
+  generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  generateSpanId() {
+    return `span_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  initContext(requestId, sessionId) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    contextStore.enterWith(context);
+  }
+  startNewContext(requestId, sessionId) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    const previousStore = contextStore.getStore();
+    contextStore.enterWith(context);
+    return () => {
+      contextStore.enterWith(previousStore);
+    };
+  }
+}
+var traceContextImpl = null;
+function initTraceContext(options) {
+  traceContextImpl = createLightweightContext();
+  return traceContextImpl;
+}
+
+// src/env/log-trace/log-trace-config-registration.ts
+var LOG_TRACE_DEFAULTS = {
+  "log-trace.logging.enabled": true,
+  "log-trace.logging.level": "info",
+  "log-trace.logging.quiet": false,
+  "log-trace.tracing.enabled": true
+};
+var LOG_TRACE_CONFIG_REGISTRATION = {
+  name: "log-trace",
+  sources: [
+    { type: "env", envPrefix: "LOG_TRACE", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "log-trace.logging.enabled", sources: ["env", "file"] },
+    { key: "log-trace.logging.level", sources: ["env", "file"] },
+    { key: "log-trace.logging.quiet", sources: ["env", "file"] },
+    { key: "log-trace.logging.dir", sources: ["env", "file"] },
+    { key: "log-trace.logging.file", sources: ["env", "file"] },
+    { key: "log-trace.logging.maxOutput", sources: ["env", "file"] },
+    { key: "log-trace.tracing.enabled", sources: ["env", "file"] },
+    { key: "log-trace.tracing.dbPath", sources: ["env", "file"] }
+  ]
+};
+
+// src/env/log-trace/log-trace-component.ts
+function getDefaultDataDir() {
+  try {
+    const xdg = __require("xdg-basedir");
+    if (xdg.xdgData) {
+      return xdg.xdgData;
+    }
+  } catch {}
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join(home, ".local", "share");
+}
+function getDefaultLogDir() {
+  return join(getDefaultDataDir(), "roy-agent", "logs");
+}
+function getDefaultSpanDbPath() {
+  return join(getDefaultDataDir(), "roy-agent", "traces.db");
+}
+var LogTraceConfigSchema = z.object({
+  logging: z.object({
+    enabled: z.boolean().default(true),
+    level: z.enum(["debug", "info", "warn", "error"]).default("info"),
+    quiet: z.boolean().default(false),
+    file: z.string().default("app.log"),
+    dir: z.string().default(getDefaultLogDir()),
+    maxOutput: z.number().default(0)
+  }).default({}),
+  tracing: z.object({
+    enabled: z.boolean().default(true),
+    dbPath: z.string().optional()
+  }).default({}),
+  initContext: z.object({
+    requestId: z.string().optional(),
+    sessionId: z.string().optional()
+  }).optional()
+});
+
+class LogTraceComponent extends BaseComponent {
+  name = "log-trace";
+  version = "1.0.0";
+  config;
+  configComponent;
+  tracer;
+  traceContext;
+  configWatcher;
+  constructor() {
+    super();
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for LogTraceComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    this.traceContext = initTraceContext();
+    const provider = getTracerProvider();
+    const _unused = provider;
+    await provider.initialize();
+    this.tracer = provider.getTracer("roy-tracer");
+    this.configureLogging();
+    if (this.config?.initContext?.requestId) {
+      this.traceContext.initContext(this.config.initContext.requestId, this.config.initContext.sessionId);
+    }
+    this.setStatus("running");
+  }
+  async registerConfig(options) {
+    const configComponent = options.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix !== undefined ? envPrefix : "LOG_TRACE";
+    configComponent.registerComponent(LOG_TRACE_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix: prefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("log-trace");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "log-trace");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(LOG_TRACE_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (configComponent.get("log-trace.logging.dir") === undefined) {
+      await configComponent.set("log-trace.logging.dir", getDefaultLogDir());
+    }
+    if (configComponent.get("log-trace.logging.file") === undefined) {
+      await configComponent.set("log-trace.logging.file", "app.log");
+    }
+    if (configComponent.get("log-trace.logging.maxOutput") === undefined) {
+      await configComponent.set("log-trace.logging.maxOutput", 0);
+    }
+    if (configComponent.get("log-trace.tracing.dbPath") === undefined) {
+      await configComponent.set("log-trace.tracing.dbPath", getDefaultSpanDbPath());
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+    setConfigComponent(configComponent);
+    const tracingDbPath = configComponent.get("log-trace.tracing.dbPath");
+    this.config = {
+      logging: {
+        enabled: configComponent.get("log-trace.logging.enabled") ?? true,
+        level: configComponent.get("log-trace.logging.level") ?? "info",
+        quiet: configComponent.get("log-trace.logging.quiet") ?? false,
+        file: configComponent.get("log-trace.logging.file") ?? "app.log",
+        dir: configComponent.get("log-trace.logging.dir") ?? getDefaultLogDir(),
+        maxOutput: configComponent.get("log-trace.logging.maxOutput") ?? 0
+      },
+      tracing: {
+        enabled: configComponent.get("log-trace.tracing.enabled") ?? true,
+        dbPath: tracingDbPath ?? getDefaultSpanDbPath()
+      }
+    };
+  }
+  flattenConfig(obj, prefix = "log-trace") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function") {
+      return;
+    }
+    this.configWatcher = configComponent.watch("log-trace.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    if (event.key === "log-trace.logging.quiet") {
+      setQuietMode(event.newValue);
+    }
+  }
+  createStorage() {
+    if (this.configComponent) {
+      const dbPath = this.configComponent.get("log-trace.tracing.dbPath");
+      if (dbPath) {
+        return new SQLiteSpanStorage(dbPath);
+      }
+    }
+    if (this.config?.tracing?.dbPath) {
+      return new SQLiteSpanStorage(this.config.tracing.dbPath);
+    }
+    return new SQLiteSpanStorage(getDefaultSpanDbPath());
+  }
+  configureLogging() {
+    if (!this.config?.logging)
+      return;
+    if (this.config.logging.quiet) {
+      setQuietMode(true);
+    }
+  }
+  initContext(requestId, sessionId) {
+    if (!this.traceContext) {
+      throw new Error("Component not initialized");
+    }
+    this.traceContext.initContext(requestId, sessionId);
+  }
+  startContext(requestId, sessionId) {
+    if (!this.traceContext) {
+      throw new Error("Component not initialized");
+    }
+    return this.traceContext.startNewContext(requestId, sessionId);
+  }
+  getLogger(prefix) {
+    return createLogger(prefix || "app");
+  }
+  getTracer() {
+    if (!this.tracer) {
+      throw new Error("Component not initialized");
+    }
+    return this.tracer;
+  }
+  getTraceContext() {
+    return this.traceContext;
+  }
+  getRequestId() {
+    return this.traceContext?.getRequestId();
+  }
+  async onStop() {
+    this.configWatcher?.();
+    this.configWatcher = undefined;
+    this.tracer = undefined;
+    this.setStatus("stopped");
+  }
+}
+
+// src/env/log-trace/index.ts
+init_tracer_provider();
+init_propagation();
+
+// src/env/log-trace/opentelemetry/propagation-env.ts
+init_propagation();
+init_tracer_provider();
+function injectToEnv(env = {}) {
+  const provider = getTracerProvider();
+  const tracer = provider.getTracer("roy-tracer");
+  tracer.injectToEnv(env);
+  return env;
+}
+function injectToEnvWithContext(env, context) {
+  propagation.inject(env, context);
+  return env;
+}
+function injectToEnvFromCarrier(target, source) {
+  const extracted = propagation.extract(source);
+  if (extracted) {
+    const context = {
+      traceId: extracted.traceId,
+      spanId: extracted.spanId,
+      parentSpanId: undefined
+    };
+    propagation.inject(target, context);
+  }
+  return target;
+}
+function getTraceparentHeader() {
+  return propagation.getTraceparentHeader();
+}
+
+// src/env/log-trace/index.ts
+init_logger();
+init_decorator();
+
+export { getDefaultLogDir, getDefaultSpanDbPath, LogTraceConfigSchema, LogTraceComponent, injectToEnv, injectToEnvWithContext, injectToEnvFromCarrier, getTraceparentHeader };