@openenthrium/oe-runtime-sdk 1.7.5

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

@@ -0,0 +1,87 @@
+const axios = require("axios");
+
+function cfg(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function client({ domain, apiKey }) {
+  return axios.create({
+    baseURL: `https://${domain}/api/v2`,
+    auth: { username: apiKey, password: "X" },
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+const TOOLS = c => [
+  { action: "list_tickets",  desc: `List support tickets from Freshdesk via ${c.name}.`,
+    params: { status:   { type: "string", description: "Filter by status: open, pending, resolved, closed." },
+              priority: { type: "string", description: "Filter by priority: low, medium, high, urgent." } }, required: [] },
+  { action: "get_ticket",   desc: `Get a Freshdesk ticket by ID via ${c.name}.`,
+    params: { ticketId: { type: "number", description: "Ticket ID." } }, required: ["ticketId"] },
+  { action: "create_ticket", desc: `Create a Freshdesk support ticket via ${c.name}.`,
+    params: { subject:     { type: "string", description: "Ticket subject." },
+              description: { type: "string", description: "Ticket description." },
+              email:       { type: "string", description: "Requester email." },
+              priority:    { type: "number", description: "Priority: 1=low, 2=medium, 3=high, 4=urgent. Default: 2." } }, required: ["subject","description","email"] },
+];
+
+const STATUS_MAP = { open: 2, pending: 3, resolved: 4, closed: 5 };
+const PRIORITY_MAP = { low: 1, medium: 2, high: 3, urgent: 4 };
+
+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.apiKey) return "Freshdesk not configured. Please add credentials in Integrations.";
+  const api = client(creds);
+
+  try {
+    if (action === "list_tickets") {
+      const params = new URLSearchParams({ per_page: "15" });
+      if (args.status)   params.set("status",   STATUS_MAP[args.status]   || 2);
+      if (args.priority) params.set("priority", PRIORITY_MAP[args.priority] || 2);
+      const res = await api.get(`/tickets?${params}`);
+      const tickets = res.data || [];
+      if (!tickets.length) return "No tickets found.";
+      return tickets.map(t => `[#${t.id}] ${t.subject} — Status: ${t.status}, Priority: ${t.priority}`).join("\n");
+    }
+
+    if (action === "get_ticket") {
+      const res = await api.get(`/tickets/${args.ticketId}`);
+      const t = res.data;
+      return JSON.stringify({ id: t.id, subject: t.subject, status: t.status, priority: t.priority, requester: t.requester_id, created: t.created_at, description: t.description_text?.slice(0, 500) }, null, 2);
+    }
+
+    if (action === "create_ticket") {
+      const { subject, description, email, priority = 2 } = args;
+      const res = await api.post("/tickets", { subject, description, email, priority, source: 2 });
+      return `Created ticket #${res.data.id}: ${subject}`;
+    }
+
+    return `Unknown Freshdesk action: ${action}`;
+  } catch (err) {
+    return `Freshdesk error: ${err.response?.data?.description || err.message}`;
+  }
+}
+
+async function testConnection(authConfig) {
+  try {
+    const res = await client(authConfig).get("/tickets?per_page=1");
+    return Array.isArray(res.data);
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };

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

@@ -0,0 +1,326 @@
+const { google } = require("googleapis");
+const { makeOAuth2Client } = require("./gmail");
+
+async function buildDriveClient(authConfig, db, workspaceId) {
+  const oauth2 = await makeOAuth2Client(db, workspaceId, "/api/oauth/gmail/callback", {
+    clientId:     authConfig.clientId,
+    clientSecret: authConfig.clientSecret,
+  });
+  oauth2.setCredentials({
+    access_token:  authConfig.accessToken,
+    refresh_token: authConfig.refreshToken,
+    expiry_date:   authConfig.expiresAt,
+  });
+  return google.drive({ version: "v3", auth: oauth2 });
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_list_files`,
+        description: `List files in the connected Google Drive (${connector.name}). Use to find files by name or type.`,
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query e.g. 'name contains apollo' or 'mimeType=text/csv'" },
+          },
+          required: []
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_read_file`,
+        description: `Download and read a CSV or Excel file from Google Drive (${connector.name}). Returns rows as JSON. Use to read prospect lists, data exports, etc.`,
+        parameters: {
+          type: "object",
+          properties: {
+            fileId:   { type: "string", description: "Google Drive file ID (from list_files)." },
+            fileName: { type: "string", description: "File name to search for if fileId is unknown." },
+            limit:    { type: "number", description: "Max rows to return (default 100)." },
+            offset:   { type: "number", description: "Skip first N rows — use for pagination." },
+          },
+          required: []
+        }
+      }
+    }
+    ,
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_write_file`,
+        description: `Update an existing CSV or text file in Google Drive (${connector.name}). Use after reading and modifying rows to write the updated data back.`,
+        parameters: {
+          type: "object",
+          properties: {
+            fileId:   { type: "string",  description: "Google Drive file ID to overwrite." },
+            fileName: { type: "string",  description: "File name to search for if fileId is unknown." },
+            rows:     { type: "array",   description: "Array of row objects — the full updated dataset to write back.", items: { type: "object" } },
+          },
+          required: ["rows"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_update_rows`,
+        description: `Partially update rows in a CSV file in Google Drive (${connector.name}) without reading the whole file. Finds rows where matchColumn equals one of matchValues and sets setColumn to setValue. All other rows are preserved unchanged. Use this instead of write_file when updating a small number of rows in a large file.`,
+        parameters: {
+          type: "object",
+          properties: {
+            fileId:      { type: "string", description: "Google Drive file ID." },
+            fileName:    { type: "string", description: "File name to search for if fileId is unknown." },
+            matchColumn: { type: "string", description: "Column name to match against (e.g. 'Email')." },
+            matchValues: { type: "array",  description: "List of values to match in matchColumn (e.g. list of email addresses).", items: { type: "string" } },
+            setColumn:   { type: "string", description: "Column name to update (e.g. 'First Email Sent')." },
+            setValue:    { type: "string", description: "Value to set in setColumn for matched rows (e.g. 'yes')." },
+          },
+          required: ["matchColumn", "matchValues", "setColumn", "setValue"]
+        }
+      }
+    }
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return [
+    {
+      name: `conn_${connector.id}_list_files`,
+      description: `List files in the connected Google Drive (${connector.name}).`,
+      input_schema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query e.g. 'name contains apollo'" },
+        },
+        required: []
+      }
+    },
+    {
+      name: `conn_${connector.id}_read_file`,
+      description: `Download and read a CSV or Excel file from Google Drive (${connector.name}). Returns rows as JSON.`,
+      input_schema: {
+        type: "object",
+        properties: {
+          fileId:   { type: "string", description: "Google Drive file ID (from list_files)." },
+          fileName: { type: "string", description: "File name to search for if fileId is unknown." },
+          limit:    { type: "number", description: "Max rows to return (default 100)." },
+          offset:   { type: "number", description: "Skip first N rows — use for pagination." },
+        },
+        required: []
+      }
+    },
+    {
+      name: `conn_${connector.id}_write_file`,
+      description: `Update an existing CSV file in Google Drive (${connector.name}). Use after modifying rows to write the updated data back.`,
+      input_schema: {
+        type: "object",
+        properties: {
+          fileId:   { type: "string", description: "Google Drive file ID to overwrite." },
+          fileName: { type: "string", description: "File name to search for if fileId is unknown." },
+          rows:     { type: "array",  description: "Full updated array of row objects to write back.", items: { type: "object" } },
+        },
+        required: ["rows"]
+      }
+    },
+    {
+      name: `conn_${connector.id}_update_rows`,
+      description: `Partially update rows in a CSV file in Google Drive (${connector.name}) without reading the whole file. Finds rows where matchColumn equals one of matchValues and sets setColumn to setValue. All other rows are preserved. Use this instead of write_file when updating a small number of rows in a large file.`,
+      input_schema: {
+        type: "object",
+        properties: {
+          fileId:      { type: "string", description: "Google Drive file ID." },
+          fileName:    { type: "string", description: "File name to search for if fileId is unknown." },
+          matchColumn: { type: "string", description: "Column name to match against (e.g. 'Email')." },
+          matchValues: { type: "array",  description: "List of values to match (e.g. list of email addresses).", items: { type: "string" } },
+          setColumn:   { type: "string", description: "Column name to update (e.g. 'First Email Sent')." },
+          setValue:    { type: "string", description: "Value to set for matched rows (e.g. 'yes')." },
+        },
+        required: ["matchColumn", "matchValues", "setColumn", "setValue"]
+      }
+    }
+  ];
+}
+
+function rowsToCSV(rows) {
+  if (!rows.length) return "";
+  const headers = Object.keys(rows[0]);
+  const escape  = val => {
+    const s = String(val ?? "");
+    return s.includes(",") || s.includes('"') || s.includes("\n") ? `"${s.replace(/"/g, '""')}"` : s;
+  };
+  return [headers.join(","), ...rows.map(row => headers.map(h => escape(row[h])).join(","))].join("\n");
+}
+
+function parseCSV(text) {
+  const lines = text.split(/\r?\n/).filter(l => l.trim());
+  if (!lines.length) return [];
+  const headers = lines[0].split(",").map(h => h.replace(/^"|"$/g, "").trim());
+  return lines.slice(1).map(line => {
+    const vals = line.match(/(".*?"|[^,]+|(?<=,)(?=,)|^(?=,)|(?<=,)$)/g) || [];
+    const row = {};
+    headers.forEach((h, i) => {
+      row[h] = (vals[i] || "").replace(/^"|"$/g, "").trim();
+    });
+    return row;
+  });
+}
+
+async function executeTool(action, args, connector, db) {
+  const authConfig = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  if (!authConfig.refreshToken) return "Google Drive not connected. Please reconnect via the Integrations tab.";
+
+  try {
+    const drive = await buildDriveClient(authConfig, db, connector.workspaceId);
+
+    if (action === "list_files") {
+      const q = args.query
+        ? `${args.query} and trashed=false`
+        : "trashed=false";
+      const res = await drive.files.list({
+        q,
+        pageSize: 20,
+        fields: "files(id, name, mimeType, size, modifiedTime)",
+      });
+      const files = res.data.files || [];
+      if (!files.length) return "No files found.";
+      return JSON.stringify(files.map(f => ({
+        id: f.id, name: f.name, type: f.mimeType, modified: f.modifiedTime
+      })), null, 2);
+    }
+
+    if (action === "read_file") {
+      let fileId   = args.fileId;
+      let mimeType = "";
+
+      if (!fileId && args.fileName) {
+        const res = await drive.files.list({
+          q: `name contains '${args.fileName}' and trashed=false`,
+          pageSize: 5,
+          fields: "files(id, name, mimeType)",
+        });
+        const files = res.data.files || [];
+        if (!files.length) return `No file found matching "${args.fileName}".`;
+        fileId   = files[0].id;
+        mimeType = files[0].mimeType;
+      }
+
+      if (!fileId) return "Provide fileId or fileName.";
+
+      if (!mimeType) {
+        const meta = await drive.files.get({ fileId, fields: "mimeType" });
+        mimeType = meta.data.mimeType;
+      }
+
+      let rows = [];
+
+      const isExcel = mimeType.includes("spreadsheetml") || mimeType.includes("excel") || mimeType.includes("openxmlformats");
+      const isGSheet = mimeType.includes("google-apps.spreadsheet");
+
+      if (isGSheet) {
+        // Export Google Sheet as CSV
+        const res = await drive.files.export({ fileId, mimeType: "text/csv" }, { responseType: "text" });
+        rows = parseCSV(res.data);
+      } else if (isExcel) {
+        // Download Excel file and parse with xlsx
+        const XLSX = require("xlsx");
+        const res  = await drive.files.get({ fileId, alt: "media" }, { responseType: "arraybuffer" });
+        const wb   = XLSX.read(res.data, { type: "buffer" });
+        const ws   = wb.Sheets[wb.SheetNames[0]];
+        rows = XLSX.utils.sheet_to_json(ws, { defval: "" });
+      } else {
+        // Assume CSV
+        const res = await drive.files.get({ fileId, alt: "media" }, { responseType: "text" });
+        rows = parseCSV(res.data);
+      }
+
+      const limit  = args.limit  || 100;
+      const offset = args.offset || 0;
+      const page   = rows.slice(offset, offset + limit);
+
+      return JSON.stringify({ total: rows.length, offset, returned: page.length, rows: page }, null, 2);
+    }
+
+    if (action === "write_file") {
+      let fileId = args.fileId;
+
+      if (!fileId && args.fileName) {
+        const res = await drive.files.list({
+          q: `name contains '${args.fileName}' and trashed=false`,
+          pageSize: 5,
+          fields: "files(id, name, mimeType)",
+        });
+        const files = res.data.files || [];
+        if (!files.length) return `No file found matching "${args.fileName}".`;
+        fileId = files[0].id;
+      }
+
+      if (!fileId) return "Provide fileId or fileName to write.";
+
+      const csvContent = rowsToCSV(args.rows || []);
+
+      await drive.files.update({
+        fileId,
+        media: { mimeType: "text/csv", body: csvContent },
+      });
+
+      return `File updated successfully. ${(args.rows || []).length} rows written.`;
+    }
+
+    if (action === "update_rows") {
+      let fileId = args.fileId;
+      let mimeType = "";
+
+      if (!fileId && args.fileName) {
+        const res = await drive.files.list({
+          q: `name contains '${args.fileName}' and trashed=false`,
+          pageSize: 5, fields: "files(id, name, mimeType)",
+        });
+        const files = res.data.files || [];
+        if (!files.length) return `No file found matching "${args.fileName}".`;
+        fileId   = files[0].id;
+        mimeType = files[0].mimeType;
+      }
+      if (!fileId) return "Provide fileId or fileName for update_rows.";
+
+      if (!mimeType) {
+        const meta = await drive.files.get({ fileId, fields: "mimeType" });
+        mimeType = meta.data.mimeType;
+      }
+
+      // Read full file
+      let rows = [];
+      const isGSheet = mimeType.includes("google-apps.spreadsheet");
+      if (isGSheet) {
+        const res = await drive.files.export({ fileId, mimeType: "text/csv" }, { responseType: "text" });
+        rows = parseCSV(res.data);
+      } else {
+        const res = await drive.files.get({ fileId, alt: "media" }, { responseType: "text" });
+        rows = parseCSV(res.data);
+      }
+
+      const matchSet = new Set((args.matchValues || []).map(v => String(v).trim().toLowerCase()));
+      let updatedCount = 0;
+      for (const row of rows) {
+        const cellVal = String(row[args.matchColumn] ?? "").trim().toLowerCase();
+        if (matchSet.has(cellVal)) {
+          row[args.setColumn] = args.setValue;
+          updatedCount++;
+        }
+      }
+
+      const csvContent = rowsToCSV(rows);
+      await drive.files.update({ fileId, media: { mimeType: "text/csv", body: csvContent } });
+      return `Updated ${updatedCount} row(s): set "${args.setColumn}" = "${args.setValue}" where "${args.matchColumn}" matched. Total rows preserved: ${rows.length}.`;
+    }
+
+    return `Unknown Google Drive action: ${action}`;
+  } catch (err) {
+    return `Google Drive error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, buildDriveClient };

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

@@ -0,0 +1,169 @@
+const axios = require("axios");
+
+function cfg(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function parseRepo(repoUrl) {
+  if (!repoUrl) return {};
+  const m = repoUrl.replace(/\.git$/, "").match(/github\.com\/([^/]+)\/([^/]+)/);
+  return m ? { owner: m[1], repo: m[2] } : {};
+}
+
+function client({ personalAccessToken }) {
+  const headers = { Accept: "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28" };
+  if (personalAccessToken) headers.Authorization = `Bearer ${personalAccessToken}`;
+  return axios.create({ baseURL: "https://api.github.com", headers });
+}
+
+const TOOLS = (c, defaultRepo) => [
+  { action: "search_issues", desc: `Search GitHub issues and PRs in ${defaultRepo || c.name}.`,
+    params: { query: { type: "string", description: `Search query. Example: repo:${defaultRepo || "owner/repo"} is:open label:bug` } }, required: ["query"] },
+  { action: "get_issue",     desc: `Get a GitHub issue by number from ${defaultRepo || c.name}.`,
+    params: { owner:  { type: "string", description: `Repo owner (default: ${defaultRepo?.split("/")[0] || "owner"})` },
+              repo:   { type: "string", description: `Repo name (default: ${defaultRepo?.split("/")[1] || "repo"})` },
+              number: { type: "number", description: "Issue number." } }, required: ["number"] },
+  { action: "list_files",    desc: `List files/directories in ${defaultRepo || c.name} at a given path.`,
+    params: { path: { type: "string", description: 'Path inside the repo (default: "" = root).' } }, required: [] },
+  { action: "read_file",     desc: `Read the contents of a file from ${defaultRepo || c.name}.`,
+    params: { path: { type: "string", description: "File path inside the repo, e.g. src/index.js" } }, required: ["path"] },
+  { action: "create_issue",  desc: `Create a GitHub issue in ${defaultRepo || c.name}.`,
+    params: { owner:  { type: "string", description: "Repo owner." },
+              repo:   { type: "string", description: "Repo name." },
+              title:  { type: "string", description: "Issue title." },
+              body:   { type: "string", description: "Issue body/description." },
+              labels: { type: "array",  items: { type: "string" }, description: "Labels to apply." } }, required: ["title"] },
+  { action: "write_file",   desc: `Create or update a file in ${defaultRepo || c.name}. Automatically handles SHA for updates.`,
+    params: { path:    { type: "string", description: "File path inside the repo, e.g. blog/my-post.html" },
+              content: { type: "string", description: "Full file content as plain text." },
+              message: { type: "string", description: "Commit message, e.g. 'feat: publish blog — What is RAG?'" },
+              branch:  { type: "string", description: "Branch to commit to (default: repo default branch)." } }, required: ["path", "content"] },
+  { action: "delete_file", desc: `Delete a file from ${defaultRepo || c.name}. Automatically fetches the required SHA.`,
+    params: { path:    { type: "string", description: "File path inside the repo, e.g. blog/old-post.html" },
+              message: { type: "string", description: "Commit message, e.g. 'revert: remove blog post — old-post'" },
+              branch:  { type: "string", description: "Branch to delete from (default: repo default branch)." } }, required: ["path"] },
+];
+
+function getToolDefinitions(connector) {
+  const { repoUrl } = cfg(connector);
+  const { owner, repo } = parseRepo(repoUrl);
+  const defaultRepo = owner && repo ? `${owner}/${repo}` : null;
+  return TOOLS(connector, defaultRepo).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) {
+  const { repoUrl } = cfg(connector);
+  const { owner, repo } = parseRepo(repoUrl);
+  const defaultRepo = owner && repo ? `${owner}/${repo}` : null;
+  return TOOLS(connector, defaultRepo).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.repoUrl) return "GitHub connector not configured. Please add a repository URL in Integrations.";
+
+  const { owner: defOwner, repo: defRepo } = parseRepo(creds.repoUrl);
+  const api = client(creds);
+
+  const owner  = args.owner  || defOwner;
+  const repo   = args.repo   || defRepo;
+
+  try {
+    if (action === "search_issues") {
+      const res = await api.get(`/search/issues?q=${encodeURIComponent(args.query)}&per_page=15`);
+      const items = res.data.items || [];
+      if (!items.length) return "No issues found.";
+      return items.map(i => `[${i.repository_url?.split("/").slice(-2).join("/")}#${i.number}] ${i.title} (${i.state})`).join("\n");
+    }
+
+    if (action === "get_issue") {
+      const res = await api.get(`/repos/${owner}/${repo}/issues/${args.number}`);
+      const i = res.data;
+      return JSON.stringify({ number: i.number, title: i.title, state: i.state, author: i.user?.login, labels: i.labels?.map(l => l.name), body: i.body?.slice(0, 1000), created: i.created_at }, null, 2);
+    }
+
+    if (action === "list_files") {
+      const filePath = args.path || "";
+      const res = await api.get(`/repos/${owner}/${repo}/contents/${filePath}`);
+      const items = Array.isArray(res.data) ? res.data : [res.data];
+      return items.map(f => `${f.type === "dir" ? "📁" : "📄"} ${f.path}`).join("\n") || "Empty directory.";
+    }
+
+    if (action === "read_file") {
+      const res = await api.get(`/repos/${owner}/${repo}/contents/${args.path}`);
+      const content = Buffer.from(res.data.content, "base64").toString("utf8");
+      return content.slice(0, 8000);
+    }
+
+    if (action === "create_issue") {
+      const { title, body = "", labels = [] } = args;
+      const res = await api.post(`/repos/${owner}/${repo}/issues`, { title, body, labels });
+      return `Created issue #${res.data.number}: ${title}\n${res.data.html_url}`;
+    }
+
+    if (action === "write_file") {
+      const { path, content, message = `Update ${args.path}`, branch } = args;
+      const encoded = Buffer.from(content).toString("base64");
+
+      // Fetch existing SHA if file already exists (required by GitHub API for updates)
+      let sha;
+      try {
+        const url = `/repos/${owner}/${repo}/contents/${path}` + (branch ? `?ref=${branch}` : "");
+        const existing = await api.get(url);
+        sha = existing.data.sha;
+      } catch (_) {
+        // File does not exist yet — create mode
+      }
+
+      const payload = { message, content: encoded };
+      if (sha) payload.sha = sha;
+      if (branch) payload.branch = branch;
+
+      const res = await api.put(`/repos/${owner}/${repo}/contents/${path}`, payload);
+      const verb = sha ? "Updated" : "Created";
+      return `${verb} ${path}\nCommit: ${res.data.commit.sha}\n${res.data.content.html_url}`;
+    }
+
+    if (action === "delete_file") {
+      const { path, message = `Delete ${args.path}`, branch } = args;
+
+      // Fetch SHA — required by GitHub API to delete
+      let sha;
+      try {
+        const url = `/repos/${owner}/${repo}/contents/${path}` + (branch ? `?ref=${branch}` : "");
+        const existing = await api.get(url);
+        sha = existing.data.sha;
+      } catch (_) {
+        return `File not found: ${path}`;
+      }
+
+      const payload = { message, sha };
+      if (branch) payload.branch = branch;
+
+      const res = await api.delete(`/repos/${owner}/${repo}/contents/${path}`, { data: payload });
+      return `Deleted ${path}\nCommit: ${res.data.commit.sha}`;
+    }
+
+    return `Unknown GitHub action: ${action}`;
+  } catch (err) {
+    return `GitHub error: ${err.response?.data?.message || err.message}`;
+  }
+}
+
+async function testConnection(authConfig) {
+  try {
+    const { owner, repo } = parseRepo(authConfig.repoUrl);
+    if (!owner || !repo) return false;
+    const res = await client(authConfig).get(`/repos/${owner}/${repo}`);
+    return !!res.data.id;
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };