@tangle-network/agent-integrations 0.19.0 → 0.21.0

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   validateCredentialFormat,
   validateCredentialSet,
   validateIntegrationSpec
-} from "./chunk-DIJ3I66K.js";
+} from "./chunk-L6WBPDUP.js";
 
 // src/index.ts
 import { createHmac as createHmac4, randomUUID as randomUUID4, timingSafeEqual as timingSafeEqual3 } from "crypto";
@@ -250,6 +250,7 @@ var DEFAULT_SOURCE_PRECEDENCE = {
   "first-party": 500,
   spec: 400,
   gateway: 300,
+  "tangle-catalog": 100,
   activepieces: 100,
   coverage: 50
 };
@@ -262,7 +263,7 @@ var SUPPORT_RANK = {
 };
 function buildDefaultIntegrationRegistry(options = {}) {
   const includeSpecs = options.includeSpecs ?? true;
-  const includeActivepieces = options.includeActivepieces ?? true;
+  const includeTangleCatalog = options.includeTangleCatalog ?? options.includeActivepieces ?? true;
   const sources = [];
   if (includeSpecs) {
     sources.push({
@@ -270,10 +271,27 @@ function buildDefaultIntegrationRegistry(options = {}) {
       connectors: listIntegrationSpecs().map((spec) => integrationSpecToConnector(spec, "spec"))
     });
   }
-  if (includeActivepieces) {
+  if (includeTangleCatalog) {
     sources.push({
-      id: "activepieces",
-      connectors: buildActivepiecesConnectors()
+      id: "tangle-catalog",
+      connectors: buildActivepiecesConnectors({ providerId: "tangle-catalog" }).map((connector) => ({
+        ...connector,
+        providerId: "tangle-catalog",
+        metadata: {
+          source: "tangle-integrations-catalog",
+          providerId: "tangle-catalog",
+          executable: connector.metadata?.executable,
+          runtime: "tangle-catalog-runtime",
+          catalogOnly: connector.metadata?.catalogOnly,
+          supportTier: connector.metadata?.supportTier,
+          catalogActionCount: connector.metadata?.catalogActionCount,
+          catalogTriggerCount: connector.metadata?.catalogTriggerCount,
+          license: connector.metadata?.license,
+          version: connector.metadata?.version,
+          domains: Array.isArray(connector.metadata?.domains) ? connector.metadata.domains.filter((domain) => typeof domain === "string" && !domain.toLowerCase().includes("activepieces")) : void 0,
+          ...connector.metadata?.overridden ? { overridden: true } : {}
+        }
+      }))
     });
   }
   return composeIntegrationRegistry(sources);
@@ -341,7 +359,7 @@ function inferIntegrationSupportTier(connector) {
   if (metadata.source === "first-party-adapter" || connector.providerId === "first-party") return "firstPartyExecutable";
   if (metadata.source === "gateway-catalog" && metadata.executable === true) return "gatewayExecutable";
   if (metadata.source === "integration-spec") return "setupReady";
-  if (metadata.source === "coverage-catalog" || metadata.source === "activepieces-community" || metadata.catalogOnly === true) return "catalogOnly";
+  if (metadata.source === "coverage-catalog" || metadata.source === "activepieces-community" || metadata.source === "tangle-integrations-catalog" || metadata.catalogOnly === true) return "catalogOnly";
   if (connector.actions.length > 0) return "gatewayExecutable";
   return "catalogOnly";
 }
@@ -2139,10 +2157,11 @@ async function exchangeAuthorizationCode(input) {
     redirect_uri: input.redirectUri,
     code_verifier: input.codeVerifier
   });
-  const res = await fetch(input.tokenUrl, {
+  const res = await (input.fetchImpl ?? fetch)(input.tokenUrl, {
     method: "POST",
     headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },
-    body
+    body,
+    signal: input.signal
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
@@ -2164,10 +2183,11 @@ async function refreshAccessToken(input) {
     client_secret: input.clientSecret,
     refresh_token: input.refreshToken
   });
-  const res = await fetch(input.tokenUrl, {
+  const res = await (input.fetchImpl ?? fetch)(input.tokenUrl, {
     method: "POST",
     headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },
-    body
+    body,
+    signal: input.signal
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
@@ -5890,13 +5910,63 @@ function verifyActivepiecesRuntimeSignature(serializedBody, signature, secret) {
   return left.length === right.length && timingSafeEqual2(left, right);
 }
 function createTangleCatalogHttpExecutor(options) {
-  return createActivepiecesHttpExecutor({
-    ...options,
-    path: options.path ?? "/v1/integration-catalog/actions/invoke",
-    signatureHeader: options.signatureHeader ?? TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER
-  });
+  const endpoint = options.endpoint.replace(/\/$/, "");
+  const path = options.path ?? "/v1/integration-catalog/actions/invoke";
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const signatureHeader = options.signatureHeader ?? TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const requestId = options.requestId ?? (() => `tcat_${randomUUID3()}`);
+  return async (invocation) => {
+    const body = buildTangleCatalogRuntimeRequest(invocation, requestId());
+    const serialized = JSON.stringify(body);
+    const response = await fetchImpl(`${endpoint}${normalizedPath}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...options.headers,
+        ...options.secret ? { [signatureHeader]: signTangleCatalogRuntimeRequest(serialized, options.secret) } : {}
+      },
+      body: serialized,
+      signal: AbortSignal.timeout(options.timeoutMs ?? 3e4)
+    });
+    const parsed = await response.json().catch(() => void 0);
+    if (!response.ok) {
+      return parsed ?? {
+        ok: false,
+        action: invocation.request.action,
+        output: { message: `Tangle catalog runtime returned HTTP ${response.status}.` }
+      };
+    }
+    return parsed ?? {
+      ok: false,
+      action: invocation.request.action,
+      output: { message: "Tangle catalog runtime returned an empty response." }
+    };
+  };
+}
+function buildTangleCatalogRuntimeRequest(invocation, requestId = `tcat_${randomUUID3()}`) {
+  return {
+    version: 1,
+    requestId,
+    providerId: invocation.connection.providerId,
+    connection: invocation.connection,
+    connector: {
+      id: invocation.connector.id,
+      title: invocation.connector.title,
+      auth: invocation.connector.auth,
+      scopes: invocation.connector.scopes,
+      metadata: invocation.connector.metadata
+    },
+    piece: invocation.piece,
+    action: {
+      id: invocation.request.action,
+      input: invocation.request.input,
+      idempotencyKey: invocation.request.idempotencyKey,
+      dryRun: invocation.request.dryRun,
+      metadata: invocation.request.metadata
+    }
+  };
 }
-var buildTangleCatalogRuntimeRequest = buildActivepiecesRuntimeRequest;
 var signTangleCatalogRuntimeRequest = signActivepiecesRuntimeRequest;
 var verifyTangleCatalogRuntimeSignature = verifyActivepiecesRuntimeSignature;
 
@@ -6031,9 +6101,53 @@ async function checkActivepiecesPublicCatalog(input) {
 }
 
 // src/tangle-catalog.ts
-var listTangleIntegrationCatalogEntries = listActivepiecesCatalogEntries;
-var buildTangleIntegrationCatalogConnectors = buildActivepiecesConnectors;
-var createTangleCatalogExecutorProvider = createActivepiecesExecutorProvider;
+var TANGLE_INTEGRATIONS_CATALOG_PROVIDER_ID = "tangle-catalog";
+var TANGLE_INTEGRATIONS_CATALOG_SOURCE = "tangle-integrations-catalog";
+function listTangleIntegrationCatalogEntries() {
+  return listActivepiecesCatalogEntries().map((entry) => sanitizeEntry(entry));
+}
+function buildTangleIntegrationCatalogConnectors(options = {}) {
+  const providerId = options.providerId ?? TANGLE_INTEGRATIONS_CATALOG_PROVIDER_ID;
+  return buildActivepiecesConnectors({
+    ...options,
+    providerId
+  }).map((connector) => sanitizeConnector(connector, providerId));
+}
+function createTangleCatalogExecutorProvider(options) {
+  const providerId = options.id ?? TANGLE_INTEGRATIONS_CATALOG_PROVIDER_ID;
+  const connectors = options.connectors ?? buildTangleIntegrationCatalogConnectors({
+    providerId,
+    includeCatalogActions: true,
+    executable: true
+  });
+  const byEntry = new Map(listActivepiecesCatalogEntries().map((entry) => [entry.id, entry]));
+  return createCatalogExecutorProvider({
+    id: providerId,
+    kind: "tangle_catalog",
+    connectors,
+    startAuth: options.startAuth,
+    completeAuth: options.completeAuth,
+    executeAction: async ({ connection, request, connector, action }) => {
+      const importedEntry = byEntry.get(connector.id);
+      if (!importedEntry) {
+        throw new IntegrationError(`Tangle catalog entry ${connector.id} not found.`, "connector_not_found");
+      }
+      const catalogAction = importedEntry.actions.find((candidate) => candidate.id === action.id);
+      return options.executeAction({
+        connection,
+        request,
+        connector,
+        catalogEntry: sanitizeEntry(importedEntry),
+        piece: {
+          id: importedEntry.id,
+          version: importedEntry.version,
+          actionId: action.id,
+          upstreamActionName: catalogAction?.upstreamName
+        }
+      });
+    }
+  });
+}
 var extractExternalCatalogPublicCount = extractActivepiecesPublicPieceCount;
 async function auditTangleIntegrationCatalogFreshness(options = {}) {
   const result = await auditIntegrationCatalogFreshness(options);
@@ -6063,6 +6177,142 @@ async function auditTangleIntegrationCatalogFreshness(options = {}) {
     warnings: result.warnings.map((warning) => warning.replaceAll("Activepieces", "Tangle Integrations Catalog"))
   };
 }
+function sanitizeEntry(entry) {
+  return {
+    id: entry.id,
+    title: entry.title,
+    description: entry.description,
+    category: entry.category,
+    auth: entry.auth,
+    domains: entry.domains.filter((domain) => !domain.toLowerCase().includes("activepieces")),
+    actions: entry.actions.map((action) => ({
+      id: action.id,
+      title: action.title,
+      risk: action.risk
+    })),
+    triggers: entry.triggers.map((trigger2) => ({
+      id: trigger2.id,
+      title: trigger2.title
+    }))
+  };
+}
+function sanitizeConnector(connector, providerId) {
+  const metadata = connector.metadata ?? {};
+  return {
+    ...connector,
+    providerId,
+    metadata: {
+      source: TANGLE_INTEGRATIONS_CATALOG_SOURCE,
+      providerId,
+      executable: metadata.executable,
+      runtime: "tangle-catalog-runtime",
+      catalogOnly: metadata.catalogOnly,
+      supportTier: metadata.supportTier,
+      catalogActionCount: metadata.catalogActionCount,
+      catalogTriggerCount: metadata.catalogTriggerCount,
+      license: metadata.license,
+      version: metadata.version,
+      domains: Array.isArray(metadata.domains) ? metadata.domains.filter((domain) => typeof domain === "string" && !domain.toLowerCase().includes("activepieces")) : void 0,
+      ...metadata.overridden ? { overridden: true } : {}
+    }
+  };
+}
+
+// src/tangle-catalog-runtime.ts
+function createTangleCatalogRuntimeHandler(options) {
+  const connectors = options.connectors ?? buildTangleIntegrationCatalogConnectors({
+    includeCatalogActions: true,
+    executable: true
+  });
+  const byConnector = new Map(connectors.map((connector) => [connector.id, connector]));
+  const requireSignature = options.requireSignature ?? Boolean(options.secret);
+  const signatureHeader = options.signatureHeader ?? TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER;
+  const maxBodyBytes = options.maxBodyBytes ?? 1e6;
+  return async function handleTangleCatalogRuntimeRequest(input) {
+    const serialized = serializeBody(input.body);
+    if (Buffer.byteLength(serialized, "utf8") > maxBodyBytes) {
+      return errorResponse(413, "unknown", "payload_too_large", "Tangle catalog runtime request is too large.");
+    }
+    if (requireSignature) {
+      if (!options.secret) {
+        return errorResponse(500, "unknown", "runtime_misconfigured", "Tangle catalog runtime secret is not configured.");
+      }
+      const signature = readHeader(input.headers, signatureHeader);
+      if (!verifyTangleCatalogRuntimeSignature(serialized, signature, options.secret)) {
+        return errorResponse(401, "unknown", "signature_invalid", "Tangle catalog runtime signature is invalid.");
+      }
+    }
+    const parsed = parseRuntimeRequest(serialized);
+    if (!parsed.ok) return parsed.response;
+    const request = parsed.request;
+    const connector = byConnector.get(request.connector.id);
+    if (!connector) {
+      return errorResponse(404, request.action.id, "connector_not_found", `Connector ${request.connector.id} is not in the Tangle catalog runtime.`);
+    }
+    if (request.connection.connectorId !== connector.id) {
+      return errorResponse(400, request.action.id, "connector_mismatch", "Connection connectorId does not match runtime connector.");
+    }
+    if (request.connection.providerId !== connector.providerId) {
+      return errorResponse(400, request.action.id, "provider_mismatch", "Connection providerId does not match runtime connector.");
+    }
+    const action = connector.actions.find((candidate) => candidate.id === request.action.id);
+    if (!action) {
+      return errorResponse(404, request.action.id, "action_not_found", `Action ${request.action.id} is not defined by connector ${connector.id}.`);
+    }
+    const result = await options.executeAction({
+      request,
+      connection: request.connection,
+      connector,
+      action
+    });
+    return {
+      status: result.ok ? 200 : 502,
+      headers: { "content-type": "application/json" },
+      body: result
+    };
+  };
+}
+function serializeBody(body) {
+  if (typeof body === "string") return body;
+  if (body instanceof Uint8Array) return new TextDecoder().decode(body);
+  return JSON.stringify(body);
+}
+function parseRuntimeRequest(serialized) {
+  try {
+    const request = JSON.parse(serialized);
+    if (request.version !== 1) {
+      return { ok: false, response: errorResponse(400, request.action?.id ?? "unknown", "version_invalid", "Unsupported Tangle catalog runtime request version.") };
+    }
+    if (!request.connection || !request.connector || !request.action?.id) {
+      return { ok: false, response: errorResponse(400, request.action?.id ?? "unknown", "request_invalid", "Tangle catalog runtime request is missing required fields.") };
+    }
+    return { ok: true, request };
+  } catch {
+    return { ok: false, response: errorResponse(400, "unknown", "json_invalid", "Tangle catalog runtime request body is not valid JSON.") };
+  }
+}
+function readHeader(headers, name) {
+  if (!headers) return void 0;
+  if (headers instanceof Headers) return headers.get(name) ?? void 0;
+  const wanted = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== wanted) continue;
+    if (Array.isArray(value)) return value[0];
+    return value;
+  }
+  return void 0;
+}
+function errorResponse(status, action, code, message) {
+  return {
+    status,
+    headers: { "content-type": "application/json" },
+    body: {
+      ok: false,
+      action,
+      output: { code, message }
+    }
+  };
+}
 
 // src/runtime.ts
 var InMemoryIntegrationGrantStore = class {
@@ -6718,6 +6968,8 @@ export {
   ResourceContention,
   StaticIntegrationPolicyEngine,
   TANGLE_CATALOG_RUNTIME_SIGNATURE_HEADER,
+  TANGLE_INTEGRATIONS_CATALOG_PROVIDER_ID,
+  TANGLE_INTEGRATIONS_CATALOG_SOURCE,
   TangleIntegrationsClient,
   _resetPendingFlowsForTests,
   adapterManifestsToConnectors,
@@ -6767,6 +7019,7 @@ export {
   createPlatformIntegrationPolicyPreset,
   createTangleCatalogExecutorProvider,
   createTangleCatalogHttpExecutor,
+  createTangleCatalogRuntimeHandler,
   createTangleIntegrationsClient,
   declarativeRestConnector,
   decodeIntegrationBridgePayload,