@almadar/integrations 2.19.0 → 2.21.0

package/dist/index.js

@@ -11,8 +11,27 @@ import { execSync, spawn } from 'child_process';
 import { mkdtempSync, writeFileSync, rmSync, promises } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
+import { Pool } from 'pg';
 
-// src/core/logger.ts
+// src/types.ts
+var IntegrationError = class extends Error {
+  constructor(message, code = "UNKNOWN_ERROR", details) {
+    super(message);
+    this.name = "IntegrationError";
+    this.code = code;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      integration: this.integration,
+      action: this.action,
+      details: this.details
+    };
+  }
+};
 var ConsoleLogger = class {
   constructor(_level = "info") {
     this.log = createLogger("almadar:integrations");
@@ -1121,26 +1140,6 @@ Return ONLY valid JSON matching the schema.`,
 };
 registerIntegration("llm", LLMIntegration);
 
-// src/types.ts
-var IntegrationError = class extends Error {
-  constructor(message, code = "UNKNOWN_ERROR", details) {
-    super(message);
-    this.name = "IntegrationError";
-    this.code = code;
-    this.details = details;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      integration: this.integration,
-      action: this.action,
-      details: this.details
-    };
-  }
-};
-
 // src/integrations/ml/index.ts
 var INFERRED_EVENT = "INFERRED";
 var INFER_FAILED_EVENT = "INFER_FAILED";
@@ -3172,6 +3171,488 @@ var DockerIntegration = class extends BaseIntegration {
 };
 registerIntegration("docker", DockerIntegration);
 
-export { BaseIntegration, CLIIntegration, ConsoleLogger, DeepAgentIntegration, DockerIntegration, EmailIntegration, GitHubIntegration, IntegrationFactory, LLMIntegration, MLIntegration, OAuthIntegration, OtelIntegration, QueueIntegration, RedisIntegration, StorageIntegration, StripeIntegration, TwilioIntegration, YouTubeIntegration, getIntegration, getIntegrationFactory, getRegisteredIntegrations, isKnownIntegration, registerIntegration, resetIntegrationFactory, validateParams, verifyAndParseStripeEvent, withRetry };
+// src/integrations/database/sql-guard.ts
+var DENIED_KEYWORDS = /* @__PURE__ */ new Set(["INSERT", "UPDATE", "DELETE", "MERGE", "INTO", "FOR"]);
+function isWordChar(ch) {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_" || ch === "$";
+}
+function skipSingleQuoted(sql, start, eString) {
+  let i = start + 1;
+  while (i < sql.length) {
+    if (eString && sql[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (sql[i] === "'") {
+      if (sql[i + 1] === "'") {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i++;
+  }
+  return sql.length;
+}
+function skipDoubleQuoted(sql, start) {
+  let i = start + 1;
+  while (i < sql.length) {
+    if (sql[i] === '"') {
+      if (sql[i + 1] === '"') {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i++;
+  }
+  return sql.length;
+}
+function matchDollarTag(sql, start) {
+  let i = start + 1;
+  if (sql[i] === "$") return "$$";
+  const first = sql[i];
+  if (!first || !(first >= "a" && first <= "z" || first >= "A" && first <= "Z" || first === "_")) {
+    return void 0;
+  }
+  i++;
+  while (i < sql.length && isWordChar(sql[i]) && sql[i] !== "$") i++;
+  if (sql[i] !== "$") return void 0;
+  return sql.slice(start, i + 1);
+}
+function sanitizeSql(sql) {
+  const out = [];
+  let i = 0;
+  while (i < sql.length) {
+    const ch = sql[i];
+    if (ch === "-" && sql[i + 1] === "-") {
+      while (i < sql.length && sql[i] !== "\n") i++;
+      out.push(" ");
+      continue;
+    }
+    if (ch === "/" && sql[i + 1] === "*") {
+      let depth = 1;
+      i += 2;
+      while (i < sql.length && depth > 0) {
+        if (sql[i] === "/" && sql[i + 1] === "*") {
+          depth++;
+          i += 2;
+        } else if (sql[i] === "*" && sql[i + 1] === "/") {
+          depth--;
+          i += 2;
+        } else {
+          i++;
+        }
+      }
+      out.push(" ");
+      continue;
+    }
+    if (ch === "'") {
+      let j = i - 1;
+      while (j >= 0 && (sql[j] === " " || sql[j] === "	" || sql[j] === "\n" || sql[j] === "\r")) j--;
+      const prev = j >= 0 ? sql[j] : "";
+      const eString = (prev === "e" || prev === "E") && (j === 0 || !isWordChar(sql[j - 1]));
+      i = skipSingleQuoted(sql, i, eString);
+      out.push("''");
+      continue;
+    }
+    if (ch === '"') {
+      i = skipDoubleQuoted(sql, i);
+      out.push('""');
+      continue;
+    }
+    if (ch === "$") {
+      const tag = matchDollarTag(sql, i);
+      if (tag) {
+        const close = sql.indexOf(tag, i + tag.length);
+        i = close === -1 ? sql.length : close + tag.length;
+        out.push("$$");
+        continue;
+      }
+    }
+    out.push(ch);
+    i++;
+  }
+  return out.join("");
+}
+function assertReadOnlySelect(sql) {
+  const sanitized = sanitizeSql(sql);
+  const statements = sanitized.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (statements.length === 0) {
+    return { ok: false, reason: "Empty statement" };
+  }
+  if (statements.length > 1) {
+    return { ok: false, reason: "Only a single statement is allowed" };
+  }
+  const words = (statements[0].match(/\b[A-Za-z_][A-Za-z0-9_]*\b/g) ?? []).map(
+    (w) => w.toUpperCase()
+  );
+  const first = words[0];
+  if (first !== "SELECT" && first !== "WITH") {
+    return { ok: false, reason: "Only SELECT statements are allowed" };
+  }
+  const denied = words.find((w) => DENIED_KEYWORDS.has(w));
+  if (denied) {
+    return { ok: false, reason: `Keyword not allowed in a read-only query: ${denied}` };
+  }
+  return { ok: true };
+}
+
+// src/integrations/database/index.ts
+var DEFAULT_STATEMENT_TIMEOUT_MS = 1e4;
+var PG_QUERY_CANCELED = "57014";
+var PostgresDriver = class {
+  constructor(connectionString, statementTimeoutMs) {
+    this.pool = new Pool({
+      connectionString,
+      statement_timeout: statementTimeoutMs,
+      query_timeout: statementTimeoutMs
+    });
+  }
+  async query(sql, params) {
+    const result = await this.pool.query(sql, [...params]);
+    return {
+      rows: result.rows,
+      rowCount: result.rowCount ?? result.rows.length
+    };
+  }
+  async end() {
+    await this.pool.end();
+  }
+};
+function mapDriverError(error) {
+  if (error instanceof IntegrationError) return error;
+  const code = error.code;
+  if (code === PG_QUERY_CANCELED) {
+    return new IntegrationError("Statement timeout exceeded", "TIMEOUT_ERROR");
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new IntegrationError(message, "SERVICE_ERROR");
+}
+var DatabaseIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.drivers = /* @__PURE__ */ new Map();
+    const fromEnv = config.env.DATABASE_STATEMENT_TIMEOUT_MS;
+    if (fromEnv) {
+      const parsed = Number(fromEnv);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid DATABASE_STATEMENT_TIMEOUT_MS: ${fromEnv}`);
+      }
+      this.statementTimeoutMs = parsed;
+    } else {
+      this.statementTimeoutMs = config.timeout ?? DEFAULT_STATEMENT_TIMEOUT_MS;
+    }
+    this.logger.info("Database integration initialized", {
+      statementTimeoutMs: this.statementTimeoutMs
+    });
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "query":
+          data = await this.executeWithRetry(() => this.runQuery(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return {
+        success: true,
+        data,
+        metadata: this.createMetadata(action, Date.now() - startTime)
+      };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async runQuery(params) {
+    const guard = assertReadOnlySelect(params.sql);
+    if (!guard.ok) {
+      throw new IntegrationError(
+        `Read-only violation: ${guard.reason ?? "not a SELECT statement"}`,
+        "VALIDATION_ERROR"
+      );
+    }
+    const driver = this.driverFor(params.connectionRef);
+    this.logger.debug("Database QUERY", { connectionRef: params.connectionRef });
+    try {
+      return await driver.query(params.sql, params.params ?? []);
+    } catch (error) {
+      throw mapDriverError(error);
+    }
+  }
+  /** Resolve (and cache) the driver for a connection reference. */
+  driverFor(connectionRef) {
+    const connectionString = process.env[connectionRef];
+    if (!connectionString) {
+      throw new IntegrationError(
+        `Connection reference "${connectionRef}" is not set in the environment`,
+        "AUTH_ERROR"
+      );
+    }
+    const cached = this.drivers.get(connectionString);
+    if (cached) return cached;
+    const driver = new PostgresDriver(connectionString, this.statementTimeoutMs);
+    this.drivers.set(connectionString, driver);
+    return driver;
+  }
+};
+registerIntegration("database", DatabaseIntegration);
+
+// src/integrations/wikimedia/index.ts
+var WIKI_ENDPOINT = "https://en.wikipedia.org/w/api.php";
+var DEFAULT_UA = "Almadar/1.0 (https://almadar.dev)";
+var DEFAULT_TIMEOUT_MS2 = 6e3;
+var EXTRACT_CHAR_CAP = 2e3;
+var WikimediaIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.userAgent = config.env?.WIKIMEDIA_USER_AGENT ?? DEFAULT_UA;
+    this.timeoutMs = Number(config.env?.WIKIMEDIA_TIMEOUT_MS ?? DEFAULT_TIMEOUT_MS2);
+    this.logger.info("Wikimedia integration initialized");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "getPage":
+          data = await this.executeWithRetry(() => this.getPage(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return { success: true, data, metadata: this.createMetadata(action, Date.now() - startTime) };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  /** Look up a title on Wikipedia: description, portrait, lead extract. Empty fields on miss. */
+  async getPage(params) {
+    const title = String(params.title ?? "").trim();
+    if (!title) return {};
+    const url = `${WIKI_ENDPOINT}?action=query&format=json&redirects=1&prop=pageimages|description|extracts&explaintext=1&exintro=1&piprop=thumbnail&pithumbsize=240&titles=${encodeURIComponent(title)}`;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(url, { headers: { "User-Agent": this.userAgent }, signal: ctrl.signal });
+      if (!res.ok) return {};
+      const data = await res.json();
+      const pages = data.query?.pages;
+      if (!pages) return {};
+      const page = Object.values(pages)[0];
+      if (!page || page.missing !== void 0) return {};
+      const extract = typeof page.extract === "string" ? page.extract.slice(0, EXTRACT_CHAR_CAP).trim() : void 0;
+      return {
+        title: page.title,
+        description: page.description ?? (typeof page.extract === "string" ? page.extract.split(".")[0] : void 0),
+        portraitUrl: page.thumbnail?.source,
+        extract
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+registerIntegration("wikimedia", WikimediaIntegration);
+
+// src/integrations/iconify/index.ts
+var ICONIFY_API = "https://api.iconify.design";
+var DEFAULT_UA2 = "Almadar/1.0 (https://almadar.dev)";
+var DEFAULT_TIMEOUT_MS3 = 6e3;
+var IconifyIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.userAgent = config.env?.ICONIFY_USER_AGENT ?? DEFAULT_UA2;
+    this.timeoutMs = Number(config.env?.ICONIFY_TIMEOUT_MS ?? DEFAULT_TIMEOUT_MS3);
+    this.logger.info("Iconify integration initialized");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "svgExists":
+          data = await this.executeWithRetry(() => this.svgExists(params));
+          break;
+        case "search":
+          data = await this.executeWithRetry(() => this.search(params));
+          break;
+        case "getIconBody":
+          data = await this.executeWithRetry(() => this.getIconBody(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return { success: true, data, metadata: this.createMetadata(action, Date.now() - startTime) };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async svgExists(params) {
+    const path = String(params.path ?? "");
+    if (!path) return { exists: false };
+    return { exists: await this.headOk(`${ICONIFY_API}/${path}`) };
+  }
+  async search(params) {
+    const query = String(params.query ?? "");
+    if (!query) return { icons: [] };
+    const limit = Number(params.limit ?? 1);
+    const data = await this.getJson(`${ICONIFY_API}/search?query=${encodeURIComponent(query)}&limit=${limit}`);
+    return { icons: data?.icons ?? [] };
+  }
+  async getIconBody(params) {
+    const iconId = String(params.iconId ?? "");
+    const [prefix, name] = iconId.split(":");
+    if (!prefix || !name) return { body: null };
+    const data = await this.getJson(`${ICONIFY_API}/${prefix}.json?icons=${encodeURIComponent(name)}`);
+    return { body: data?.icons?.[name]?.body ?? data?.aliases?.[name]?.body ?? null };
+  }
+  async headOk(url) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(url, { method: "GET", headers: { "User-Agent": this.userAgent }, signal: ctrl.signal });
+      return res.ok;
+    } catch {
+      return false;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async getJson(url) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(url, { headers: { "User-Agent": this.userAgent }, signal: ctrl.signal });
+      if (!res.ok) return null;
+      return await res.json();
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+registerIntegration("iconify", IconifyIntegration);
+
+// src/integrations/arxiv/index.ts
+var ARXIV_ENDPOINT = "https://export.arxiv.org/api/query";
+var DEFAULT_TIMEOUT_MS4 = 1e4;
+var DEFAULT_MAX_RESULTS = 8;
+function parseAtom(xml) {
+  const entries = [];
+  for (const block of xml.split("<entry>").slice(1)) {
+    const grab = (tag) => {
+      const m = block.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "i"));
+      return m ? m[1].replace(/<[^>]+>/g, "").trim() : "";
+    };
+    const id = grab("id");
+    const title = grab("title").replace(/\s+/g, " ");
+    const summary = grab("summary").replace(/\s+/g, " ");
+    const published = grab("published");
+    const authors = Array.from(block.matchAll(/<author>\s*<name>([^<]+)<\/name>/g)).map((m) => m[1].trim());
+    const linkMatch = block.match(/<link[^>]*rel="alternate"[^>]*href="([^"]+)"/i);
+    const url = linkMatch ? linkMatch[1] : id;
+    if (id || title) entries.push({ id, title, summary, authors, published, url });
+  }
+  return entries;
+}
+var ArxivIntegration = class extends BaseIntegration {
+  constructor(config) {
+    super(config);
+    this.timeoutMs = Number(config.env?.ARXIV_TIMEOUT_MS ?? DEFAULT_TIMEOUT_MS4);
+    this.logger.info("arXiv integration initialized");
+  }
+  async execute(action, params) {
+    const validation = this.validateParams(action, params);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          name: "IntegrationError",
+          message: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: validation.errors
+        },
+        metadata: this.createMetadata(action, 0)
+      };
+    }
+    const startTime = Date.now();
+    try {
+      let data;
+      switch (action) {
+        case "search":
+          data = await this.executeWithRetry(() => this.search(params));
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      return { success: true, data, metadata: this.createMetadata(action, Date.now() - startTime) };
+    } catch (error) {
+      return this.handleError(action, error);
+    }
+  }
+  async search(params) {
+    const query = String(params.query ?? "").trim();
+    if (!query) return { results: [] };
+    const maxResults = Number(params.maxResults ?? DEFAULT_MAX_RESULTS);
+    const url = `${ARXIV_ENDPOINT}?search_query=${encodeURIComponent(`all:${query}`)}&start=0&max_results=${maxResults}&sortBy=relevance`;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(url, { headers: { "Accept": "application/atom+xml" }, signal: ctrl.signal });
+      if (!res.ok) return { results: [] };
+      const xml = await res.text();
+      return { results: parseAtom(xml) };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+registerIntegration("arxiv", ArxivIntegration);
+
+export { ArxivIntegration, BaseIntegration, CLIIntegration, ConsoleLogger, DatabaseIntegration, DeepAgentIntegration, DockerIntegration, EmailIntegration, GitHubIntegration, IconifyIntegration, IntegrationError, IntegrationFactory, LLMIntegration, MLIntegration, OAuthIntegration, OtelIntegration, QueueIntegration, RedisIntegration, StorageIntegration, StripeIntegration, TwilioIntegration, WikimediaIntegration, YouTubeIntegration, assertReadOnlySelect, getIntegration, getIntegrationFactory, getRegisteredIntegrations, isKnownIntegration, registerIntegration, resetIntegrationFactory, validateParams, verifyAndParseStripeEvent, withRetry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map