@openenthrium/oe-runtime-sdk 1.7.5

package/src/utils/tools/adapters/confluence.js

@@ -0,0 +1,80 @@
+const axios = require("axios");
+
+function cfg(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function client({ domain, email, apiToken }) {
+  return axios.create({
+    baseURL: `https://${domain}/wiki/rest/api`,
+    auth: { username: email, password: apiToken },
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+const TOOLS = c => [
+  { action: "search_pages", desc: `Search Confluence pages via ${c.name}.`,
+    params: { query:    { type: "string", description: "Search query." },
+              spaceKey: { type: "string", description: "Optional space key to limit search." } }, required: ["query"] },
+  { action: "get_page",    desc: `Get content of a Confluence page by ID via ${c.name}.`,
+    params: { pageId: { type: "string", description: "Confluence page ID." } }, required: ["pageId"] },
+  { action: "list_spaces", desc: `List Confluence spaces via ${c.name}.`, params: {}, required: [] },
+];
+
+function getToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({
+    type: "function",
+    function: { name: `conn_${connector.id}_${t.action}`, description: t.desc,
+      parameters: { type: "object", properties: t.params, required: t.required } },
+  }));
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({
+    name: `conn_${connector.id}_${t.action}`, description: t.desc,
+    input_schema: { type: "object", properties: t.params, required: t.required },
+  }));
+}
+
+async function executeTool(action, args, connector) {
+  const creds = cfg(connector);
+  if (!creds.domain || !creds.apiToken) return "Confluence not configured. Please add credentials in Integrations.";
+  const api = client(creds);
+
+  try {
+    if (action === "search_pages") {
+      const { query, spaceKey } = args;
+      let cql = `type=page AND text~"${query}"`;
+      if (spaceKey) cql += ` AND space.key="${spaceKey}"`;
+      const res = await api.get(`/content/search?cql=${encodeURIComponent(cql)}&limit=10`);
+      const results = res.data.results || [];
+      if (!results.length) return "No pages found.";
+      return results.map(r => `[${r.id}] ${r.title} (Space: ${r.space?.name})`).join("\n");
+    }
+
+    if (action === "get_page") {
+      const res = await api.get(`/content/${args.pageId}?expand=body.storage`);
+      const text = res.data.body?.storage?.value?.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim() || "";
+      return `Title: ${res.data.title}\n\n${text.slice(0, 3000)}`;
+    }
+
+    if (action === "list_spaces") {
+      const res = await api.get("/space?limit=25&type=global");
+      const spaces = res.data.results || [];
+      return spaces.map(s => `${s.key}: ${s.name}`).join("\n") || "No spaces found.";
+    }
+
+    return `Unknown Confluence action: ${action}`;
+  } catch (err) {
+    return `Confluence error: ${err.response?.data?.message || err.message}`;
+  }
+}
+
+async function testConnection(authConfig) {
+  try {
+    const res = await client(authConfig).get("/space?limit=1");
+    return Array.isArray(res.data.results);
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };

package/src/utils/tools/adapters/database.js

@@ -0,0 +1,215 @@
+const DEFAULT_OPS = ["SELECT", "WITH", "SHOW", "DESCRIBE", "EXPLAIN"];
+
+function getAllowedOps(connector) {
+  try {
+    const cfg = connector.config ? JSON.parse(connector.config) : {};
+    return cfg.allowedOps?.length ? cfg.allowedOps : DEFAULT_OPS;
+  } catch { return DEFAULT_OPS; }
+}
+
+function isSafe(sql, allowedOps) {
+  const pattern = new RegExp(`^\\s*(${allowedOps.join("|")})\\s`, "i");
+  return pattern.test(sql.trim());
+}
+
+function getToolDefinitions(connector) {
+  const ops = getAllowedOps(connector);
+  return [{
+    type: "function",
+    function: {
+      name: `conn_${connector.id}_query`,
+      description: `Execute a SQL statement on the "${connector.name}" ${connector.type} database. Allowed operations: ${ops.join(", ")}.`,
+      parameters: {
+        type: "object",
+        properties: {
+          sql: { type: "string", description: `SQL statement using allowed operations: ${ops.join(", ")}.` }
+        },
+        required: ["sql"]
+      }
+    }
+  }];
+}
+
+// Anthropic tool_use format
+function getAnthropicToolDefinitions(connector) {
+  const ops = getAllowedOps(connector);
+  return [{
+    name: `conn_${connector.id}_query`,
+    description: `Execute a SQL statement on the "${connector.name}" ${connector.type} database. Allowed operations: ${ops.join(", ")}.`,
+    input_schema: {
+      type: "object",
+      properties: {
+        sql: { type: "string", description: `SQL statement using allowed operations: ${ops.join(", ")}.` }
+      },
+      required: ["sql"]
+    }
+  }];
+}
+
+function applySafeLimit(sql, dialect, maxRows) {
+  const n     = maxRows > 0 ? maxRows : 100;
+  const clean = sql.replace(/;+\s*$/, "").trim();
+  if (/\bLIMIT\b/i.test(clean)) return clean;
+  if (/\bTOP\s+\d+\b/i.test(clean)) return clean;
+  if (/FETCH\s+FIRST\b/i.test(clean)) return clean;
+  if (/\bROWNUM\b/i.test(clean)) return clean;
+  if (/^\s*SELECT\s+(?:COUNT|SUM|AVG|MIN|MAX)\s*\(/i.test(clean)) return clean;
+  if (dialect === "mssql")  return clean.replace(/^(\s*SELECT\s+)/i, `$1TOP ${n} `);
+  if (dialect === "oracle") return clean + `\nFETCH FIRST ${n} ROWS ONLY`;
+  return clean + ` LIMIT ${n}`;
+}
+
+async function executeTool(action, args, connector) {
+  if (action !== "query") return "Unknown action.";
+
+  const sql        = (args.sql || "").trim();
+  const allowedOps = getAllowedOps(connector);
+  if (!sql) return "No SQL provided.";
+  if (!isSafe(sql, allowedOps)) return `Operation not allowed. Permitted: ${allowedOps.join(", ")}.`;
+
+  const isSelect = /^\s*SELECT\b/i.test(sql);
+  const cfg  = connector.config   ? JSON.parse(connector.config)   : {};
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const maxRows = cfg.maxRows || 100;
+
+  try {
+    if (connector.type === "postgresql") {
+      const { Pool } = require("pg");
+      const pool = new Pool({
+        connectionString: cfg.url || undefined,
+        host:     cfg.host     || auth.host     || "localhost",
+        port:     parseInt(cfg.port || auth.port || "5432"),
+        database: cfg.database || auth.database || undefined,
+        user:     auth.username || auth.user || cfg.user || undefined,
+        password: auth.password || cfg.password || undefined,
+        ssl:      cfg.ssl ? { rejectUnauthorized: false } : false,
+        connectionTimeoutMillis: 10000,
+        query_timeout: 30000,
+      });
+      const result = await pool.query(isSelect ? applySafeLimit(sql, "postgresql", maxRows) : sql);
+      await pool.end();
+      if (!result.rows.length) return "Query returned no results.";
+      return JSON.stringify(result.rows, null, 2);
+    }
+
+    if (connector.type === "mysql") {
+      const mysql = require("mysql2/promise");
+      const conn = await mysql.createConnection({
+        host:     cfg.host     || auth.host     || "localhost",
+        port:     parseInt(cfg.port || auth.port || "3306"),
+        database: cfg.database || auth.database || undefined,
+        user:     auth.username || auth.user || cfg.user || undefined,
+        password: auth.password || cfg.password || undefined,
+        ssl:      cfg.ssl ? { rejectUnauthorized: false } : undefined,
+        connectTimeout: 10000,
+      });
+      const [rows] = await conn.execute(isSelect ? applySafeLimit(sql, "mysql", maxRows) : sql);
+      await conn.end();
+      if (!rows.length) return "Query returned no results.";
+      return JSON.stringify(rows, null, 2);
+    }
+
+    if (connector.type === "mssql") {
+      const mssql = require("mssql");
+      const pool  = await mssql.connect({
+        server:   cfg.host     || "localhost",
+        port:     parseInt(cfg.port || "1433"),
+        database: cfg.database || undefined,
+        user:     auth.username || undefined,
+        password: auth.password || undefined,
+        options: {
+          encrypt:                cfg.encrypt !== false,
+          trustServerCertificate: cfg.trustServerCertificate || false,
+        },
+        connectionTimeout: 10000,
+        requestTimeout:    30000,
+      });
+      const result = await pool.request().query(isSelect ? applySafeLimit(sql, "mssql", maxRows) : sql);
+      await pool.close();
+      if (!result.recordset?.length) return "Query returned no results.";
+      return JSON.stringify(result.recordset, null, 2);
+    }
+
+    if (connector.type === "oracle") {
+      const oracledb = require("oracledb");
+      oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT;
+      const connectString = cfg.connectString ||
+        `${cfg.host || "localhost"}:${cfg.port || "1521"}/${cfg.serviceName || cfg.sid || "ORCL"}`;
+      const conn = await oracledb.getConnection({
+        user:          auth.username || undefined,
+        password:      auth.password || undefined,
+        connectString,
+      });
+      const result = await conn.execute(isSelect ? applySafeLimit(sql, "oracle", maxRows) : sql, [], { outFormat: oracledb.OUT_FORMAT_OBJECT });
+      await conn.close();
+      if (!result.rows?.length) return "Query returned no results.";
+      return JSON.stringify(result.rows, null, 2);
+    }
+
+    if (connector.type === "cockroachdb") {
+      const { Pool } = require("pg");
+      const pool = new Pool({
+        host:     cfg.host     || "localhost",
+        port:     parseInt(cfg.port || "26257"),
+        database: cfg.database || "defaultdb",
+        user:     auth.username || undefined,
+        password: auth.password || undefined,
+        ssl:      cfg.ssl ? { rejectUnauthorized: false } : false,
+        connectionTimeoutMillis: 10000,
+      });
+      const result = await pool.query(isSelect ? applySafeLimit(sql, "postgresql", maxRows) : sql);
+      await pool.end();
+      if (!result.rows.length) return "Query returned no results.";
+      return JSON.stringify(result.rows, null, 2);
+    }
+
+    if (connector.type === "sqlite") {
+      const Database = require("better-sqlite3");
+      const db = new Database(cfg.filename || ":memory:", { readonly: isSelect });
+      const stmt = db.prepare(isSelect ? applySafeLimit(sql, "sqlite", maxRows) : sql);
+      const rows = isSelect ? stmt.all() : [stmt.run()];
+      db.close();
+      if (!rows.length) return "Query returned no results.";
+      return JSON.stringify(rows, null, 2);
+    }
+
+    if (connector.type === "snowflake") {
+      const snowflake = require("snowflake-sdk");
+      const conn = await new Promise((resolve, reject) => {
+        const c = snowflake.createConnection({
+          account:   cfg.account,
+          username:  auth.username,
+          password:  auth.password,
+          database:  cfg.database,
+          schema:    cfg.schema   || "PUBLIC",
+          warehouse: cfg.warehouse,
+          role:      cfg.role     || undefined,
+        });
+        c.connect(err => err ? reject(err) : resolve(c));
+      });
+      const rows = await new Promise((resolve, reject) => {
+        conn.execute({ sqlText: isSelect ? applySafeLimit(sql, "snowflake", maxRows) : sql,
+          complete: (err, _stmt, rows) => err ? reject(err) : resolve(rows || []) });
+      });
+      conn.destroy(() => {});
+      if (!rows.length) return "Query returned no results.";
+      return JSON.stringify(rows, null, 2);
+    }
+
+    if (connector.type === "bigquery") {
+      const { BigQuery } = require("@google-cloud/bigquery");
+      const credentials = auth.keyFileJson ? JSON.parse(auth.keyFileJson) : undefined;
+      const bq = new BigQuery({ projectId: cfg.projectId, credentials });
+      const [rows] = await bq.query({ query: isSelect ? applySafeLimit(sql, "bigquery", maxRows) : sql,
+        defaultDataset: cfg.dataset ? { datasetId: cfg.dataset, projectId: cfg.projectId } : undefined });
+      if (!rows.length) return "Query returned no results.";
+      return JSON.stringify(rows, null, 2);
+    }
+
+    return `Unsupported database type: ${connector.type}`;
+  } catch (err) {
+    return `Database error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

package/src/utils/tools/adapters/dropbox.js

@@ -0,0 +1,74 @@
+const axios = require("axios");
+
+function auth(connector) { return connector.authConfig ? JSON.parse(connector.authConfig) : {}; }
+function cfg(connector)  { return connector.config    ? JSON.parse(connector.config)    : {}; }
+
+async function getToken(connector, db) {
+  const a = auth(connector);
+  const c = cfg(connector);
+  if (!a.refreshToken) return a.accessToken;
+  if (a.expiresAt && Date.now() < a.expiresAt - 60000) return a.accessToken;
+  const { data } = await axios.post("https://api.dropboxapi.com/oauth2/token",
+    new URLSearchParams({ grant_type: "refresh_token", refresh_token: a.refreshToken, client_id: c.appKey, client_secret: c.appSecret }),
+    { headers: { "Content-Type": "application/x-www-form-urlencoded" } });
+  const newAuth = { ...a, accessToken: data.access_token, expiresAt: Date.now() + (data.expires_in || 14400) * 1000 };
+  if (db) await db.connector.update({ where: { id: connector.id }, data: { authConfig: JSON.stringify(newAuth) } });
+  return data.access_token;
+}
+
+function api(token) {
+  return axios.create({ baseURL: "https://api.dropboxapi.com/2", headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" } });
+}
+
+const TOOLS = c => [
+  { action: "list_files", desc: `List files/folders in Dropbox via ${c.name}.`,
+    params: { path: { type: "string", description: 'Folder path e.g. "/Documents" or "" for root.' } }, required: [] },
+  { action: "read_file",  desc: `Read the text content of a Dropbox file via ${c.name}.`,
+    params: { path: { type: "string", description: "File path in Dropbox e.g. /Reports/q1.csv" } }, required: ["path"] },
+  { action: "search",     desc: `Search files in Dropbox via ${c.name}.`,
+    params: { query: { type: "string", description: "Search query." } }, required: ["query"] },
+];
+
+function getToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({ type: "function", function: { name: `conn_${connector.id}_${t.action}`, description: t.desc, parameters: { type: "object", properties: t.params, required: t.required } } }));
+}
+function getAnthropicToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({ name: `conn_${connector.id}_${t.action}`, description: t.desc, input_schema: { type: "object", properties: t.params, required: t.required } }));
+}
+
+async function executeTool(action, args, connector, db) {
+  const token = await getToken(connector, db);
+  try {
+    if (action === "list_files") {
+      const res = await api(token).post("/files/list_folder", { path: args.path || "", limit: 100 });
+      const entries = res.data.entries || [];
+      return entries.map(e => `${e[".tag"] === "folder" ? "📁" : "📄"} ${e.name} (path: ${e.path_display})`).join("\n") || "Empty folder.";
+    }
+    if (action === "read_file") {
+      const res = await axios.post("https://content.dropboxapi.com/2/files/download", null, {
+        headers: { Authorization: `Bearer ${token}`, "Dropbox-API-Arg": JSON.stringify({ path: args.path }) },
+        responseType: "text"
+      });
+      return String(res.data).slice(0, 8000);
+    }
+    if (action === "search") {
+      const res = await api(token).post("/files/search_v2", { query: args.query, options: { max_results: 20 } });
+      const matches = res.data.matches || [];
+      return matches.map(m => `${m.metadata?.metadata?.name} (${m.metadata?.metadata?.path_display})`).join("\n") || "No results.";
+    }
+    return `Unknown Dropbox action: ${action}`;
+  } catch (err) { return `Dropbox error: ${err.response?.data?.error_summary || err.message}`; }
+}
+
+async function testConnection(authConfig, config, db, connectorId) {
+  try {
+    const connector = { authConfig: JSON.stringify(authConfig), config: JSON.stringify(config || {}), id: connectorId };
+    const token = await getToken(connector, db);
+    const res = await axios.post("https://api.dropboxapi.com/2/users/get_current_account", null, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    return !!res.data.account_id;
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection, getToken };

package/src/utils/tools/adapters/elasticsearch.js

@@ -0,0 +1,90 @@
+const { Client } = require("@elastic/elasticsearch");
+
+function cfg(connector) {
+  return connector.config    ? JSON.parse(connector.config)    : {};
+}
+function auth(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function client(connector) {
+  const c = cfg(connector);
+  const a = auth(connector);
+  const opts = { node: c.node || "http://localhost:9200", requestTimeout: 15000 };
+  if (a.apiKey)                       opts.auth = { apiKey: a.apiKey };
+  else if (a.username || a.password)  opts.auth = { username: a.username, password: a.password };
+  return new Client(opts);
+}
+
+const TOOLS = c => {
+  const idx = JSON.parse(c.config || "{}").index || "your-index";
+  return [
+    { action: "search",   desc: `Search documents in ${c.name} (Elasticsearch).`,
+      params: { index: { type: "string", description: `Index name (default: ${idx})` },
+                query: { type: "object", description: 'Elasticsearch query DSL e.g. {"match":{"field":"value"}}' },
+                size:  { type: "number", description: "Max results (default 10)" } }, required: [] },
+    { action: "get",      desc: `Get a document by ID from ${c.name}.`,
+      params: { index: { type: "string", description: `Index name (default: ${idx})` },
+                id:    { type: "string", description: "Document ID." } }, required: ["id"] },
+    { action: "index_doc",desc: `Index (upsert) a document in ${c.name}.`,
+      params: { index:    { type: "string", description: `Index name (default: ${idx})` },
+                id:       { type: "string", description: "Document ID (optional, auto-generated if omitted)." },
+                document: { type: "object", description: "Document body to index." } }, required: ["document"] },
+  ];
+};
+
+function getToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({
+    type: "function",
+    function: { name: `conn_${connector.id}_${t.action}`, description: t.desc,
+      parameters: { type: "object", properties: t.params, required: t.required } },
+  }));
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({
+    name: `conn_${connector.id}_${t.action}`, description: t.desc,
+    input_schema: { type: "object", properties: t.params, required: t.required },
+  }));
+}
+
+async function executeTool(action, args, connector) {
+  const c   = cfg(connector);
+  const es  = client(connector);
+  const idx = args.index || c.index || "default";
+
+  try {
+    if (action === "search") {
+      const res = await es.search({ index: idx, size: args.size || 10,
+        body: args.query ? { query: args.query } : { query: { match_all: {} } } });
+      const hits = res.hits?.hits || [];
+      if (!hits.length) return "No documents found.";
+      return JSON.stringify(hits.map(h => ({ _id: h._id, _score: h._score, ...h._source })), null, 2);
+    }
+
+    if (action === "get") {
+      const res = await es.get({ index: idx, id: args.id });
+      return JSON.stringify({ _id: res._id, ...res._source }, null, 2);
+    }
+
+    if (action === "index_doc") {
+      const res = await es.index({ index: idx, id: args.id || undefined, document: args.document });
+      return `Document ${res.result}: _id=${res._id} in index "${idx}"`;
+    }
+
+    return `Unknown Elasticsearch action: ${action}`;
+  } catch (err) {
+    return `Elasticsearch error: ${err.message}`;
+  }
+}
+
+async function testConnection(authConfig, config) {
+  const connector = { config: JSON.stringify(config || {}), authConfig: JSON.stringify(authConfig || {}) };
+  try {
+    const es = client(connector);
+    await es.ping();
+    return true;
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };

package/src/utils/tools/adapters/filesystem.js

@@ -0,0 +1,197 @@
+"use strict";
+const fs   = require("fs");
+const path = require("path");
+
+function cfg(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : connector;
+}
+
+// Prevent directory traversal attacks
+function safePath(basePath, filePath) {
+  const resolved = path.resolve(basePath, filePath);
+  if (!resolved.startsWith(path.resolve(basePath))) {
+    throw new Error(`Access denied: path is outside basePath (${basePath})`);
+  }
+  return resolved;
+}
+
+const TOOLS = c => [
+  {
+    action: "list_dir",
+    desc: `List files and folders in a directory on the local filesystem via ${c.name}.`,
+    params: {
+      dir: { type: "string", description: "Directory path relative to basePath. Use '.' for root." },
+    },
+    required: ["dir"],
+  },
+  {
+    action: "read_file",
+    desc: `Read the contents of a file on the local filesystem via ${c.name}.`,
+    params: {
+      file: { type: "string", description: "File path relative to basePath." },
+    },
+    required: ["file"],
+  },
+  {
+    action: "write_file",
+    desc: `Write or overwrite a file on the local filesystem via ${c.name}.`,
+    params: {
+      file:    { type: "string", description: "File path relative to basePath." },
+      content: { type: "string", description: "Content to write." },
+    },
+    required: ["file", "content"],
+  },
+  {
+    action: "append_file",
+    desc: `Append content to an existing file on the local filesystem via ${c.name}.`,
+    params: {
+      file:    { type: "string", description: "File path relative to basePath." },
+      content: { type: "string", description: "Content to append." },
+    },
+    required: ["file", "content"],
+  },
+  {
+    action: "delete_file",
+    desc: `Delete a file on the local filesystem via ${c.name}.`,
+    params: {
+      file: { type: "string", description: "File path relative to basePath." },
+    },
+    required: ["file"],
+  },
+  {
+    action: "make_dir",
+    desc: `Create a directory (and any missing parents) on the local filesystem via ${c.name}.`,
+    params: {
+      dir: { type: "string", description: "Directory path relative to basePath." },
+    },
+    required: ["dir"],
+  },
+  {
+    action: "file_info",
+    desc: `Get metadata (size, modified date, type) of a file or directory via ${c.name}.`,
+    params: {
+      file: { type: "string", description: "File or directory path relative to basePath." },
+    },
+    required: ["file"],
+  },
+  {
+    action: "search_files",
+    desc: `Search for files by name pattern recursively via ${c.name}.`,
+    params: {
+      pattern: { type: "string", description: "Filename pattern to match (e.g. '*.js', 'README*')." },
+      dir:     { type: "string", description: "Directory to search in relative to basePath. Use '.' for all." },
+    },
+    required: ["pattern", "dir"],
+  },
+];
+
+function getToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({
+    type: "function",
+    function: {
+      name:        `conn_${connector.id}_${t.action}`,
+      description: t.desc,
+      parameters:  { type: "object", properties: t.params, required: t.required },
+    },
+  }));
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({
+    name:         `conn_${connector.id}_${t.action}`,
+    description:  t.desc,
+    input_schema: { type: "object", properties: t.params, required: t.required },
+  }));
+}
+
+function matchPattern(filename, pattern) {
+  const regex = new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i");
+  return regex.test(filename);
+}
+
+function searchRecursive(dir, pattern, results = []) {
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (matchPattern(entry.name, pattern)) results.push(fullPath);
+      if (entry.isDirectory()) searchRecursive(fullPath, pattern, results);
+    }
+  } catch {}
+  return results;
+}
+
+async function executeTool(action, args, connector) {
+  const { basePath } = cfg(connector);
+  if (!basePath) return "filesystem connector requires a basePath in config.";
+
+  try {
+    if (action === "list_dir") {
+      const target = safePath(basePath, args.dir || ".");
+      const entries = fs.readdirSync(target, { withFileTypes: true });
+      if (entries.length === 0) return "Directory is empty.";
+      return entries.map(e => `${e.isDirectory() ? "[dir] " : "[file]"} ${e.name}`).join("\n");
+    }
+
+    if (action === "read_file") {
+      const target = safePath(basePath, args.file);
+      if (!fs.existsSync(target)) return `File not found: ${args.file}`;
+      const content = fs.readFileSync(target, "utf8");
+      return content.length > 50000 ? content.slice(0, 50000) + "\n\n[truncated — file too large]" : content;
+    }
+
+    if (action === "write_file") {
+      const target = safePath(basePath, args.file);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, args.content, "utf8");
+      return `Written: ${args.file}`;
+    }
+
+    if (action === "append_file") {
+      const target = safePath(basePath, args.file);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.appendFileSync(target, args.content, "utf8");
+      return `Appended to: ${args.file}`;
+    }
+
+    if (action === "delete_file") {
+      const target = safePath(basePath, args.file);
+      if (!fs.existsSync(target)) return `File not found: ${args.file}`;
+      fs.unlinkSync(target);
+      return `Deleted: ${args.file}`;
+    }
+
+    if (action === "make_dir") {
+      const target = safePath(basePath, args.dir);
+      fs.mkdirSync(target, { recursive: true });
+      return `Directory created: ${args.dir}`;
+    }
+
+    if (action === "file_info") {
+      const target = safePath(basePath, args.file);
+      if (!fs.existsSync(target)) return `Not found: ${args.file}`;
+      const stat = fs.statSync(target);
+      return JSON.stringify({
+        path:     args.file,
+        type:     stat.isDirectory() ? "directory" : "file",
+        size:     `${(stat.size / 1024).toFixed(1)} KB`,
+        modified: stat.mtime.toISOString(),
+        created:  stat.birthtime.toISOString(),
+      }, null, 2);
+    }
+
+    if (action === "search_files") {
+      const target = safePath(basePath, args.dir || ".");
+      const results = searchRecursive(target, args.pattern);
+      if (results.length === 0) return `No files matching "${args.pattern}" found.`;
+      return results.map(r => path.relative(basePath, r)).join("\n");
+    }
+
+    return `Unknown action: ${action}`;
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };