@portel/photon 1.4.1 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portel/photon",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "description": "You focus on the business logic. We'll enable the rest. Build MCP servers and CLI tools in a single TypeScript file.",
   "type": "module",
   "main": "dist/index.js",
@@ -12,21 +12,47 @@
     "templates"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && cp -r src/photons dist/",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "build:beam": "tsx scripts/build-beam.ts",
+    "watch:beam": "tsx scripts/build-beam.ts --watch",
+    "dev:beam": "npm run build:beam && (tsx scripts/build-beam.ts --watch & tsx watch src/cli.ts beam)",
+    "prepublishOnly": "node -e \"const p=require('./package.json'); if(JSON.stringify(p.dependencies).includes('file:')) { console.error('ERROR: file: dependency found. Update to npm version before publishing.'); process.exit(1); }\" && npm run build",
     "test": "npm run test:all",
-    "test:all": "npm run build && npm run test:schema && npm run test:marketplace && npm run test:loader && npm run test:server && npm run test:integration && npm run test:cli && npm run test:readme",
+    "test:all": "npm run build && npm run test:schema && npm run test:marketplace && npm run test:loader && npm run test:server && npm run test:integration && npm run test:ui-resources && npm run test:zero-config && npm run test:mcp-config && npm run test:cli && npm run test:logger && npm run test:error-handler && npm run test:performance && npm run test:validation && npm run test:daemon-pubsub && npm run test:daemon-tools && npm run test:daemon-buffer && npm run test:readme",
+    "test:zero-config": "npx tsx tests/zero-config.test.ts",
+    "test:mcp-config": "npx tsx tests/mcp-configuration.test.ts",
+    "test:coverage": "npm run build && c8 --include='dist/**/*.js' --reporter=text --reporter=html npm run test:unit",
+    "test:unit": "npx tsx tests/schema-extractor.test.ts && npx tsx tests/marketplace-manager.test.ts && npx tsx tests/loader.test.ts && npx tsx tests/loader.comprehensive.test.ts && npx tsx tests/server.test.ts && npx tsx tests/server.comprehensive.test.ts && npx tsx tests/cli-runner.test.ts && npx tsx tests/cli.comprehensive.test.ts && npx tsx tests/logger.test.ts && npx tsx tests/error-handler.test.ts && npx tsx tests/performance.test.ts && npx tsx tests/validation.test.ts && npx tsx tests/daemon-pubsub.test.ts && npx tsx tests/daemon-tools.test.ts && npx tsx tests/shared-utils.test.ts",
+    "test:cli:comprehensive": "npx tsx tests/cli.comprehensive.test.ts",
+    "test:loader:comprehensive": "npx tsx tests/loader.comprehensive.test.ts",
+    "test:server:comprehensive": "npx tsx tests/server.comprehensive.test.ts",
+    "test:daemon-pubsub": "npx tsx tests/daemon-pubsub.test.ts",
+    "test:daemon-tools": "npx tsx tests/daemon-tools.test.ts",
+    "test:daemon-buffer": "npx tsx tests/daemon-event-buffer.test.ts",
     "test:cli": "npx tsx tests/cli-runner.test.ts",
+    "test:logger": "npx tsx tests/logger.test.ts",
+    "test:error-handler": "npx tsx tests/error-handler.test.ts",
+    "test:performance": "npx tsx tests/performance.test.ts",
+    "test:validation": "npx tsx tests/validation.test.ts",
     "test:readme": "bash tests/readme-validation.sh",
     "test:schema": "npx tsx tests/schema-extractor.test.ts",
     "test:marketplace": "npx tsx tests/marketplace-manager.test.ts",
     "test:loader": "npx tsx tests/loader.test.ts",
     "test:server": "npx tsx tests/server.test.ts",
     "test:integration": "npx tsx tests/integration.test.ts",
+    "test:ui-resources": "npx tsx tests/ui-resources.test.ts",
     "test:load": "npm run build && node --expose-gc --max-old-space-size=4096 node_modules/.bin/tsx tests/load-test.ts",
     "test:sqlite": "npm run build && npx tsx tests/sqlite.test.ts",
     "test:github": "npm run build && npx tsx tests/github-issues.test.ts",
+    "test:beam": "npm run build && npx tsx tests/beam/rendering.test.ts",
+    "test:e2e": "npm run build && npx playwright test",
+    "test:e2e:ui": "npm run build && npx playwright test --ui",
     "release": "release-it",
     "release:minor": "release-it minor",
     "release:major": "release-it major",
@@ -51,19 +77,33 @@
   "author": "Portel Dev",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.4",
-    "@portel/photon-core": "^1.1.0",
+    "@modelcontextprotocol/sdk": "^1.25.2",
+    "@portel/photon-core": "^2.3.0",
     "chokidar": "^4.0.3",
     "cli-highlight": "^2.1.11",
     "commander": "^12.1.0",
     "esbuild": "^0.27.0",
-    "typescript": "^5.0.0"
+    "lit": "^3.3.2",
+    "typescript": "^5.0.0",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@playwright/test": "^1.58.0",
     "@release-it/conventional-changelog": "^10.0.1",
+    "@types/inquirer": "^9.0.9",
     "@types/node": "^22.10.2",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
     "autocannon": "^8.0.0",
+    "c8": "^10.1.3",
     "clinic": "^13.0.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "openapi-types": "^12.1.3",
+    "playwright": "^1.57.0",
+    "prettier": "^3.8.0",
     "release-it": "^19.0.6",
     "tsx": "^4.20.6",
     "typescript": "^5.7.3"

package/templates/cloudflare/worker.ts.template

@@ -0,0 +1,381 @@
+/**
+ * Photon MCP Worker for Cloudflare
+ * Auto-generated - do not edit directly
+ */
+
+// @ts-ignore - Will be replaced during build
+import PhotonClass from './photon';
+
+interface Env {
+  // Add your environment variables here
+  [key: string]: string | undefined;
+}
+
+type SSESession = {
+  writer: WritableStreamDefaultWriter<Uint8Array>;
+  encoder: TextEncoder;
+};
+
+const sessions = new Map<string, SSESession>();
+
+// Tool definitions extracted at build time
+// @ts-ignore - Will be replaced during build
+const TOOL_DEFINITIONS: any[] = __TOOL_DEFINITIONS__;
+const PHOTON_NAME = '__PHOTON_NAME__';
+const DEV_MODE = __DEV_MODE__;
+
+// Instantiate photon
+let photonInstance: InstanceType<typeof PhotonClass> | null = null;
+
+function getPhoton(env: Env): InstanceType<typeof PhotonClass> {
+  if (!photonInstance) {
+    // Pass env vars as constructor params if needed
+    photonInstance = new PhotonClass();
+  }
+  return photonInstance;
+}
+
+// MCP JSON-RPC handler
+async function handleMCPRequest(request: any, env: Env): Promise<any> {
+  const { method, params, id } = request;
+  const photon = getPhoton(env);
+
+  switch (method) {
+    case 'initialize':
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo: { name: PHOTON_NAME, version: '1.0.0' },
+        },
+      };
+
+    case 'tools/list':
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: { tools: TOOL_DEFINITIONS },
+      };
+
+    case 'tools/call': {
+      const { name, arguments: args } = params;
+      try {
+        const method = (photon as any)[name];
+        if (typeof method !== 'function') {
+          throw new Error(`Unknown tool: ${name}`);
+        }
+        const result = await method.call(photon, args || {});
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+          },
+        };
+      } catch (error: any) {
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: `Error: ${error.message}` }],
+            isError: true,
+          },
+        };
+      }
+    }
+
+    case 'notifications/initialized':
+    case 'ping':
+      return { jsonrpc: '2.0', id, result: {} };
+
+    default:
+      return {
+        jsonrpc: '2.0',
+        id,
+        error: { code: -32601, message: `Method not found: ${method}` },
+      };
+  }
+}
+
+// SSE stream handler
+async function handleSSE(request: Request, env: Env): Promise<Response> {
+  const sessionId = crypto.randomUUID();
+  const encoder = new TextEncoder();
+
+  const { readable, writable } = new TransformStream();
+  const writer = writable.getWriter();
+
+  sessions.set(sessionId, { writer, encoder });
+
+  // Send session ID
+  await writer.write(encoder.encode(`event: session\ndata: ${JSON.stringify({ sessionId })}\n\n`));
+
+  // Keep-alive
+  const interval = setInterval(async () => {
+    try {
+      await writer.write(encoder.encode(`: keepalive\n\n`));
+    } catch {
+      clearInterval(interval);
+    }
+  }, 30000);
+
+  // Cleanup on close
+  request.signal.addEventListener('abort', () => {
+    clearInterval(interval);
+    sessions.delete(sessionId);
+    writer.close().catch(() => {});
+  });
+
+  return new Response(readable, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+    },
+  });
+}
+
+// Message handler for SSE
+async function handleMessage(request: Request, env: Env): Promise<Response> {
+  const url = new URL(request.url);
+  const sessionId = url.searchParams.get('sessionId');
+
+  if (!sessionId || !sessions.has(sessionId)) {
+    return new Response('Invalid session', { status: 400 });
+  }
+
+  const session = sessions.get(sessionId)!;
+  const body = await request.json();
+  const response = await handleMCPRequest(body, env);
+
+  // Send response via SSE
+  const data = `event: message\ndata: ${JSON.stringify(response)}\n\n`;
+  await session.writer.write(session.encoder.encode(data));
+
+  return new Response('OK', {
+    headers: { 'Access-Control-Allow-Origin': '*' },
+  });
+}
+
+// Playground HTML
+function getPlaygroundHTML(): string {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${PHOTON_NAME} - Playground</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    :root { --bg: #0a0a0f; --card: #12121a; --border: #1e1e2e; --text: #e4e4e7; --muted: #71717a; --accent: #6366f1; --green: #22c55e; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: var(--bg); color: var(--text); min-height: 100vh; }
+    .header { background: var(--card); border-bottom: 1px solid var(--border); padding: 16px 24px; display: flex; align-items: center; gap: 12px; }
+    .header h1 { font-size: 18px; font-weight: 600; }
+    .header h1::before { content: ''; width: 8px; height: 8px; background: var(--green); border-radius: 50%; display: inline-block; margin-right: 8px; box-shadow: 0 0 8px var(--green); }
+    .badge { background: #f97316; color: white; padding: 2px 8px; border-radius: 4px; font-size: 11px; font-weight: 600; }
+    .container { display: grid; grid-template-columns: 300px 1fr; height: calc(100vh - 57px); }
+    .sidebar { background: var(--card); border-right: 1px solid var(--border); padding: 16px; overflow-y: auto; }
+    .tool { padding: 12px; border-radius: 8px; cursor: pointer; margin-bottom: 8px; border: 1px solid var(--border); }
+    .tool:hover { border-color: var(--accent); }
+    .tool.active { border-color: var(--accent); background: rgba(99, 102, 241, 0.1); }
+    .tool-name { font-weight: 600; font-size: 14px; margin-bottom: 4px; }
+    .tool-desc { font-size: 12px; color: var(--muted); }
+    .main { padding: 24px; display: flex; flex-direction: column; gap: 16px; overflow-y: auto; }
+    .panel { background: var(--card); border: 1px solid var(--border); border-radius: 8px; padding: 16px; }
+    .panel h3 { font-size: 14px; margin-bottom: 12px; color: var(--muted); }
+    .form-group { margin-bottom: 12px; }
+    .form-group label { display: block; font-size: 12px; color: var(--muted); margin-bottom: 4px; }
+    .form-group input, .form-group select { width: 100%; padding: 8px 12px; background: var(--bg); border: 1px solid var(--border); border-radius: 6px; color: var(--text); font-size: 14px; }
+    .btn { background: var(--accent); color: white; border: none; padding: 10px 20px; border-radius: 6px; cursor: pointer; font-weight: 600; }
+    .btn:hover { opacity: 0.9; }
+    .btn:disabled { opacity: 0.5; cursor: not-allowed; }
+    pre { background: var(--bg); padding: 12px; border-radius: 6px; overflow-x: auto; font-size: 13px; white-space: pre-wrap; }
+    .preview { flex: 1; min-height: 300px; }
+    .preview iframe { width: 100%; height: 100%; border: none; border-radius: 6px; background: white; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>${PHOTON_NAME}</h1>
+    <span class="badge">Cloudflare Workers</span>
+  </div>
+  <div class="container">
+    <div class="sidebar">
+      <div id="tools"></div>
+    </div>
+    <div class="main">
+      <div class="panel">
+        <h3>Parameters</h3>
+        <div id="params"></div>
+        <button class="btn" id="call" disabled>Call Tool</button>
+      </div>
+      <div class="panel">
+        <h3>Response</h3>
+        <pre id="response">Select a tool to get started</pre>
+      </div>
+    </div>
+  </div>
+  <script>
+    const tools = ${JSON.stringify(TOOL_DEFINITIONS)};
+    let selectedTool = null;
+
+    function renderTools() {
+      const container = document.getElementById('tools');
+      container.innerHTML = tools.map(t => \`
+        <div class="tool" data-name="\${t.name}">
+          <div class="tool-name">\${t.name}</div>
+          <div class="tool-desc">\${t.description || ''}</div>
+        </div>
+      \`).join('');
+
+      container.querySelectorAll('.tool').forEach(el => {
+        el.onclick = () => selectTool(el.dataset.name);
+      });
+    }
+
+    function selectTool(name) {
+      selectedTool = tools.find(t => t.name === name);
+      document.querySelectorAll('.tool').forEach(el => el.classList.remove('active'));
+      document.querySelector(\`[data-name="\${name}"]\`).classList.add('active');
+      renderParams();
+      document.getElementById('call').disabled = false;
+    }
+
+    function renderParams() {
+      const container = document.getElementById('params');
+      const props = selectedTool?.inputSchema?.properties || {};
+      const required = selectedTool?.inputSchema?.required || [];
+
+      if (Object.keys(props).length === 0) {
+        container.innerHTML = '<p style="color: var(--muted); font-size: 13px;">No parameters required</p>';
+        return;
+      }
+
+      container.innerHTML = Object.entries(props).map(([key, schema]) => {
+        const req = required.includes(key) ? ' *' : '';
+        if (schema.enum) {
+          return \`<div class="form-group">
+            <label>\${key}\${req}</label>
+            <select name="\${key}">
+              <option value="">Select...</option>
+              \${schema.enum.map(v => \`<option value="\${v}">\${v}</option>\`).join('')}
+            </select>
+          </div>\`;
+        }
+        const type = schema.type === 'number' ? 'number' : 'text';
+        return \`<div class="form-group">
+          <label>\${key}\${req}</label>
+          <input type="\${type}" name="\${key}" placeholder="\${schema.description || ''}">
+        </div>\`;
+      }).join('');
+    }
+
+    document.getElementById('call').onclick = async () => {
+      if (!selectedTool) return;
+      const form = document.getElementById('params');
+      const args = {};
+      form.querySelectorAll('input, select').forEach(el => {
+        if (el.value) {
+          args[el.name] = el.type === 'number' ? Number(el.value) : el.value;
+        }
+      });
+
+      document.getElementById('response').textContent = 'Calling...';
+
+      try {
+        const res = await fetch('/api/call', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ tool: selectedTool.name, args })
+        });
+        const data = await res.json();
+        document.getElementById('response').textContent = JSON.stringify(data, null, 2);
+      } catch (e) {
+        document.getElementById('response').textContent = 'Error: ' + e.message;
+      }
+    };
+
+    renderTools();
+  </script>
+</body>
+</html>`;
+}
+
+// Main fetch handler
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const url = new URL(request.url);
+
+    // CORS preflight
+    if (request.method === 'OPTIONS') {
+      return new Response(null, {
+        headers: {
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+          'Access-Control-Allow-Headers': 'Content-Type',
+        },
+      });
+    }
+
+    // Info endpoint
+    if (url.pathname === '/' && request.method === 'GET') {
+      return Response.json({
+        name: PHOTON_NAME,
+        transport: 'sse',
+        runtime: 'cloudflare-workers',
+        endpoints: {
+          sse: '/mcp',
+          messages: '/mcp/messages',
+          ...(DEV_MODE ? { playground: '/playground' } : {}),
+        },
+        tools: TOOL_DEFINITIONS.length,
+      });
+    }
+
+    // SSE endpoint
+    if (url.pathname === '/mcp' && request.method === 'GET') {
+      return handleSSE(request, env);
+    }
+
+    // Message endpoint
+    if (url.pathname === '/mcp/messages' && request.method === 'POST') {
+      return handleMessage(request, env);
+    }
+
+    // Dev-only endpoints
+    if (DEV_MODE) {
+      // Playground
+      if (url.pathname === '/playground') {
+        return new Response(getPlaygroundHTML(), {
+          headers: { 'Content-Type': 'text/html' },
+        });
+      }
+
+      // API: List tools
+      if (url.pathname === '/api/tools') {
+        return Response.json({ tools: TOOL_DEFINITIONS });
+      }
+
+      // API: Call tool
+      if (url.pathname === '/api/call' && request.method === 'POST') {
+        const { tool, args } = await request.json();
+        const photon = getPhoton(env);
+        try {
+          const method = (photon as any)[tool];
+          if (typeof method !== 'function') {
+            throw new Error(`Unknown tool: ${tool}`);
+          }
+          const result = await method.call(photon, args || {});
+          return Response.json({ success: true, data: result });
+        } catch (error: any) {
+          return Response.json({ success: false, error: error.message }, { status: 500 });
+        }
+      }
+    }
+
+    return new Response('Not Found', { status: 404 });
+  },
+};

package/templates/cloudflare/wrangler.toml.template

@@ -0,0 +1,9 @@
+name = "__PHOTON_NAME__"
+main = "src/worker.ts"
+compatibility_date = "2024-01-01"
+
+# Uncomment to add environment variables
+# [vars]
+# API_KEY = "your-api-key"
+
+# For secrets, use: wrangler secret put SECRET_NAME

package/dist/base.d.ts

@@ -1,58 +0,0 @@
-/**
- * PhotonMCP Base Class
- *
- * Optional base class for creating Photon MCPs.
- * You don't need to extend this - any class with async methods works!
- *
- * Usage:
- * ```typescript
- * export default class Calculator extends PhotonMCP {
- *   /**
- *    * Add two numbers together
- *    * @param a First number
- *    * @param b Second number
- *    *\/
- *   async add(params: { a: number; b: number }) {
- *     return params.a + params.b;
- *   }
- * }
- * ```
- *
- * Or without extending (plain class):
- * ```typescript
- * export default class Calculator {
- *   async add(params: { a: number; b: number }) {
- *     return params.a + params.b;
- *   }
- * }
- * ```
- */
-/**
- * Simple base class for creating Photon MCPs
- *
- * - Class name = MCP name
- * - Public async methods = Tools
- * - Return value = Tool result
- */
-export declare class PhotonMCP {
-    /**
-     * Get MCP name from class name
-     * Converts PascalCase to kebab-case (e.g., MyAwesomeMCP → my-awesome-mcp)
-     */
-    static getMCPName(): string;
-    /**
-     * Get all tool methods from this class
-     * Returns all public async methods except lifecycle hooks
-     */
-    static getToolMethods(): string[];
-    /**
-     * Execute a tool method
-     */
-    executeTool(toolName: string, parameters: any): Promise<any>;
-    /**
-     * Optional lifecycle hooks
-     */
-    onInitialize?(): Promise<void>;
-    onShutdown?(): Promise<void>;
-}
-//# sourceMappingURL=base.d.ts.map

package/dist/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../src/base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;GAMG;AACH,qBAAa,SAAS;IACpB;;;OAGG;IACH,MAAM,CAAC,UAAU,IAAI,MAAM;IAQ3B;;;OAGG;IACH,MAAM,CAAC,cAAc,IAAI,MAAM,EAAE;IA0BjC;;OAEG;IACG,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAgBlE;;OAEG;IACG,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;IAC9B,UAAU,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CACnC"}

package/dist/base.js

@@ -1,92 +0,0 @@
-/**
- * PhotonMCP Base Class
- *
- * Optional base class for creating Photon MCPs.
- * You don't need to extend this - any class with async methods works!
- *
- * Usage:
- * ```typescript
- * export default class Calculator extends PhotonMCP {
- *   /**
- *    * Add two numbers together
- *    * @param a First number
- *    * @param b Second number
- *    *\/
- *   async add(params: { a: number; b: number }) {
- *     return params.a + params.b;
- *   }
- * }
- * ```
- *
- * Or without extending (plain class):
- * ```typescript
- * export default class Calculator {
- *   async add(params: { a: number; b: number }) {
- *     return params.a + params.b;
- *   }
- * }
- * ```
- */
-/**
- * Simple base class for creating Photon MCPs
- *
- * - Class name = MCP name
- * - Public async methods = Tools
- * - Return value = Tool result
- */
-export class PhotonMCP {
-    /**
-     * Get MCP name from class name
-     * Converts PascalCase to kebab-case (e.g., MyAwesomeMCP → my-awesome-mcp)
-     */
-    static getMCPName() {
-        return this.name
-            .replace(/MCP$/, '') // Remove "MCP" suffix if present
-            .replace(/([A-Z])/g, '-$1')
-            .toLowerCase()
-            .replace(/^-/, ''); // Remove leading dash
-    }
-    /**
-     * Get all tool methods from this class
-     * Returns all public async methods except lifecycle hooks
-     */
-    static getToolMethods() {
-        const prototype = this.prototype;
-        const methods = [];
-        // Get all property names from prototype chain
-        let current = prototype;
-        while (current && current !== PhotonMCP.prototype) {
-            Object.getOwnPropertyNames(current).forEach((name) => {
-                // Skip constructor, private methods (starting with _), and lifecycle hooks
-                if (name !== 'constructor' &&
-                    !name.startsWith('_') &&
-                    name !== 'onInitialize' &&
-                    name !== 'onShutdown' &&
-                    typeof prototype[name] === 'function' &&
-                    !methods.includes(name)) {
-                    methods.push(name);
-                }
-            });
-            current = Object.getPrototypeOf(current);
-        }
-        return methods;
-    }
-    /**
-     * Execute a tool method
-     */
-    async executeTool(toolName, parameters) {
-        const method = this[toolName];
-        if (!method || typeof method !== 'function') {
-            throw new Error(`Tool not found: ${toolName}`);
-        }
-        try {
-            const result = await method.call(this, parameters);
-            return result;
-        }
-        catch (error) {
-            console.error(`Tool execution failed: ${toolName} - ${error.message}`);
-            throw error;
-        }
-    }
-}
-//# sourceMappingURL=base.js.map

package/dist/base.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.js","sourceRoot":"","sources":["../src/base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;GAMG;AACH,MAAM,OAAO,SAAS;IACpB;;;OAGG;IACH,MAAM,CAAC,UAAU;QACf,OAAO,IAAI,CAAC,IAAI;aACb,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,iCAAiC;aACrD,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC;aAC1B,WAAW,EAAE;aACb,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,sBAAsB;IAC9C,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,cAAc;QACnB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACjC,MAAM,OAAO,GAAa,EAAE,CAAC;QAE7B,8CAA8C;QAC9C,IAAI,OAAO,GAAG,SAAS,CAAC;QACxB,OAAO,OAAO,IAAI,OAAO,KAAK,SAAS,CAAC,SAAS,EAAE,CAAC;YAClD,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBACnD,2EAA2E;gBAC3E,IACE,IAAI,KAAK,aAAa;oBACtB,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;oBACrB,IAAI,KAAK,cAAc;oBACvB,IAAI,KAAK,YAAY;oBACrB,OAAQ,SAAiB,CAAC,IAAI,CAAC,KAAK,UAAU;oBAC9C,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EACvB,CAAC;oBACD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACrB,CAAC;YACH,CAAC,CAAC,CAAC;YACH,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC3C,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW,CAAC,QAAgB,EAAE,UAAe;QACjD,MAAM,MAAM,GAAI,IAAY,CAAC,QAAQ,CAAC,CAAC;QAEvC,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CAAC,mBAAmB,QAAQ,EAAE,CAAC,CAAC;QACjD,CAAC;QAED,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YACnD,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,CAAC,KAAK,CAAC,0BAA0B,QAAQ,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACvE,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;CAOF"}