agent-relay 2.1.4 → 2.1.6

package/packages/telemetry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/telemetry",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "description": "Anonymous telemetry for Agent Relay usage analytics",
   "type": "module",
   "main": "dist/index.js",

package/packages/trajectory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/trajectory",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "description": "Trajectory integration utilities (trail/PDERO) for Relay",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/config": "2.1.4"
+    "@agent-relay/config": "2.1.6"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/user-directory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/user-directory",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "description": "User directory service for agent-relay (per-user credential storage)",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/resiliency": "2.1.4"
+    "@agent-relay/resiliency": "2.1.6"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/utils/dist/cjs/discovery.js

@@ -0,0 +1,328 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var discovery_exports = {};
+__export(discovery_exports, {
+  cloudApiRequest: () => cloudApiRequest,
+  detectCloudWorkspace: () => detectCloudWorkspace,
+  discoverAgentName: () => discoverAgentName,
+  discoverSocket: () => discoverSocket,
+  getCloudEnvironmentSummary: () => getCloudEnvironmentSummary,
+  getCloudOutboxPath: () => getCloudOutboxPath,
+  getCloudSocketPath: () => getCloudSocketPath,
+  getConnectionInfo: () => getConnectionInfo,
+  getWorkspaceStatus: () => getWorkspaceStatus,
+  isCloudWorkspace: () => isCloudWorkspace
+});
+module.exports = __toCommonJS(discovery_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_os = require("node:os");
+var import_config = require("@agent-relay/config");
+function detectCloudWorkspace() {
+  const workspaceId = process.env.WORKSPACE_ID;
+  const cloudApiUrl = process.env.CLOUD_API_URL;
+  if (!workspaceId || !cloudApiUrl) {
+    return null;
+  }
+  return {
+    workspaceId,
+    cloudApiUrl,
+    workspaceToken: process.env.WORKSPACE_TOKEN,
+    ownerUserId: process.env.WORKSPACE_OWNER_USER_ID
+  };
+}
+function isCloudWorkspace() {
+  return detectCloudWorkspace() !== null;
+}
+function getCloudSocketPath(workspaceId) {
+  return `/tmp/relay/${workspaceId}/sockets/daemon.sock`;
+}
+function getCloudOutboxPath(workspaceId, agentName) {
+  return `/tmp/relay/${workspaceId}/outbox/${agentName}`;
+}
+function getDataDir() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return (0, import_node_path.join)((0, import_node_os.homedir)(), "Library", "Application Support", "agent-relay");
+  } else if (platform === "win32") {
+    return (0, import_node_path.join)(process.env.APPDATA || (0, import_node_os.homedir)(), "agent-relay");
+  } else {
+    return (0, import_node_path.join)(
+      process.env.XDG_DATA_HOME || (0, import_node_path.join)((0, import_node_os.homedir)(), ".local", "share"),
+      "agent-relay"
+    );
+  }
+}
+function discoverSocket(options = {}) {
+  if (options.socketPath) {
+    const workspace2 = options.workspace ? {
+      workspaceId: options.workspace.workspaceId || "override",
+      cloudApiUrl: options.workspace.cloudApiUrl || ""
+    } : void 0;
+    return {
+      socketPath: options.socketPath,
+      project: workspace2?.workspaceId || "override",
+      source: "env",
+      isCloud: !!workspace2,
+      workspace: workspace2
+    };
+  }
+  const socketEnv = process.env.RELAY_SOCKET;
+  if (socketEnv) {
+    const workspace2 = detectCloudWorkspace();
+    return {
+      socketPath: socketEnv,
+      project: process.env.RELAY_PROJECT || workspace2?.workspaceId || "unknown",
+      source: "env",
+      isCloud: !!workspace2,
+      workspace: workspace2 || void 0
+    };
+  }
+  const workspace = detectCloudWorkspace();
+  if (workspace) {
+    const cloudSocket = getCloudSocketPath(workspace.workspaceId);
+    return {
+      socketPath: cloudSocket,
+      project: workspace.workspaceId,
+      source: "cloud",
+      isCloud: true,
+      workspace
+    };
+  }
+  const projectEnv = process.env.RELAY_PROJECT;
+  if (projectEnv) {
+    const dataDir2 = getDataDir();
+    const projectSocket = (0, import_node_path.join)(dataDir2, "projects", projectEnv, "daemon.sock");
+    return {
+      socketPath: projectSocket,
+      project: projectEnv,
+      source: "env",
+      isCloud: false
+    };
+  }
+  const projectRoot = (0, import_config.findProjectRoot)(process.cwd());
+  const searchDirs = [process.cwd()];
+  if (projectRoot && projectRoot !== process.cwd()) {
+    searchDirs.push(projectRoot);
+  }
+  for (const dir of searchDirs) {
+    const projectLocalSocket = (0, import_node_path.join)(dir, ".agent-relay", "relay.sock");
+    if ((0, import_node_fs.existsSync)(projectLocalSocket)) {
+      let projectId = "local";
+      const markerPath = (0, import_node_path.join)(dir, ".agent-relay", ".project");
+      if ((0, import_node_fs.existsSync)(markerPath)) {
+        try {
+          const marker = JSON.parse((0, import_node_fs.readFileSync)(markerPath, "utf-8"));
+          projectId = marker.projectId || "local";
+        } catch {
+        }
+      }
+      return {
+        socketPath: projectLocalSocket,
+        project: projectId,
+        source: "cwd",
+        isCloud: false
+      };
+    }
+  }
+  const cwdConfig = (0, import_node_path.join)(process.cwd(), ".relay", "config.json");
+  if ((0, import_node_fs.existsSync)(cwdConfig)) {
+    try {
+      const config = JSON.parse((0, import_node_fs.readFileSync)(cwdConfig, "utf-8"));
+      if (config.socketPath) {
+        return {
+          socketPath: config.socketPath,
+          project: config.project || "local",
+          source: "cwd",
+          isCloud: false
+        };
+      }
+    } catch (err) {
+      if (process.env.DEBUG || process.env.RELAY_DEBUG) {
+        console.debug("[discovery] Failed to read cwd config:", cwdConfig, err);
+      }
+    }
+  }
+  const dataDir = getDataDir();
+  const projectsDir = (0, import_node_path.join)(dataDir, "projects");
+  if ((0, import_node_fs.existsSync)(projectsDir)) {
+    try {
+      const projects = (0, import_node_fs.readdirSync)(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      for (const project of projects) {
+        const socketPath = (0, import_node_path.join)(projectsDir, project, "daemon.sock");
+        if ((0, import_node_fs.existsSync)(socketPath)) {
+          return {
+            socketPath,
+            project,
+            source: "scan",
+            isCloud: false
+          };
+        }
+      }
+    } catch (err) {
+      if (process.env.DEBUG || process.env.RELAY_DEBUG) {
+        console.debug("[discovery] Failed to scan projects directory:", projectsDir, err);
+      }
+    }
+  }
+  return null;
+}
+async function cloudApiRequest(workspace, path, options = {}) {
+  const url = `${workspace.cloudApiUrl}${path}`;
+  const headers = {
+    "Content-Type": "application/json",
+    ...options.headers
+  };
+  if (workspace.workspaceToken) {
+    headers["Authorization"] = `Bearer ${workspace.workspaceToken}`;
+  }
+  return fetch(url, {
+    ...options,
+    headers
+  });
+}
+async function getWorkspaceStatus(workspace) {
+  try {
+    const response = await cloudApiRequest(
+      workspace,
+      `/api/workspaces/${workspace.workspaceId}/status`
+    );
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+function getConnectionInfo(options = {}) {
+  const discovery = discoverSocket(options);
+  if (!discovery) {
+    return null;
+  }
+  const info = {
+    socketPath: discovery.socketPath,
+    project: discovery.project,
+    isCloud: discovery.isCloud,
+    workspace: discovery.workspace
+  };
+  if (discovery.workspace?.cloudApiUrl) {
+    info.daemonUrl = discovery.workspace.cloudApiUrl;
+  }
+  return info;
+}
+function getCloudEnvironmentSummary() {
+  return {
+    WORKSPACE_ID: process.env.WORKSPACE_ID,
+    CLOUD_API_URL: process.env.CLOUD_API_URL,
+    WORKSPACE_TOKEN: process.env.WORKSPACE_TOKEN ? "[set]" : void 0,
+    WORKSPACE_OWNER_USER_ID: process.env.WORKSPACE_OWNER_USER_ID,
+    RELAY_SOCKET: process.env.RELAY_SOCKET,
+    RELAY_PROJECT: process.env.RELAY_PROJECT,
+    RELAY_AGENT_NAME: process.env.RELAY_AGENT_NAME
+  };
+}
+function discoverAgentName(_discovery) {
+  const envName = process.env.RELAY_AGENT_NAME;
+  if (envName) {
+    return envName;
+  }
+  const projectRoot = (0, import_config.findProjectRoot)(process.cwd());
+  const searchDirs = [process.cwd()];
+  if (projectRoot && projectRoot !== process.cwd()) {
+    searchDirs.push(projectRoot);
+  }
+  for (const dir of searchDirs) {
+    const relayDir = (0, import_node_path.join)(dir, ".agent-relay");
+    if (!(0, import_node_fs.existsSync)(relayDir)) continue;
+    const pidIdentityPath = (0, import_node_path.join)(relayDir, `mcp-identity-${process.ppid}`);
+    if ((0, import_node_fs.existsSync)(pidIdentityPath)) {
+      try {
+        const content = (0, import_node_fs.readFileSync)(pidIdentityPath, "utf-8").trim();
+        if (content) {
+          return content;
+        }
+      } catch {
+      }
+    }
+    try {
+      const files = (0, import_node_fs.readdirSync)(relayDir, { withFileTypes: true }).filter((d) => d.isFile() && d.name.startsWith("mcp-identity-")).map((d) => ({
+        path: (0, import_node_path.join)(relayDir, d.name),
+        name: d.name
+      }));
+      if (files.length > 0) {
+        const sorted = files.map((f) => {
+          try {
+            const stat = (0, import_node_fs.statSync)(f.path);
+            return { ...f, mtime: stat.mtimeMs };
+          } catch {
+            return { ...f, mtime: 0 };
+          }
+        }).sort((a, b) => b.mtime - a.mtime);
+        const latest = sorted[0];
+        if (latest) {
+          try {
+            const content = (0, import_node_fs.readFileSync)(latest.path, "utf-8").trim();
+            if (content) {
+              return content;
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    const identityPath = (0, import_node_path.join)(relayDir, "mcp-identity");
+    if ((0, import_node_fs.existsSync)(identityPath)) {
+      try {
+        const content = (0, import_node_fs.readFileSync)(identityPath, "utf-8").trim();
+        if (content) {
+          return content;
+        }
+      } catch {
+      }
+    }
+  }
+  for (const dir of searchDirs) {
+    const outboxDir = (0, import_node_path.join)(dir, ".agent-relay", "outbox");
+    if ((0, import_node_fs.existsSync)(outboxDir)) {
+      try {
+        const agents = (0, import_node_fs.readdirSync)(outboxDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        if (agents.length === 1) {
+          return agents[0];
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloudApiRequest,
+  detectCloudWorkspace,
+  discoverAgentName,
+  discoverSocket,
+  getCloudEnvironmentSummary,
+  getCloudOutboxPath,
+  getCloudSocketPath,
+  getConnectionInfo,
+  getWorkspaceStatus,
+  isCloudWorkspace
+});

package/packages/utils/dist/cjs/errors.js

@@ -0,0 +1,81 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  AgentNotFoundError: () => AgentNotFoundError,
+  ChannelNotFoundError: () => ChannelNotFoundError,
+  ConnectionError: () => ConnectionError,
+  DaemonNotRunningError: () => DaemonNotRunningError,
+  RelayError: () => RelayError,
+  SpawnError: () => SpawnError,
+  TimeoutError: () => TimeoutError
+});
+module.exports = __toCommonJS(errors_exports);
+class RelayError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RelayError";
+  }
+}
+class DaemonNotRunningError extends RelayError {
+  constructor(message) {
+    super(message || "Relay daemon is not running. Start with: agent-relay up");
+    this.name = "DaemonNotRunningError";
+  }
+}
+class AgentNotFoundError extends RelayError {
+  constructor(agentName) {
+    super(`Agent not found: ${agentName}`);
+    this.name = "AgentNotFoundError";
+  }
+}
+class TimeoutError extends RelayError {
+  constructor(operation, timeoutMs) {
+    super(`Timeout after ${timeoutMs}ms: ${operation}`);
+    this.name = "TimeoutError";
+  }
+}
+class ConnectionError extends RelayError {
+  constructor(message) {
+    super(`Connection error: ${message}`);
+    this.name = "ConnectionError";
+  }
+}
+class ChannelNotFoundError extends RelayError {
+  constructor(channel) {
+    super(`Channel not found: ${channel}`);
+    this.name = "ChannelNotFoundError";
+  }
+}
+class SpawnError extends RelayError {
+  constructor(workerName, reason) {
+    super(`Failed to spawn worker "${workerName}": ${reason}`);
+    this.name = "SpawnError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentNotFoundError,
+  ChannelNotFoundError,
+  ConnectionError,
+  DaemonNotRunningError,
+  RelayError,
+  SpawnError,
+  TimeoutError
+});

package/packages/utils/dist/discovery.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Socket Discovery & Cloud Workspace Detection
+ *
+ * Single source of truth for discovering relay daemon sockets,
+ * cloud workspace environments, and agent identity.
+ *
+ * Previously duplicated in @agent-relay/mcp (cloud.ts). Now consolidated
+ * here in the SDK so both SDK and MCP use the same discovery logic.
+ */
+export interface CloudWorkspace {
+    workspaceId: string;
+    cloudApiUrl: string;
+    workspaceToken?: string;
+    ownerUserId?: string;
+}
+export interface DiscoveryResult {
+    socketPath: string;
+    project: string;
+    source: 'env' | 'cloud' | 'cwd' | 'scan';
+    isCloud: boolean;
+    workspace?: CloudWorkspace;
+}
+export interface CloudConnectionOptions {
+    /** Override socket path (for testing) */
+    socketPath?: string;
+    /** Override workspace detection */
+    workspace?: Partial<CloudWorkspace>;
+}
+export interface CloudConnectionInfo {
+    socketPath: string;
+    project: string;
+    isCloud: boolean;
+    workspace?: CloudWorkspace;
+    daemonUrl?: string;
+}
+/**
+ * Detect if running in a cloud workspace environment.
+ *
+ * Cloud workspaces set these environment variables:
+ * - WORKSPACE_ID: The unique workspace identifier
+ * - CLOUD_API_URL: The cloud API endpoint
+ * - WORKSPACE_TOKEN: Bearer token for API auth (optional)
+ * - WORKSPACE_OWNER_USER_ID: The workspace owner's user ID (optional)
+ */
+export declare function detectCloudWorkspace(): CloudWorkspace | null;
+/**
+ * Check if we're running in a cloud workspace.
+ */
+export declare function isCloudWorkspace(): boolean;
+/**
+ * Get the workspace-namespaced socket path.
+ *
+ * In cloud workspaces, sockets are stored at:
+ * /tmp/relay/{WORKSPACE_ID}/sockets/daemon.sock
+ *
+ * This provides multi-tenant isolation on shared infrastructure.
+ */
+export declare function getCloudSocketPath(workspaceId: string): string;
+/**
+ * Get the workspace-namespaced outbox path.
+ *
+ * In cloud workspaces, outbox directories are at:
+ * /tmp/relay/{WORKSPACE_ID}/outbox/{agentName}/
+ */
+export declare function getCloudOutboxPath(workspaceId: string, agentName: string): string;
+/**
+ * Discover relay daemon socket with cloud-awareness.
+ *
+ * Priority order:
+ * 1. RELAY_SOCKET environment variable (explicit path)
+ * 2. Cloud workspace socket (if WORKSPACE_ID is set)
+ * 3. RELAY_PROJECT environment variable (project name -> data dir)
+ * 4. Current working directory .relay/config.json
+ * 5. Scan data directory for active sockets
+ *
+ * @param options - Optional configuration overrides
+ * @returns Discovery result with socket path, project info, and cloud status
+ */
+export declare function discoverSocket(options?: CloudConnectionOptions): DiscoveryResult | null;
+/**
+ * Make an authenticated request to the cloud API.
+ *
+ * @param workspace - Cloud workspace configuration
+ * @param path - API path (e.g., '/api/status')
+ * @param options - Fetch options
+ * @returns Response from the API
+ */
+export declare function cloudApiRequest(workspace: CloudWorkspace, path: string, options?: RequestInit): Promise<Response>;
+/**
+ * Get the workspace status from the cloud API.
+ */
+export declare function getWorkspaceStatus(workspace: CloudWorkspace): Promise<{
+    status: string;
+    agents?: string[];
+} | null>;
+/**
+ * Get connection info for the relay daemon.
+ *
+ * This function determines the best way to connect to the daemon:
+ * - In cloud environments: Uses workspace-namespaced socket
+ * - In local environments: Uses standard socket discovery
+ *
+ * @param options - Optional configuration overrides
+ * @returns Connection info or null if daemon not found
+ */
+export declare function getConnectionInfo(options?: CloudConnectionOptions): CloudConnectionInfo | null;
+/**
+ * Environment variable summary for debugging.
+ */
+export declare function getCloudEnvironmentSummary(): Record<string, string | undefined>;
+/**
+ * Discover the agent name for the MCP server.
+ *
+ * Priority order:
+ * 1. RELAY_AGENT_NAME environment variable (explicit)
+ * 2. Identity file in .agent-relay directory (written by wrapper)
+ * 3. Scan outbox directories to find agent's outbox
+ *
+ * @param _discovery - Optional discovery result (reserved for future use)
+ * @returns Agent name or null if not found
+ */
+export declare function discoverAgentName(_discovery?: DiscoveryResult | null): string | null;
+//# sourceMappingURL=discovery.d.ts.map

package/packages/utils/dist/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAWH,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,KAAK,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACrC,yCAAyC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAMD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,GAAG,IAAI,CAc5D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAMD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEjF;AAoBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,sBAA2B,GAAG,eAAe,GAAG,IAAI,CA+I3F;AAMD;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,cAAc,EACzB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,QAAQ,CAAC,CAgBnB;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,cAAc,GACxB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CAevD;AAMD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,sBAA2B,GACnC,mBAAmB,GAAG,IAAI,CAoB5B;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAU/E;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,CAAC,EAAE,eAAe,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAgHpF"}