@uipath/common 0.2.0 → 0.9.0

package/dist/singleton.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Cross-bundle singleton primitive.
+ *
+ * Each tool bundles its own copy of @uipath/common, so module-level
+ * variables are isolated per bundle. This utility uses Symbol.for()
+ * keyed slots on globalThis to share state across all bundles.
+ *
+ * Usage:
+ *
+ *   // Class — name derived from constructor:
+ *   const logger = singleton(SimpleLogger);
+ *   logger.getOrInit(() => new SimpleLogger());
+ *
+ *   // Type alias or union — explicit name:
+ *   const format = singleton<OutputFormat>("OutputFormat");
+ *   format.set("json");
+ *   format.get("table");   // "json" (value takes precedence)
+ */
+export interface Singleton<T> {
+    /** Read the current value, or `fallback` when unset. */
+    get(fallback?: T): T | undefined;
+    /** Write a new value. */
+    set(value: T): void;
+    /** Reset to undefined. */
+    clear(): void;
+    /**
+     * Get the existing value, or initialise it with `factory()`.
+     * An optional `guard` validates existing values via duck-typing
+     * (needed because `instanceof` fails across bundles).
+     */
+    getOrInit(factory: () => T, guard?: (value: object) => boolean): T;
+}
+/**
+ * Create a typed singleton backed by `globalThis[Symbol.for(key)]`.
+ *
+ * @overload Pass a class constructor to derive the key from its name.
+ * @overload Pass a string key for non-class types (type aliases, unions).
+ *
+ * The key is auto-prefixed with `@uipath/common/`.
+ */
+export declare function singleton<T>(ctor: abstract new (...args: any[]) => T): Singleton<T>;
+export declare function singleton<T>(name: string): Singleton<T>;

package/dist/telemetry/browser-context-storage.d.ts

@@ -0,0 +1,29 @@
+import type { IContextStorage } from "./context-storage.js";
+/**
+ * Browser implementation of context storage using a stack-based approach.
+ *
+ * Unlike Node.js's AsyncLocalStorage which provides automatic context propagation,
+ * this implementation uses a simple stack to maintain context. The context remains
+ * available for the duration of the async operation because JavaScript is single-threaded
+ * and async operations are queued.
+ *
+ * @template TContext - The type of context to store
+ *
+ * @remarks
+ * This implementation works in browser environments without requiring zone.js.
+ * Context is maintained on a stack and is available until the async operation completes.
+ */
+export declare class BrowserContextStorage<TContext = unknown> implements IContextStorage<TContext> {
+    private contextStack;
+    /**
+     * Runs a function with the given context.
+     * Uses a stack-based approach to maintain context across async operations.
+     * The context remains available for the duration of the async operation.
+     */
+    run<T>(context: TContext, fn: () => T): T;
+    /**
+     * Gets the current context from the context stack.
+     * Returns undefined if no context is available (not within a run() block).
+     */
+    getContext(): TContext | undefined;
+}

package/dist/telemetry/console-telemetry-provider.d.ts

@@ -0,0 +1,12 @@
+import type { ITelemetryProvider } from "./telemetry-provider.js";
+import type { TelemetryProperties } from "./telemetry-service.js";
+/**
+ * A simple telemetry provider that logs events to the console.
+ * Useful for development and testing. Browser-safe (no Node API dependencies).
+ */
+export declare class ConsoleTelemetryProvider implements ITelemetryProvider {
+    trackEvent(eventName: string, _properties?: TelemetryProperties): Promise<void>;
+    trackException(error: Error, _properties?: TelemetryProperties): Promise<void>;
+    trackRequest(name: string, duration: number, success: boolean, _properties?: TelemetryProperties): Promise<void>;
+    trackDependency(name: string, type: string, duration: number, success: boolean, _properties?: TelemetryProperties): Promise<void>;
+}

package/dist/telemetry/context-storage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Interface for storing and retrieving context in async operations.
+ * @template TContext - The type of context to store
+ */
+export interface IContextStorage<TContext = unknown> {
+    /**
+     * Runs a function with a given context, making it available to all
+     * async operations within the execution tree.
+     * @param context - The context to store
+     * @param fn - The function to execute with this context
+     * @returns The result of the function
+     */
+    run<T>(context: TContext, fn: () => T): T;
+    /**
+     * Gets the current context for the executing async operation.
+     * @returns The current context, or undefined if not within a run() call
+     */
+    getContext(): TContext | undefined;
+}

package/dist/telemetry/debug-telemetry-provider.d.ts

@@ -0,0 +1,12 @@
+import type { ITelemetryProvider } from "./telemetry-provider.js";
+import type { TelemetryProperties } from "./telemetry-service.js";
+/**
+ * A simple telemetry provider that logs events via the shared logger.
+ * Useful for development and testing.
+ */
+export declare class DebugTelemetryProvider implements ITelemetryProvider {
+    trackEvent(eventName: string, _properties?: TelemetryProperties): Promise<void>;
+    trackException(error: Error, _properties?: TelemetryProperties): Promise<void>;
+    trackRequest(name: string, duration: number, success: boolean, _properties?: TelemetryProperties): Promise<void>;
+    trackDependency(name: string, type: string, duration: number, success: boolean, _properties?: TelemetryProperties): Promise<void>;
+}

package/dist/telemetry/detect-agent.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Detect which AI coding agent (if any) is invoking the CLI
+ * by checking known environment variables.
+ *
+ * Tool-specific variables are checked first (most reliable),
+ * then the generic `AGENT` variable (emerging standard from
+ * https://github.com/agentsmd/agents.md/issues/136).
+ */
+/**
+ * Detect the AI coding agent invoking the CLI.
+ * Returns the agent identifier string, or `undefined` if no agent is detected.
+ */
+export declare function detectAgent(): string | undefined;

package/dist/telemetry/index.d.ts

@@ -0,0 +1,7 @@
+export { BrowserContextStorage } from "./browser-context-storage.js";
+export { ConsoleTelemetryProvider } from "./console-telemetry-provider.js";
+export type { IContextStorage } from "./context-storage.js";
+export { redactProperties, redactProperty } from "./pii-redactor.js";
+export type { ITelemetryProvider } from "./telemetry-provider.js";
+export type { ITelemetryService, TelemetryContext, TelemetryProperties, } from "./telemetry-service.js";
+export { TelemetryService } from "./telemetry-service.js";

package/dist/telemetry/index.js

@@ -0,0 +1,256 @@
+// src/telemetry/browser-context-storage.ts
+class BrowserContextStorage {
+  contextStack = [];
+  run(context, fn) {
+    this.contextStack.push(context);
+    try {
+      const result = fn();
+      if (result !== null && typeof result === "object" && typeof result.then === "function") {
+        return result.finally(() => {
+          this.contextStack.pop();
+        });
+      }
+      this.contextStack.pop();
+      return result;
+    } catch (error) {
+      this.contextStack.pop();
+      throw error;
+    }
+  }
+  getContext() {
+    return this.contextStack.length > 0 ? this.contextStack[this.contextStack.length - 1] : undefined;
+  }
+}
+// src/telemetry/console-telemetry-provider.ts
+class ConsoleTelemetryProvider {
+  async trackEvent(eventName, _properties) {
+    console.debug(`[Telemetry] Event: ${eventName}`);
+  }
+  async trackException(error, _properties) {
+    console.error(`[Telemetry] Exception: ${error.message}`);
+  }
+  async trackRequest(name, duration, success, _properties) {
+    console.debug(`[Telemetry] Request: ${name} (${duration}ms, ${success ? "ok" : "fail"})`);
+  }
+  async trackDependency(name, type, duration, success, _properties) {
+    console.debug(`[Telemetry] Dependency: ${name} [${type}] (${duration}ms, ${success ? "ok" : "fail"})`);
+  }
+}
+// src/telemetry/pii-redactor.ts
+var REDACTED = "[REDACTED]";
+var MAX_VALUE_LENGTH = 200;
+var SENSITIVE_NAME_TOKENS = new Set([
+  "token",
+  "tokens",
+  "secret",
+  "secrets",
+  "password",
+  "passwords",
+  "pwd",
+  "credential",
+  "credentials",
+  "auth",
+  "authentication",
+  "authorization",
+  "authority",
+  "cert",
+  "certificate",
+  "certificates"
+]);
+var SENSITIVE_KEY_PREFIXES = new Set([
+  "api",
+  "access",
+  "client",
+  "private",
+  "public",
+  "signing",
+  "encryption",
+  "session",
+  "master",
+  "shared",
+  "root",
+  "ssh",
+  "rsa",
+  "aes",
+  "hmac",
+  "oauth"
+]);
+var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+var EMAIL_PATTERN = /\b[^\s@]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
+var USER_HOME_PATTERN = /([/\\])(Users|home)([/\\])([^/\\]+)/gi;
+var URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
+var URL_TRAILING_PUNCT = /[.,;:!?)\]}>'"]+$/;
+function shortHash(input) {
+  let hash = 2166136261;
+  for (let i = 0;i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function redactUrl(raw) {
+  try {
+    const url = new URL(raw);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return `url#${shortHash(raw)}`;
+  }
+}
+function redactValueDetectors(value) {
+  let out = value;
+  out = out.replace(JWT_PATTERN, () => REDACTED);
+  out = out.replace(URL_PATTERN, (match) => {
+    const trailing = match.match(URL_TRAILING_PUNCT)?.[0] ?? "";
+    const core = trailing ? match.slice(0, -trailing.length) : match;
+    return `${redactUrl(core)}${trailing}`;
+  });
+  out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
+  out = out.replace(EMAIL_PATTERN, (match) => `email#${shortHash(match)}`);
+  out = out.replace(UUID_PATTERN, (match) => `uuid#${shortHash(match)}`);
+  out = out.replace(LONG_TOKEN_PATTERN, () => REDACTED);
+  if (out.length > MAX_VALUE_LENGTH) {
+    out = `${out.slice(0, MAX_VALUE_LENGTH)}…`;
+  }
+  return out;
+}
+function nameTokens(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((t) => t.toLowerCase()).filter(Boolean);
+}
+function isSensitiveName(name) {
+  const tokens = nameTokens(name);
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (SENSITIVE_NAME_TOKENS.has(token)) {
+      return true;
+    }
+    if (token === "key" || token === "keys") {
+      const prev = tokens[i - 1];
+      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function redactProperty(name, value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (isSensitiveName(name)) {
+    return REDACTED;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return "[OBJECT]";
+  }
+  return redactValueDetectors(value);
+}
+function redactProperties(properties) {
+  const out = {};
+  for (const [name, value] of Object.entries(properties)) {
+    const redacted = redactProperty(name, value);
+    if (redacted !== undefined) {
+      out[name] = redacted;
+    }
+  }
+  return out;
+}
+// src/telemetry/telemetry-service.ts
+class TelemetryService {
+  telemetryProvider;
+  contextStorage;
+  operationId;
+  defaultProperties;
+  constructor(telemetryProvider, contextStorage) {
+    this.telemetryProvider = telemetryProvider;
+    this.contextStorage = contextStorage;
+  }
+  setOperationId(operationId) {
+    this.operationId = operationId;
+  }
+  setProvider(provider) {
+    this.telemetryProvider = provider;
+  }
+  setDefaultProperties(properties) {
+    this.defaultProperties = properties;
+  }
+  trackEvent(name, properties) {
+    const context = this.getCurrentContext();
+    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+    this.telemetryProvider.trackEvent(name, enrichedProperties);
+  }
+  trackException(error, properties) {
+    const context = this.getCurrentContext();
+    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+    this.telemetryProvider.trackException(error, enrichedProperties);
+  }
+  async trackRequest(name, fn, properties) {
+    const context = {
+      operationId: this.operationId ?? this.generateId(),
+      id: this.generateId()
+    };
+    const startTime = performance.now();
+    try {
+      const result = await this.contextStorage.run(context, fn);
+      const durationMs = performance.now() - startTime;
+      const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+      await this.telemetryProvider.trackRequest(name, durationMs, true, enrichedProperties);
+      return result;
+    } catch (error) {
+      const durationMs = performance.now() - startTime;
+      const err = error instanceof Error ? error : new Error(String(error));
+      const enrichedProperties = this.enrichPropertiesWithContext({ ...properties, errorMessage: err.message }, context);
+      await this.telemetryProvider.trackRequest(name, durationMs, false, enrichedProperties);
+      throw error;
+    }
+  }
+  async trackDependencyOperation(name, type, fn, properties) {
+    const parentContext = this.getCurrentContext();
+    if (!parentContext) {
+      throw new Error("trackDependencyOperation must be called within a trackRequest block.");
+    }
+    const childContext = {
+      operationId: parentContext.operationId,
+      parentId: parentContext.id,
+      id: this.generateId()
+    };
+    const startTime = performance.now();
+    try {
+      const result = await this.contextStorage.run(childContext, fn);
+      const durationMs = performance.now() - startTime;
+      const enrichedProperties = this.enrichPropertiesWithContext(properties, childContext);
+      await this.telemetryProvider.trackDependency(name, type, durationMs, true, enrichedProperties);
+      return result;
+    } catch (error) {
+      const durationMs = performance.now() - startTime;
+      const err = error instanceof Error ? error : new Error(String(error));
+      const enrichedProperties = this.enrichPropertiesWithContext({ ...properties, errorMessage: err.message }, childContext);
+      await this.telemetryProvider.trackDependency(name, type, durationMs, false, enrichedProperties);
+      throw error;
+    }
+  }
+  getCurrentContext() {
+    return this.contextStorage.getContext();
+  }
+  enrichPropertiesWithContext(properties, context) {
+    return {
+      ...this.defaultProperties,
+      ...properties,
+      ...context
+    };
+  }
+  generateId() {
+    return crypto.randomUUID().replaceAll("-", "");
+  }
+}
+export {
+  redactProperty,
+  redactProperties,
+  TelemetryService,
+  ConsoleTelemetryProvider,
+  BrowserContextStorage
+};

package/dist/telemetry/logger-telemetry-provider.d.ts

@@ -0,0 +1,15 @@
+import type { ITelemetryProvider } from "./telemetry-provider.js";
+import type { TelemetryProperties } from "./telemetry-service.js";
+/**
+ * Telemetry provider that enriches all events with analyticsUniqueId
+ * from the Windows registry and forwards them to the shared logger.
+ */
+export declare class LoggerTelemetryProvider implements ITelemetryProvider {
+    private readonly analyticsUniqueId;
+    constructor();
+    private enrich;
+    trackEvent(eventName: string, properties?: TelemetryProperties): Promise<void>;
+    trackException(error: Error, properties?: TelemetryProperties): Promise<void>;
+    trackRequest(name: string, duration: number, success: boolean, properties?: TelemetryProperties): Promise<void>;
+    trackDependency(name: string, type: string, duration: number, success: boolean, properties?: TelemetryProperties): Promise<void>;
+}

package/dist/telemetry/node-appinsights-telemetry-provider.d.ts

@@ -0,0 +1,62 @@
+import type { ITelemetryProvider } from "./telemetry-provider.js";
+import type { TelemetryProperties } from "./telemetry-service.js";
+export declare function setGlobalTelemetryProperties(properties: TelemetryProperties): void;
+export declare function getGlobalTelemetryProperties(): TelemetryProperties | undefined;
+/**
+ * Node.js Application Insights telemetry provider.
+ * Uses the `applicationinsights` Node SDK (not the browser SDK).
+ *
+ * The provider is created asynchronously because `applicationinsights` is
+ * loaded via dynamic import — it may not be installed in all packages.
+ */
+export declare class NodeAppInsightsTelemetryProvider implements ITelemetryProvider {
+    private readonly connectionString;
+    private client;
+    private appInsightsModule;
+    private readonly _sessionId;
+    private initialized;
+    constructor(connectionString: string);
+    /**
+     * Initialize the provider by dynamically importing applicationinsights.
+     * Returns false if the package is not available.
+     */
+    initialize(): Promise<boolean>;
+    getSessionId(): string;
+    /**
+     * Set the Application Version context tag (`ai.application.ver`).
+     * Must be called after {@link initialize}.
+     */
+    setApplicationVersion(version: string): void;
+    /**
+     * Merge global default properties with per-call properties.
+     * Per-call properties take precedence over global defaults.
+     */
+    private mergeProperties;
+    trackEvent(eventName: string, properties?: TelemetryProperties): Promise<void>;
+    trackException(error: Error, properties?: TelemetryProperties): Promise<void>;
+    trackRequest(name: string, duration: number, success: boolean, properties?: TelemetryProperties): Promise<void>;
+    trackDependency(name: string, type: string, duration: number, success: boolean, properties?: TelemetryProperties): Promise<void>;
+    flush(): Promise<void>;
+    /**
+     * Dispose the Application Insights SDK so its internal channels,
+     * keep-alive sockets, and timers are closed — allowing the Node.js
+     * event loop to drain and the process to exit naturally.
+     *
+     * IMPORTANT: The caller must NOT call `process.exit()` after this.
+     * On Windows, forcing exit while libuv handles from the preceding
+     * `flush()` are still closing triggers
+     * `!(handle->flags & UV_HANDLE_CLOSING)` in `uv_async_send`.
+     * Instead, set `process.exitCode` and let the loop drain.
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Get or create the single shared provider instance.
+ * The first call creates the provider and stores it on globalThis;
+ * subsequent calls (from other bundled copies) return the same instance.
+ *
+ * Now async — must be awaited. Returns undefined if applicationinsights
+ * is not installed. Stores the init promise on globalThis to prevent
+ * concurrent callers from creating duplicate providers.
+ */
+export declare function getOrCreateProvider(connectionString: string): Promise<NodeAppInsightsTelemetryProvider | undefined>;

package/dist/telemetry/node-context-storage.d.ts

@@ -0,0 +1,11 @@
+import type { IContextStorage } from "./context-storage.js";
+/**
+ * Node.js implementation of context storage using AsyncLocalStorage.
+ * This provides proper async context propagation in Node.js environments.
+ * @template TContext - The type of context to store
+ */
+export declare class NodeContextStorage<TContext = unknown> implements IContextStorage<TContext> {
+    private readonly storage;
+    run<T>(context: TContext, fn: () => T): T;
+    getContext(): TContext | undefined;
+}

package/dist/telemetry/node.d.ts

@@ -0,0 +1,7 @@
+export type { IContextStorage } from "./context-storage.js";
+export { DebugTelemetryProvider } from "./debug-telemetry-provider.js";
+export { detectAgent } from "./detect-agent.js";
+export { NodeContextStorage } from "./node-context-storage.js";
+export type { ITelemetryProvider } from "./telemetry-provider.js";
+export type { ITelemetryService, TelemetryContext, TelemetryProperties, } from "./telemetry-service.js";
+export { TelemetryService } from "./telemetry-service.js";

package/dist/telemetry/pii-redactor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * PII redactor for telemetry property values.
+ *
+ * Two layers, applied in order:
+ *   1. Name-based hard redact — property names are split on camelCase,
+ *      snake_case, and kebab-case boundaries, then any token matches a
+ *      sensitive-word set (token/secret/password/pwd/credential/auth/
+ *      certificate) triggers [REDACTED]. `key` is only flagged when preceded
+ *      by a sensitive prefix (apiKey, accessKey, signingKey, …) so benign
+ *      names like sortKey, cacheKey, keyword pass through.
+ *   2. Value detectors — JWTs, UUIDs, emails, URLs, user-home paths are
+ *      rewritten to a non-reversible form (hash or structural redaction).
+ *      Long strings are truncated.
+ *
+ * The goal is defense in depth: even if a new sensitive option slips through
+ * without being added to the denylist, value detectors catch common shapes.
+ */
+type TelemetryValue = string | number | boolean;
+/**
+ * Redact a single telemetry property.
+ * Preserves the original value's type (number/boolean pass through unchanged);
+ * strings are scanned for sensitive shapes. Returns undefined for null/undefined
+ * so callers can drop the key.
+ */
+export declare function redactProperty(name: string, value: unknown): TelemetryValue | undefined;
+/**
+ * Redact an entire property bag. Preserves each value's native type
+ * (numbers stay numbers, booleans stay booleans) so downstream sinks like
+ * App Insights can still aggregate them as metrics. Undefined values are dropped.
+ */
+export declare function redactProperties(properties: Record<string, unknown>): Record<string, TelemetryValue>;
+export {};

package/dist/telemetry/telemetry-events.d.ts

@@ -0,0 +1,3 @@
+export declare const CommonTelemetryEvents: {
+    readonly Error: "uip.error";
+};

package/dist/telemetry/telemetry-init.d.ts

@@ -0,0 +1,53 @@
+import type { ITelemetryProvider, ITelemetryService } from "./node.js";
+import { type NodeAppInsightsTelemetryProvider } from "./node-appinsights-telemetry-provider.js";
+/**
+ * Create or retrieve the shared Node.js Application Insights telemetry provider.
+ * Uses globalThis to ensure all bundled copies share a single TelemetryClient.
+ * Returns undefined if the applicationinsights package is not installed.
+ */
+export declare function createAppInsightsProvider(): Promise<NodeAppInsightsTelemetryProvider | undefined>;
+/**
+ * Check whether telemetry is disabled via environment variable.
+ * Set UIPATH_TELEMETRY_DISABLED=1 or UIPATH_TELEMETRY_DISABLED=true to opt out.
+ */
+export declare function isTelemetryDisabled(): boolean;
+interface TelemetryProviderResult {
+    provider: ITelemetryProvider;
+    name: string;
+}
+/**
+ * Create the default telemetry provider (async).
+ * Uses Application Insights (Node SDK) by default, falls back to
+ * LoggerTelemetryProvider if telemetry is disabled, initialization
+ * fails, or the applicationinsights package is not installed.
+ *
+ * Returns both the provider and its name so callers can log which
+ * provider was selected without relying on module-level mutable state.
+ */
+export declare function createTelemetryProvider(): Promise<TelemetryProviderResult>;
+export declare const telemetry: ITelemetryService;
+export interface TelemetryInitOptions {
+    /** Application version — sets the standard `ai.application.ver` context tag. */
+    version?: string;
+    /** Custom dimensions added to every telemetry event. */
+    defaultProperties?: Record<string, string>;
+}
+/**
+ * Initialize telemetry with default properties.
+ * Call after logger is configured (e.g. after --log-file is processed).
+ *
+ * This is async — it awaits the dynamic import of applicationinsights.
+ * Must be awaited to ensure the correct provider is selected before
+ * telemetry events are tracked.
+ *
+ * The resulting TelemetryService instance is stored on globalThis so that
+ * tool bundles (which don't ship applicationinsights) can reuse it.
+ */
+export declare function telemetryInit(options?: TelemetryInitOptions): Promise<void>;
+/**
+ * Flush all buffered telemetry to the cloud.
+ * Must be awaited before the process exits to ensure delivery.
+ * Capped at FLUSH_SHUTDOWN_TIMEOUT_MS to avoid hanging on slow/unreachable endpoints.
+ */
+export declare function telemetryFlushAndShutdown(): Promise<void>;
+export {};

package/dist/telemetry/telemetry-provider.d.ts

@@ -0,0 +1,27 @@
+import type { TelemetryProperties } from "./telemetry-service.js";
+/**
+ * Interface for telemetry providers that can be injected into the solution packager.
+ * Providers are simple adapters that send pre-measured telemetry data to their backends.
+ */
+export interface ITelemetryProvider {
+    /**
+     * Track a custom event with optional properties.
+     */
+    trackEvent(eventName: string, properties?: TelemetryProperties): Promise<void>;
+    /**
+     * Track an exception with optional properties.
+     */
+    trackException(error: Error, properties?: TelemetryProperties): Promise<void>;
+    /**
+     * Track a completed request operation with measured duration.
+     */
+    trackRequest(name: string, duration: number, success: boolean, properties?: TelemetryProperties): Promise<void>;
+    /**
+     * Track a completed dependency operation with measured duration.
+     */
+    trackDependency(name: string, type: string, duration: number, success: boolean, properties?: TelemetryProperties): Promise<void>;
+    /**
+     * Get the current session ID, if available.
+     */
+    getSessionId?(): string | undefined;
+}