@eagi/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,498 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApprovalRequiredError: () => ApprovalRequiredError,
+  AuthError: () => AuthError,
+  DomainLoader: () => DomainLoader,
+  DomainRegistry: () => DomainRegistry,
+  EagiRunner: () => EagiRunner,
+  EagiServerBuilder: () => EagiServerBuilder,
+  HookEngine: () => HookEngine,
+  approvalMiddleware: () => approvalMiddleware,
+  auditMiddleware: () => auditMiddleware,
+  authMiddleware: () => authMiddleware,
+  defineConfig: () => defineConfig,
+  defineHooks: () => defineHooks,
+  definePrompt: () => definePrompt,
+  defineResource: () => defineResource,
+  defineService: () => defineService,
+  defineTool: () => defineTool,
+  sortServices: () => sortServices
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hooks/engine.ts
+var HookEngine = class {
+  actions = /* @__PURE__ */ new Map();
+  filters = /* @__PURE__ */ new Map();
+  addAction(hookName, handler, priority = 10) {
+    if (!this.actions.has(hookName)) {
+      this.actions.set(hookName, []);
+    }
+    this.actions.get(hookName).push({ handler, priority });
+    this.actions.get(hookName).sort((a, b) => a.priority - b.priority);
+  }
+  addFilter(hookName, handler, priority = 10) {
+    if (!this.filters.has(hookName)) {
+      this.filters.set(hookName, []);
+    }
+    this.filters.get(hookName).push({ handler, priority });
+    this.filters.get(hookName).sort((a, b) => a.priority - b.priority);
+  }
+  async doAction(hookName, context) {
+    const handlers = this.actions.get(hookName) || [];
+    for (const { handler } of handlers) {
+      await handler(context);
+    }
+  }
+  async applyFilters(hookName, data, context) {
+    let result = data;
+    const handlers = this.filters.get(hookName) || [];
+    for (const { handler } of handlers) {
+      result = await handler(result, context);
+    }
+    return result;
+  }
+};
+
+// src/domain/loader.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_js_yaml = __toESM(require("js-yaml"));
+var DomainLoader = class {
+  async load(domainDir) {
+    const manifestPath = (0, import_node_path.join)(domainDir, "domain.yaml");
+    if (!(0, import_node_fs.existsSync)(manifestPath)) {
+      throw new Error(`Domain manifest not found at ${manifestPath}`);
+    }
+    const manifestContent = (0, import_node_fs.readFileSync)(manifestPath, "utf8");
+    const manifest = import_js_yaml.default.load(manifestContent);
+    const services = await this.loadDirectory(domainDir, "services");
+    const tools = await this.loadDirectory(domainDir, "tools");
+    const resources = await this.loadDirectory(domainDir, "resources");
+    const prompts = await this.loadDirectory(domainDir, "prompts");
+    let hooksModule;
+    const hooksPath = (0, import_node_path.join)(domainDir, "hooks", "index.ts");
+    const hooksPathJs = (0, import_node_path.join)(domainDir, "hooks", "index.js");
+    if ((0, import_node_fs.existsSync)(hooksPath) || (0, import_node_fs.existsSync)(hooksPathJs)) {
+      hooksModule = await import((0, import_node_path.join)(domainDir, "hooks", "index"));
+    }
+    return {
+      manifest,
+      services,
+      tools,
+      resources,
+      prompts,
+      hooksModule,
+      dir: domainDir
+    };
+  }
+  async loadDirectory(domainDir, subDir) {
+    const dirPath = (0, import_node_path.join)(domainDir, subDir);
+    if (!(0, import_node_fs.existsSync)(dirPath)) return [];
+    const files = (0, import_node_fs.readdirSync)(dirPath).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    const loaded = [];
+    for (const file of files) {
+      const module2 = await import((0, import_node_path.join)(dirPath, file));
+      if (module2.default) {
+        loaded.push(module2.default);
+      }
+    }
+    return loaded;
+  }
+};
+function sortServices(services) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const serviceMap = new Map(services.map((s) => [s.name, s]));
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      throw new Error(`Circular dependency detected involving service: ${name}`);
+    }
+    visiting.add(name);
+    const service = serviceMap.get(name);
+    if (service && service.deps) {
+      for (const dep of service.deps) {
+        if (!serviceMap.has(dep)) {
+          throw new Error(`Service ${name} depends on unknown service ${dep}`);
+        }
+        visit(dep);
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    if (service) sorted.push(service);
+  }
+  for (const service of services) {
+    visit(service.name);
+  }
+  return sorted;
+}
+
+// src/domain/registry.ts
+var DomainRegistry = class {
+  domains = /* @__PURE__ */ new Map();
+  register(domain) {
+    this.domains.set(domain.manifest.name, domain);
+  }
+  get(name) {
+    return this.domains.get(name);
+  }
+  getAll() {
+    return Array.from(this.domains.values());
+  }
+  getAllTools() {
+    return this.getAll().flatMap((d) => d.tools);
+  }
+  getAllResources() {
+    return this.getAll().flatMap((d) => d.resources);
+  }
+  getAllPrompts() {
+    return this.getAll().flatMap((d) => d.prompts);
+  }
+};
+
+// src/define/tool.ts
+function defineTool(definition) {
+  return definition;
+}
+
+// src/define/resource.ts
+function defineResource(definition) {
+  return definition;
+}
+
+// src/define/prompt.ts
+function definePrompt(definition) {
+  return definition;
+}
+
+// src/define/service.ts
+function defineService(definition) {
+  return definition;
+}
+
+// src/define/hooks.ts
+function defineHooks(hooks) {
+  return hooks;
+}
+
+// src/define/config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/server/builder.ts
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_zod_to_json_schema = require("zod-to-json-schema");
+
+// src/middleware/auth.ts
+var AuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+async function authMiddleware(tool, ctx) {
+  if (!tool.auth || !tool.auth.roles) return;
+  const userRole = ctx.identity.role;
+  const domainRoles = ctx.domain.roles || {};
+  const allowedRoles = new Set(tool.auth.roles);
+  if (allowedRoles.has(userRole)) return;
+  const userRoleDef = domainRoles[userRole];
+  if (userRoleDef && userRoleDef.includes) {
+    for (const included of userRoleDef.includes) {
+      if (allowedRoles.has(included)) return;
+    }
+  }
+  throw new AuthError(`User role '${userRole}' is not authorized to execute tool '${tool.name}'`);
+}
+
+// src/middleware/audit.ts
+async function auditMiddleware(tool, input, output, ctx) {
+  if (!tool.audit) return;
+  let auditedInput = { ...input };
+  if (typeof tool.audit === "object" && tool.audit.redactFields) {
+    for (const field of tool.audit.redactFields) {
+      if (field in auditedInput) {
+        auditedInput[field] = "[REDACTED]";
+      }
+    }
+  }
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool: tool.name,
+    identity: ctx.identity.userId,
+    role: ctx.identity.role,
+    input: auditedInput,
+    success: !output.isError
+  };
+  const finalEntry = await ctx.hooks.applyFilters("filter:audit:entry", entry, ctx);
+  if (ctx.logger) {
+    ctx.logger.info("AUDIT", finalEntry);
+  }
+}
+
+// src/middleware/approval.ts
+var ApprovalRequiredError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ApprovalRequiredError";
+  }
+};
+async function approvalMiddleware(tool, input, ctx) {
+  if (!tool.approval || !tool.approval.required) return;
+  const hasApprovalToken = false;
+  if (!hasApprovalToken) {
+    const message = typeof tool.approval.message === "function" ? tool.approval.message(input) : tool.approval.message;
+    throw new ApprovalRequiredError(message);
+  }
+}
+
+// src/server/builder.ts
+var EagiServerBuilder = class {
+  constructor(config, registry, hooks, servicesMap) {
+    this.config = config;
+    this.registry = registry;
+    this.hooks = hooks;
+    this.servicesMap = servicesMap;
+  }
+  config;
+  registry;
+  hooks;
+  servicesMap;
+  build() {
+    const server = new import_server.Server(
+      { name: this.config.name, version: this.config.version },
+      { capabilities: { tools: {}, resources: {}, prompts: {} } }
+    );
+    this.registerTools(server);
+    this.registerResources(server);
+    this.registerPrompts(server);
+    return server;
+  }
+  registerTools(server) {
+    server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
+      const tools = this.registry.getAllTools().map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: (0, import_zod_to_json_schema.zodToJsonSchema)(t.input)
+      }));
+      return { tools };
+    });
+    server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      const tool = this.registry.getAllTools().find((t) => t.name === name);
+      if (!tool) {
+        throw new Error(`Tool not found: ${name}`);
+      }
+      const identity = { userId: "system", role: "admin", claims: {} };
+      const domain = this.registry.getAll().find((d) => d.tools.includes(tool)).manifest;
+      const ctx = {
+        identity,
+        domain,
+        hooks: this.hooks,
+        logger: console,
+        // Temporary logger
+        services: this.servicesMap,
+        tools: {
+          call: async (toolName, input2) => {
+            return null;
+          }
+        },
+        resources: {
+          get: async (uri) => {
+            return null;
+          }
+        }
+      };
+      let input = await this.hooks.applyFilters("filter:tool:input", args, ctx);
+      const parsedInput = tool.input.parse(input);
+      await this.hooks.doAction("before:tool:call", { toolName: name, input: parsedInput, identity, domain });
+      if (tool.auth) await authMiddleware(tool, ctx);
+      if (tool.approval) await approvalMiddleware(tool, parsedInput, ctx);
+      const startTime = Date.now();
+      let output = await tool.handler(parsedInput, ctx);
+      const duration = Date.now() - startTime;
+      output = await this.hooks.applyFilters("filter:tool:output", output, ctx);
+      await this.hooks.doAction("after:tool:call", { toolName: name, input: parsedInput, output, identity, duration });
+      if (tool.audit) await auditMiddleware(tool, parsedInput, output, ctx);
+      return output;
+    });
+  }
+  registerResources(server) {
+    server.setRequestHandler(import_types.ListResourcesRequestSchema, async () => {
+      const resources = this.registry.getAllResources().map((r) => ({
+        uri: r.uri,
+        name: r.name,
+        description: r.description,
+        mimeType: r.mimeType
+      }));
+      return { resources };
+    });
+    server.setRequestHandler(import_types.ReadResourceRequestSchema, async (request) => {
+      const { uri } = request.params;
+      const resource = this.registry.getAllResources().find((r) => r.uri === uri);
+      if (!resource) {
+        throw new Error(`Resource not found: ${uri}`);
+      }
+      const identity = { userId: "system", role: "admin", claims: {} };
+      const domain = this.registry.getAll().find((d) => d.resources.includes(resource)).manifest;
+      const ctx = {
+        identity,
+        domain,
+        hooks: this.hooks,
+        logger: console,
+        services: this.servicesMap
+      };
+      await this.hooks.doAction("before:resource:read", { uri, identity });
+      let data = await resource.handler({}, ctx);
+      data = await this.hooks.applyFilters("filter:resource:data", data, ctx);
+      await this.hooks.doAction("after:resource:read", { uri, data, identity });
+      return {
+        contents: [{ uri, mimeType: resource.mimeType, text: data }]
+      };
+    });
+  }
+  registerPrompts(server) {
+    server.setRequestHandler(import_types.ListPromptsRequestSchema, async () => {
+      const prompts = this.registry.getAllPrompts().map((p) => ({
+        name: p.name,
+        description: p.description,
+        arguments: []
+        // Should extract from Zod schema
+      }));
+      return { prompts };
+    });
+    server.setRequestHandler(import_types.GetPromptRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      const prompt = this.registry.getAllPrompts().find((p) => p.name === name);
+      if (!prompt) {
+        throw new Error(`Prompt not found: ${name}`);
+      }
+      const identity = { userId: "system", role: "admin", claims: {} };
+      const domain = this.registry.getAll().find((d) => d.prompts.includes(prompt)).manifest;
+      const ctx = {
+        identity,
+        domain,
+        hooks: this.hooks,
+        logger: console,
+        services: this.servicesMap
+      };
+      const parsedArgs = prompt.arguments.parse(args);
+      const result = await prompt.handler(parsedArgs, ctx);
+      return {
+        description: prompt.description,
+        messages: result.messages
+      };
+    });
+  }
+};
+
+// src/server/lifecycle.ts
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var EagiRunner = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  registry = new DomainRegistry();
+  hooks = new HookEngine();
+  servicesMap = {};
+  async start(domainDirs) {
+    if (this.config.hooks) {
+      for (const [hookName, handler] of Object.entries(this.config.hooks)) {
+        if (hookName.startsWith("filter:")) {
+          this.hooks.addFilter(hookName, handler);
+        } else {
+          this.hooks.addAction(hookName, handler);
+        }
+      }
+    }
+    const loader = new DomainLoader();
+    for (const dir of domainDirs) {
+      const domain = await loader.load(dir);
+      this.registry.register(domain);
+      if (domain.hooksModule && domain.hooksModule.default) {
+        const domainHooks = domain.hooksModule.default;
+        for (const [hookName, handler] of Object.entries(domainHooks)) {
+          if (hookName.startsWith("filter:")) {
+            this.hooks.addFilter(hookName, handler);
+          } else {
+            this.hooks.addAction(hookName, handler);
+          }
+        }
+      }
+      await this.hooks.doAction("on:domain:load", { domain: domain.manifest });
+    }
+    const allServices = this.registry.getAll().flatMap((d) => d.services);
+    const sortedServices = sortServices(allServices);
+    for (const service of sortedServices) {
+      const deps = {};
+      if (service.deps) {
+        for (const dep of service.deps) {
+          deps[dep] = this.servicesMap[dep];
+        }
+      }
+      const instance = await service.factory({ env: process.env }, deps);
+      this.servicesMap[service.name] = instance;
+    }
+    const builder = new EagiServerBuilder(this.config, this.registry, this.hooks, this.servicesMap);
+    const server = builder.build();
+    const transport = new import_stdio.StdioServerTransport();
+    await server.connect(transport);
+    await this.hooks.doAction("on:server:start", { config: this.config, domains: this.registry.getAll().map((d) => d.manifest) });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApprovalRequiredError,
+  AuthError,
+  DomainLoader,
+  DomainRegistry,
+  EagiRunner,
+  EagiServerBuilder,
+  HookEngine,
+  approvalMiddleware,
+  auditMiddleware,
+  authMiddleware,
+  defineConfig,
+  defineHooks,
+  definePrompt,
+  defineResource,
+  defineService,
+  defineTool,
+  sortServices
+});