@dexto/core 1.1.10 → 1.1.11

package/dist/resources/internal-provider.js

@@ -0,0 +1,117 @@
+import { logger } from "../logger/index.js";
+import { createInternalResourceHandler } from "./handlers/factory.js";
+import { InternalResourceConfigSchema } from "./schemas.js";
+import { ResourceError } from "./errors.js";
+class InternalResourcesProvider {
+  config;
+  handlers = /* @__PURE__ */ new Map();
+  services;
+  constructor(config, services) {
+    this.config = config;
+    this.services = services;
+    logger.debug(
+      `InternalResourcesProvider initialized with config: ${JSON.stringify(config)}`
+    );
+  }
+  async initialize() {
+    if (!this.config.enabled || this.config.resources.length === 0) {
+      logger.debug("Internal resources disabled or no resources configured");
+      return;
+    }
+    for (const resourceConfig of this.config.resources) {
+      try {
+        const parsedConfig = InternalResourceConfigSchema.parse(resourceConfig);
+        const handler = createInternalResourceHandler(parsedConfig, this.services);
+        await handler.initialize(this.services);
+        this.handlers.set(resourceConfig.type, handler);
+        logger.debug(`Initialized ${resourceConfig.type} resource handler`);
+      } catch (error) {
+        logger.error(`Failed to initialize ${resourceConfig.type} resource handler`, error);
+      }
+    }
+    logger.debug(
+      `InternalResourcesProvider initialized with ${this.handlers.size} resource handlers`
+    );
+  }
+  getSource() {
+    return "internal";
+  }
+  async listResources() {
+    const allResources = [];
+    for (const [type, handler] of this.handlers.entries()) {
+      try {
+        const resources = await handler.listResources();
+        allResources.push(...resources);
+      } catch (error) {
+        logger.error(
+          `Failed to list resources from ${type} handler: ${error instanceof Error ? error.message : String(error)}`,
+          error
+        );
+      }
+    }
+    return allResources;
+  }
+  async hasResource(uri) {
+    for (const handler of this.handlers.values()) {
+      if (handler.canHandle(uri)) return true;
+    }
+    return false;
+  }
+  async readResource(uri) {
+    for (const [type, handler] of this.handlers.entries()) {
+      if (handler.canHandle(uri)) {
+        try {
+          return await handler.readResource(uri);
+        } catch (error) {
+          logger.error(
+            `Failed to read resource ${uri} from ${type} handler: ${error instanceof Error ? error.message : String(error)}`,
+            error
+          );
+          throw error;
+        }
+      }
+    }
+    throw ResourceError.noSuitableProvider(uri);
+  }
+  async refresh() {
+    for (const [type, handler] of this.handlers.entries()) {
+      if (handler.refresh) {
+        try {
+          await handler.refresh();
+          logger.debug(`Refreshed ${type} resource handler`);
+        } catch (error) {
+          logger.error(
+            `Failed to refresh ${type} resource handler: ${error instanceof Error ? error.message : String(error)}`,
+            error
+          );
+        }
+      }
+    }
+  }
+  async addResourceConfig(config) {
+    try {
+      const parsedConfig = InternalResourceConfigSchema.parse(config);
+      const handler = createInternalResourceHandler(parsedConfig, this.services);
+      await handler.initialize(this.services);
+      this.handlers.set(config.type, handler);
+      this.config.resources.push(parsedConfig);
+      logger.info(`Added new ${config.type} resource handler`);
+    } catch (error) {
+      logger.error(
+        `Failed to add ${config.type} resource handler: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+      throw error;
+    }
+  }
+  async removeResourceHandler(type) {
+    if (this.handlers.has(type)) {
+      this.handlers.delete(type);
+      this.config.resources = this.config.resources.filter((r) => r.type !== type);
+      logger.info(`Removed ${type} resource handler`);
+    }
+  }
+}
+export {
+  InternalResourcesProvider
+};

package/dist/resources/manager.cjs

@@ -0,0 +1,221 @@
+"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 manager_exports = {};
+__export(manager_exports, {
+  ResourceManager: () => ResourceManager
+});
+module.exports = __toCommonJS(manager_exports);
+var import_internal_provider = require("./internal-provider.js");
+var import_logger = require("../logger/index.js");
+var import_errors = require("./errors.js");
+var import_events = require("../events/index.js");
+class ResourceManager {
+  mcpManager;
+  internalResourcesProvider;
+  blobStore;
+  constructor(mcpManager, options) {
+    this.mcpManager = mcpManager;
+    this.blobStore = options.blobStore;
+    const services = {
+      blobStore: this.blobStore
+    };
+    const config = options.internalResourcesConfig;
+    if (config.enabled || config.resources.length > 0) {
+      this.internalResourcesProvider = new import_internal_provider.InternalResourcesProvider(config, services);
+    } else {
+      this.internalResourcesProvider = new import_internal_provider.InternalResourcesProvider(
+        { enabled: true, resources: [] },
+        services
+      );
+    }
+    this.setupNotificationListeners();
+    import_logger.logger.debug("ResourceManager initialized");
+  }
+  async initialize() {
+    if (this.internalResourcesProvider) {
+      await this.internalResourcesProvider.initialize();
+    }
+    import_logger.logger.debug("ResourceManager initialization complete");
+  }
+  getBlobStore() {
+    return this.blobStore;
+  }
+  deriveName(uri) {
+    const segments = uri.split(/[\\/]/).filter(Boolean);
+    const lastSegment = segments[segments.length - 1];
+    return lastSegment ?? uri;
+  }
+  async list() {
+    const resources = {};
+    try {
+      const mcpResources = await this.mcpManager.listAllResources();
+      for (const resource of mcpResources) {
+        const {
+          key,
+          serverName,
+          summary: { uri, name, description, mimeType }
+        } = resource;
+        const metadata = {
+          uri: key,
+          name: name ?? this.deriveName(uri),
+          description: description ?? `Resource from MCP server: ${serverName}`,
+          source: "mcp",
+          serverName,
+          metadata: {
+            originalUri: uri,
+            serverName
+          }
+        };
+        if (mimeType) {
+          metadata.mimeType = mimeType;
+        }
+        resources[key] = metadata;
+      }
+      if (mcpResources.length > 0) {
+        import_logger.logger.debug(
+          `\u{1F5C3}\uFE0F Resource discovery (MCP): ${mcpResources.length} resources across ${new Set(mcpResources.map((r) => r.serverName)).size} server(s)`
+        );
+      }
+    } catch (error) {
+      import_logger.logger.error(
+        `Failed to enumerate MCP resources: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (this.internalResourcesProvider) {
+      try {
+        const internalResources = await this.internalResourcesProvider.listResources();
+        for (const resource of internalResources) {
+          resources[resource.uri] = resource;
+        }
+        if (internalResources.length > 0) {
+          import_logger.logger.debug(
+            `\u{1F5C3}\uFE0F Resource discovery (internal): ${internalResources.length} resources`
+          );
+        }
+      } catch (error) {
+        import_logger.logger.error(
+          `Failed to enumerate internal resources: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return resources;
+  }
+  async has(uri) {
+    if (uri.startsWith("mcp:")) {
+      return this.mcpManager.hasResource(uri);
+    }
+    if (uri.startsWith("blob:")) {
+      try {
+        return await this.blobStore.exists(uri);
+      } catch (error) {
+        import_logger.logger.warn(
+          `BlobService exists check failed for ${uri}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return false;
+      }
+    }
+    if (!this.internalResourcesProvider) {
+      return false;
+    }
+    return await this.internalResourcesProvider.hasResource(uri);
+  }
+  async read(uri) {
+    import_logger.logger.debug(`\u{1F4D6} Reading resource: ${uri}`);
+    try {
+      if (uri.startsWith("mcp:")) {
+        const result2 = await this.mcpManager.readResource(uri);
+        import_logger.logger.debug(`\u2705 Successfully read MCP resource: ${uri}`);
+        return result2;
+      }
+      if (uri.startsWith("blob:")) {
+        const blob = await this.blobStore.retrieve(uri, "base64");
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: blob.metadata.mimeType,
+              blob: blob.data
+            }
+          ],
+          _meta: {
+            size: blob.metadata.size,
+            createdAt: blob.metadata.createdAt,
+            originalName: blob.metadata.originalName,
+            source: blob.metadata.source
+          }
+        };
+      }
+      if (!this.internalResourcesProvider) {
+        throw import_errors.ResourceError.providerNotInitialized("Internal", uri);
+      }
+      const result = await this.internalResourcesProvider.readResource(uri);
+      import_logger.logger.debug(`\u2705 Successfully read internal resource: ${uri}`);
+      return result;
+    } catch (error) {
+      import_logger.logger.error(
+        `\u274C Failed to read resource '${uri}': ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  async refresh() {
+    if (this.internalResourcesProvider) {
+      await this.internalResourcesProvider.refresh();
+    }
+    import_logger.logger.info("ResourceManager refreshed");
+  }
+  getInternalResourcesProvider() {
+    return this.internalResourcesProvider;
+  }
+  /**
+   * Set up listeners for MCP resource notifications to enable real-time updates
+   */
+  setupNotificationListeners() {
+    import_events.eventBus.on("dexto:mcpResourceUpdated", async (payload) => {
+      import_logger.logger.debug(
+        `\u{1F504} Resource updated notification: ${payload.resourceUri} from server '${payload.serverName}'`
+      );
+      import_events.eventBus.emit("dexto:resourceCacheInvalidated", {
+        resourceUri: payload.resourceUri,
+        serverName: payload.serverName,
+        action: "updated"
+      });
+    });
+    import_events.eventBus.on("dexto:mcpServerConnected", async (payload) => {
+      if (payload.success) {
+        import_logger.logger.debug(`\u{1F504} Server connected, resources may have changed: ${payload.name}`);
+        import_events.eventBus.emit("dexto:resourceCacheInvalidated", {
+          serverName: payload.name,
+          action: "server_connected"
+        });
+      }
+    });
+    import_events.eventBus.on("dexto:mcpServerRemoved", async (payload) => {
+      import_logger.logger.debug(`\u{1F504} Server removed, resources invalidated: ${payload.serverName}`);
+      import_events.eventBus.emit("dexto:resourceCacheInvalidated", {
+        serverName: payload.serverName,
+        action: "server_removed"
+      });
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResourceManager
+});

package/dist/resources/manager.d.ts

@@ -0,0 +1,29 @@
+import type { MCPManager } from '../mcp/manager.js';
+import type { ResourceSet } from './types.js';
+import { InternalResourcesProvider } from './internal-provider.js';
+import type { ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ValidatedInternalResourcesConfig } from './schemas.js';
+import type { BlobStore } from '../storage/blob/types.js';
+export interface ResourceManagerOptions {
+    internalResourcesConfig: ValidatedInternalResourcesConfig;
+    blobStore: BlobStore;
+}
+export declare class ResourceManager {
+    private readonly mcpManager;
+    private internalResourcesProvider?;
+    private readonly blobStore;
+    constructor(mcpManager: MCPManager, options: ResourceManagerOptions);
+    initialize(): Promise<void>;
+    getBlobStore(): BlobStore;
+    private deriveName;
+    list(): Promise<ResourceSet>;
+    has(uri: string): Promise<boolean>;
+    read(uri: string): Promise<ReadResourceResult>;
+    refresh(): Promise<void>;
+    getInternalResourcesProvider(): InternalResourcesProvider | undefined;
+    /**
+     * Set up listeners for MCP resource notifications to enable real-time updates
+     */
+    private setupNotificationListeners;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/resources/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/resources/manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,YAAY,CAAC;AAChE,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,cAAc,CAAC;AAKrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,MAAM,WAAW,sBAAsB;IACnC,uBAAuB,EAAE,gCAAgC,CAAC;IAC1D,SAAS,EAAE,SAAS,CAAC;CACxB;AAED,qBAAa,eAAe;IACxB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,yBAAyB,CAAC,CAA4B;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;gBAE1B,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,sBAAsB;IAyB7D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,YAAY,IAAI,SAAS;IAIzB,OAAO,CAAC,UAAU;IAMZ,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC;IA6D5B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA4C9C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B,4BAA4B,IAAI,yBAAyB,GAAG,SAAS;IAIrE;;OAEG;IACH,OAAO,CAAC,0BAA0B;CAkCrC"}

package/dist/resources/manager.js

@@ -0,0 +1,197 @@
+import { InternalResourcesProvider } from "./internal-provider.js";
+import { logger } from "../logger/index.js";
+import { ResourceError } from "./errors.js";
+import { eventBus } from "../events/index.js";
+class ResourceManager {
+  mcpManager;
+  internalResourcesProvider;
+  blobStore;
+  constructor(mcpManager, options) {
+    this.mcpManager = mcpManager;
+    this.blobStore = options.blobStore;
+    const services = {
+      blobStore: this.blobStore
+    };
+    const config = options.internalResourcesConfig;
+    if (config.enabled || config.resources.length > 0) {
+      this.internalResourcesProvider = new InternalResourcesProvider(config, services);
+    } else {
+      this.internalResourcesProvider = new InternalResourcesProvider(
+        { enabled: true, resources: [] },
+        services
+      );
+    }
+    this.setupNotificationListeners();
+    logger.debug("ResourceManager initialized");
+  }
+  async initialize() {
+    if (this.internalResourcesProvider) {
+      await this.internalResourcesProvider.initialize();
+    }
+    logger.debug("ResourceManager initialization complete");
+  }
+  getBlobStore() {
+    return this.blobStore;
+  }
+  deriveName(uri) {
+    const segments = uri.split(/[\\/]/).filter(Boolean);
+    const lastSegment = segments[segments.length - 1];
+    return lastSegment ?? uri;
+  }
+  async list() {
+    const resources = {};
+    try {
+      const mcpResources = await this.mcpManager.listAllResources();
+      for (const resource of mcpResources) {
+        const {
+          key,
+          serverName,
+          summary: { uri, name, description, mimeType }
+        } = resource;
+        const metadata = {
+          uri: key,
+          name: name ?? this.deriveName(uri),
+          description: description ?? `Resource from MCP server: ${serverName}`,
+          source: "mcp",
+          serverName,
+          metadata: {
+            originalUri: uri,
+            serverName
+          }
+        };
+        if (mimeType) {
+          metadata.mimeType = mimeType;
+        }
+        resources[key] = metadata;
+      }
+      if (mcpResources.length > 0) {
+        logger.debug(
+          `\u{1F5C3}\uFE0F Resource discovery (MCP): ${mcpResources.length} resources across ${new Set(mcpResources.map((r) => r.serverName)).size} server(s)`
+        );
+      }
+    } catch (error) {
+      logger.error(
+        `Failed to enumerate MCP resources: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (this.internalResourcesProvider) {
+      try {
+        const internalResources = await this.internalResourcesProvider.listResources();
+        for (const resource of internalResources) {
+          resources[resource.uri] = resource;
+        }
+        if (internalResources.length > 0) {
+          logger.debug(
+            `\u{1F5C3}\uFE0F Resource discovery (internal): ${internalResources.length} resources`
+          );
+        }
+      } catch (error) {
+        logger.error(
+          `Failed to enumerate internal resources: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return resources;
+  }
+  async has(uri) {
+    if (uri.startsWith("mcp:")) {
+      return this.mcpManager.hasResource(uri);
+    }
+    if (uri.startsWith("blob:")) {
+      try {
+        return await this.blobStore.exists(uri);
+      } catch (error) {
+        logger.warn(
+          `BlobService exists check failed for ${uri}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return false;
+      }
+    }
+    if (!this.internalResourcesProvider) {
+      return false;
+    }
+    return await this.internalResourcesProvider.hasResource(uri);
+  }
+  async read(uri) {
+    logger.debug(`\u{1F4D6} Reading resource: ${uri}`);
+    try {
+      if (uri.startsWith("mcp:")) {
+        const result2 = await this.mcpManager.readResource(uri);
+        logger.debug(`\u2705 Successfully read MCP resource: ${uri}`);
+        return result2;
+      }
+      if (uri.startsWith("blob:")) {
+        const blob = await this.blobStore.retrieve(uri, "base64");
+        return {
+          contents: [
+            {
+              uri,
+              mimeType: blob.metadata.mimeType,
+              blob: blob.data
+            }
+          ],
+          _meta: {
+            size: blob.metadata.size,
+            createdAt: blob.metadata.createdAt,
+            originalName: blob.metadata.originalName,
+            source: blob.metadata.source
+          }
+        };
+      }
+      if (!this.internalResourcesProvider) {
+        throw ResourceError.providerNotInitialized("Internal", uri);
+      }
+      const result = await this.internalResourcesProvider.readResource(uri);
+      logger.debug(`\u2705 Successfully read internal resource: ${uri}`);
+      return result;
+    } catch (error) {
+      logger.error(
+        `\u274C Failed to read resource '${uri}': ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  async refresh() {
+    if (this.internalResourcesProvider) {
+      await this.internalResourcesProvider.refresh();
+    }
+    logger.info("ResourceManager refreshed");
+  }
+  getInternalResourcesProvider() {
+    return this.internalResourcesProvider;
+  }
+  /**
+   * Set up listeners for MCP resource notifications to enable real-time updates
+   */
+  setupNotificationListeners() {
+    eventBus.on("dexto:mcpResourceUpdated", async (payload) => {
+      logger.debug(
+        `\u{1F504} Resource updated notification: ${payload.resourceUri} from server '${payload.serverName}'`
+      );
+      eventBus.emit("dexto:resourceCacheInvalidated", {
+        resourceUri: payload.resourceUri,
+        serverName: payload.serverName,
+        action: "updated"
+      });
+    });
+    eventBus.on("dexto:mcpServerConnected", async (payload) => {
+      if (payload.success) {
+        logger.debug(`\u{1F504} Server connected, resources may have changed: ${payload.name}`);
+        eventBus.emit("dexto:resourceCacheInvalidated", {
+          serverName: payload.name,
+          action: "server_connected"
+        });
+      }
+    });
+    eventBus.on("dexto:mcpServerRemoved", async (payload) => {
+      logger.debug(`\u{1F504} Server removed, resources invalidated: ${payload.serverName}`);
+      eventBus.emit("dexto:resourceCacheInvalidated", {
+        serverName: payload.serverName,
+        action: "server_removed"
+      });
+    });
+  }
+}
+export {
+  ResourceManager
+};