@poolzin/pool-bot 2026.3.9 → 2026.3.11

package/extensions/mavalie/src/index.ts

@@ -0,0 +1,62 @@
+import { emptyPluginConfigSchema } from "poolbot/plugin-sdk";
+
+/**
+ * Mavalie Plugin for PoolBot
+ * 
+ * Template mínimo válido de plugin para PoolBot.
+ * Este plugin registra um provider customizado que pode ser expandido
+ * conforme necessidades específicas.
+ */
+
+const mavaliePlugin = {
+  id: "mavalie",
+  name: "Mavalie",
+  description: "Custom Mavalie integration for PoolBot",
+  configSchema: emptyPluginConfigSchema(),
+  
+  register(api) {
+    // Log de registro do plugin
+    api.runtime?.log?.("Mavalie plugin registered");
+    
+    // TODO: Adicione aqui o registro de:
+    // - Providers (modelos customizados)
+    // - Canais (integrações de mensageria)
+    // - Ferramentas (tools para agentes)
+    // - Hooks (eventos do ciclo de vida)
+    
+    // Exemplo de registro de provider (descomente e adapte):
+    /*
+    api.registerProvider({
+      id: "mavalie",
+      label: "Mavalie Provider",
+      docsPath: "/providers/models",
+      auth: [
+        {
+          id: "api-key",
+          label: "API Key",
+          kind: "apiKey",
+          run: async (ctx) => {
+            const key = await ctx.prompter.password({
+              message: "Enter your Mavalie API key:",
+            });
+            return {
+              profiles: [
+                {
+                  profileId: "mavalie:default",
+                  credential: {
+                    type: "apiKey",
+                    provider: "mavalie",
+                    key: String(key),
+                  },
+                },
+              ],
+            };
+          },
+        },
+      ],
+    });
+    */
+  },
+};
+
+export default mavaliePlugin;

package/extensions/mcp-server/index.ts

@@ -0,0 +1,14 @@
+import type { PoolBotPluginApi } from "../../src/plugins/types.js";
+
+import { createMcpServerService } from "./src/service.js";
+
+const plugin = {
+  id: "mcp-server",
+  name: "MCP Server",
+  description: "MCP (Model Context Protocol) server - exposes PoolBot tools via MCP protocol",
+  register(api: PoolBotPluginApi) {
+    api.registerService(createMcpServerService());
+  },
+};
+
+export default plugin;

package/extensions/mcp-server/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@poolbot/mcp-server",
+  "version": "2026.3.11",
+  "type": "module",
+  "description": "MCP (Model Context Protocol) server plugin for PoolBot - exposes tools via MCP protocol",
+  "poolbot": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/extensions/mcp-server/src/service.ts

@@ -0,0 +1,540 @@
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import type { PoolBotPluginService } from "../../../src/plugins/types.js";
+
+// MCP Protocol types
+interface McpTool {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+}
+
+interface McpTextContent {
+  type: "text";
+  text: string;
+}
+
+interface McpImageContent {
+  type: "image";
+  data: string;
+  mimeType: string;
+}
+
+type McpContent = McpTextContent | McpImageContent;
+
+interface McpToolResult {
+  content: McpContent[];
+  isError?: boolean;
+}
+
+interface McpRequest {
+  jsonrpc: "2.0";
+  id: number | string;
+  method: string;
+  params?: unknown;
+}
+
+interface McpResponse {
+  jsonrpc: "2.0";
+  id: number | string;
+  result?: unknown;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+// Tool registry to store PoolBot tools mapped to MCP
+class McpToolRegistry {
+  private tools = new Map<string, McpTool>();
+  private handlers = new Map<string, (args: unknown) => Promise<McpToolResult>>();
+
+  register(
+    name: string,
+    description: string,
+    inputSchema: unknown,
+    handler: (args: unknown) => Promise<McpToolResult>,
+  ): void {
+    this.tools.set(name, { name, description, inputSchema });
+    this.handlers.set(name, handler);
+  }
+
+  getTool(name: string): McpTool | undefined {
+    return this.tools.get(name);
+  }
+
+  getAllTools(): McpTool[] {
+    return Array.from(this.tools.values());
+  }
+
+  async execute(name: string, args: unknown): Promise<McpToolResult> {
+    const handler = this.handlers.get(name);
+    if (!handler) {
+      return {
+        content: [{ type: "text", text: `Tool not found: ${name}` }],
+        isError: true,
+      };
+    }
+    try {
+      return await handler(args);
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error executing tool ${name}: ${error instanceof Error ? error.message : String(error)}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+}
+
+// MCP Server implementation
+class McpServer {
+  private registry = new McpToolRegistry();
+  private server?: ReturnType<typeof createServer>;
+  private port: number;
+
+  constructor(port = 8765) {
+    this.port = port;
+    this.registerBuiltinTools();
+  }
+
+  private registerBuiltinTools(): void {
+    // Register basic PoolBot tools as MCP tools
+    this.registry.register(
+      "poolbot_read_file",
+      "Read a file from the filesystem",
+      {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "Absolute path to the file to read",
+          },
+          offset: {
+            type: "number",
+            description: "Line number to start reading from (0-indexed)",
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of lines to read",
+          },
+        },
+        required: ["file_path"],
+      },
+      async (args) => {
+        const { file_path, offset, limit } = args as {
+          file_path: string;
+          offset?: number;
+          limit?: number;
+        };
+        try {
+          const fs = await import("node:fs/promises");
+          const content = await fs.readFile(file_path, "utf-8");
+          const lines = content.split("\n");
+          const start = offset ?? 0;
+          const end = limit ? start + limit : lines.length;
+          const selectedLines = lines.slice(start, end);
+          return {
+            content: [
+              {
+                type: "text",
+                text: selectedLines.join("\n"),
+              },
+            ],
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error reading file: ${error instanceof Error ? error.message : String(error)}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+      },
+    );
+
+    this.registry.register(
+      "poolbot_write_file",
+      "Write content to a file",
+      {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "Absolute path to the file to write",
+          },
+          content: {
+            type: "string",
+            description: "Content to write to the file",
+          },
+        },
+        required: ["file_path", "content"],
+      },
+      async (args) => {
+        const { file_path, content } = args as { file_path: string; content: string };
+        try {
+          const fs = await import("node:fs/promises");
+          const path = await import("node:path");
+          await fs.mkdir(path.dirname(file_path), { recursive: true });
+          await fs.writeFile(file_path, content, "utf-8");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Successfully wrote to ${file_path}`,
+              },
+            ],
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error writing file: ${error instanceof Error ? error.message : String(error)}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+      },
+    );
+
+    this.registry.register(
+      "poolbot_execute_command",
+      "Execute a shell command",
+      {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "Command to execute",
+          },
+          workdir: {
+            type: "string",
+            description: "Working directory for the command",
+          },
+          timeout: {
+            type: "number",
+            description: "Timeout in milliseconds",
+          },
+        },
+        required: ["command"],
+      },
+      async (args) => {
+        const { command, workdir, timeout } = args as {
+          command: string;
+          workdir?: string;
+          timeout?: number;
+        };
+        try {
+          const { exec } = await import("node:child_process");
+          const { promisify } = await import("node:util");
+          const execAsync = promisify(exec);
+
+          const result = await execAsync(command, {
+            cwd: workdir,
+            timeout: timeout ?? 120000,
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: result.stdout || "(no output)",
+              },
+            ],
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error executing command: ${error instanceof Error ? error.message : String(error)}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+      },
+    );
+
+    this.registry.register(
+      "poolbot_list_directory",
+      "List files and directories",
+      {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Directory path to list",
+          },
+        },
+        required: ["path"],
+      },
+      async (args) => {
+        const { path: dirPath } = args as { path: string };
+        try {
+          const fs = await import("node:fs/promises");
+          const entries = await fs.readdir(dirPath, { withFileTypes: true });
+          const result = entries
+            .map((entry) => `${entry.isDirectory() ? "📁" : "📄"} ${entry.name}`)
+            .join("\n");
+          return {
+            content: [
+              {
+                type: "text",
+                text: result || "(empty directory)",
+              },
+            ],
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error listing directory: ${error instanceof Error ? error.message : String(error)}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+      },
+    );
+
+    this.registry.register(
+      "poolbot_search_files",
+      "Search for files matching a pattern",
+      {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "Glob pattern to search for",
+          },
+          path: {
+            type: "string",
+            description: "Base directory to search in",
+          },
+        },
+        required: ["pattern"],
+      },
+      async (args) => {
+        const { pattern, path: basePath = "." } = args as {
+          pattern: string;
+          path?: string;
+        };
+        try {
+          const { glob } = await import("glob");
+          const matches = await glob(pattern, { cwd: basePath, absolute: true });
+          return {
+            content: [
+              {
+                type: "text",
+                text: matches.join("\n") || "(no matches)",
+              },
+            ],
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error searching files: ${error instanceof Error ? error.message : String(error)}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+      },
+    );
+
+    this.registry.register(
+      "poolbot_send_message",
+      "Send a message through PoolBot",
+      {
+        type: "object",
+        properties: {
+          channel: {
+            type: "string",
+            description: "Channel to send message to (e.g., telegram, discord)",
+          },
+          to: {
+            type: "string",
+            description: "Recipient ID or chat ID",
+          },
+          message: {
+            type: "string",
+            description: "Message content",
+          },
+        },
+        required: ["channel", "to", "message"],
+      },
+      async (args) => {
+        const { channel, to, message } = args as {
+          channel: string;
+          to: string;
+          message: string;
+        };
+        // This would integrate with PoolBot's message sending
+        // For now, return a placeholder
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Message queued for ${channel}:${to}: ${message.slice(0, 100)}...`,
+            },
+          ],
+        };
+      },
+    );
+  }
+
+  private async handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    // Set CORS headers
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    if (req.method !== "POST") {
+      res.writeHead(405, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Method not allowed" }));
+      return;
+    }
+
+    // Read body
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
+    const body = Buffer.concat(chunks).toString("utf-8");
+
+    let request: McpRequest;
+    try {
+      request = JSON.parse(body) as McpRequest;
+    } catch {
+      const response: McpResponse = {
+        jsonrpc: "2.0",
+        id: 0,
+        error: { code: -32700, message: "Parse error" },
+      };
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(response));
+      return;
+    }
+
+    const response = await this.processRequest(request);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(response));
+  }
+
+  private async processRequest(request: McpRequest): Promise<McpResponse> {
+    const { id, method, params } = request;
+
+    switch (method) {
+      case "initialize": {
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: {
+              tools: {},
+            },
+            serverInfo: {
+              name: "poolbot-mcp-server",
+              version: "2026.3.9",
+            },
+          },
+        };
+      }
+
+      case "tools/list": {
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: this.registry.getAllTools(),
+          },
+        };
+      }
+
+      case "tools/call": {
+        const { name, arguments: args } = params as { name: string; arguments?: unknown };
+        const result = await this.registry.execute(name, args);
+        return {
+          jsonrpc: "2.0",
+          id,
+          result,
+        };
+      }
+
+      default: {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32601, message: `Method not found: ${method}` },
+        };
+      }
+    }
+  }
+
+  start(): Promise<void> {
+    return new Promise((resolve) => {
+      this.server = createServer((req, res) => {
+        this.handleRequest(req, res).catch(() => {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Internal server error" }));
+        });
+      });
+
+      this.server.listen(this.port, () => {
+        console.log(`MCP Server listening on port ${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+export function createMcpServerService(): PoolBotPluginService {
+  let server: McpServer | null = null;
+
+  return {
+    id: "mcp-server",
+    async start(ctx) {
+      const port = Number(process.env.POOLBOT_MCP_PORT) || 8765;
+      server = new McpServer(port);
+      await server.start();
+      ctx.logger.info(`MCP Server started on port ${port}`);
+    },
+    async stop() {
+      if (server) {
+        await server.stop();
+        server = null;
+      }
+    },
+  };
+}

package/extensions/memory-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolbot/memory-core",
-  "version": "2026.3.4",
+  "version": "2026.3.11",
   "type": "module",
   "description": "Poolbot core memory search plugin",
   "poolbot": {

package/extensions/memory-lancedb/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolbot/memory-lancedb",
-  "version": "2026.3.4",
+  "version": "2026.3.11",
   "type": "module",
   "description": "Poolbot LanceDB-backed long-term memory plugin with auto-recall/capture",
   "dependencies": {

package/extensions/minimax-portal-auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/minimax-portal-auth",
-  "version": "2026.3.4",
+  "version": "2026.3.11",
   "private": true,
   "description": "Pool Bot MiniMax Portal OAuth provider plugin",
   "type": "module",

package/extensions/msteams/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2026.3.11
+
+### Changes
+- Version alignment with core Poolbot release numbers.
+
+## 2026.3.10
+
+### Changes
+- Version alignment with core Poolbot release numbers.
+
 ## 2026.3.4
 
 ### Changes

package/extensions/msteams/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolbot/msteams",
-  "version": "2026.3.4",
+  "version": "2026.3.11",
   "type": "module",
   "description": "Poolbot Microsoft Teams channel plugin",
   "poolbot": {

package/extensions/nextcloud-talk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolbot/nextcloud-talk",
-  "version": "2026.3.4",
+  "version": "2026.3.11",
   "type": "module",
   "description": "Poolbot Nextcloud Talk channel plugin",
   "poolbot": {

package/extensions/nostr/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2026.3.11
+
+### Changes
+- Version alignment with core Poolbot release numbers.
+
+## 2026.3.10
+
+### Changes
+- Version alignment with core Poolbot release numbers.
+
 ## 2026.3.4
 
 ### Changes