@tangle-network/agent-integrations 0.13.0 → 0.14.0

package/dist/index.js

@@ -128,21 +128,24 @@ function buildActivepiecesConnectors(options = {}) {
     const override = getActivepiecesOverride(entry.id);
     const category = override?.category ?? entry.category;
     const scopes = [`${entry.id}.read`, `${entry.id}.write`];
-    const actions = entry.actions.length > 0 ? entry.actions.map((action) => toAction(applyActionOverride(action, override), scopes, dataClassFor(category))) : defaultActions(entry.id, scopes, dataClassFor(category));
+    const catalogActions = entry.actions.length > 0 ? entry.actions.map((action) => toAction(applyActionOverride(action, override), scopes, dataClassFor(category))) : defaultActions(entry.id, scopes, dataClassFor(category));
+    const catalogTriggers = entry.triggers.map((trigger) => toTrigger(trigger, scopes, dataClassFor(category)));
     return {
       id: entry.id,
       providerId,
       title: entry.title,
       category,
       auth: entry.auth,
-      scopes,
-      actions,
-      triggers: entry.triggers.map((trigger) => toTrigger(trigger, scopes, dataClassFor(category))),
+      scopes: options.includeCatalogActions ? scopes : [],
+      actions: options.includeCatalogActions ? catalogActions : [],
+      triggers: options.includeCatalogActions ? catalogTriggers : void 0,
       metadata: {
         source: "activepieces-community",
         executable: false,
         runtime: "activepieces-piece",
         catalogOnly: true,
+        catalogActionCount: catalogActions.length,
+        catalogTriggerCount: catalogTriggers.length,
         npmPackage: entry.npmPackage,
         version: entry.version,
         license: entry.source.license,
@@ -490,15 +493,15 @@ function actionPack(pack, scopes) {
 }
 function triggersFor(pack, scopes) {
   const readScope = scopes.find((scope) => scope.endsWith(".read")) ?? scopes[0];
-  const requiredScopes = readScope ? [readScope] : [];
-  if (pack === "email") return [{ id: "message.received", title: "Message received", requiredScopes, dataClass: "private" }];
-  if (pack === "calendar") return [{ id: "event.changed", title: "Event changed", requiredScopes, dataClass: "private" }];
-  if (pack === "chat") return [{ id: "message.posted", title: "Message posted", requiredScopes, dataClass: "private" }];
-  if (pack === "crm") return [{ id: "record.changed", title: "Record changed", requiredScopes, dataClass: "private" }];
-  if (pack === "support") return [{ id: "ticket.changed", title: "Ticket changed", requiredScopes, dataClass: "private" }];
-  if (pack === "commerce") return [{ id: "order.changed", title: "Order changed", requiredScopes, dataClass: "sensitive" }];
-  if (pack === "finance") return [{ id: "transaction.changed", title: "Transaction changed", requiredScopes, dataClass: "sensitive" }];
-  if (pack === "workflow" || pack === "webhook") return [{ id: "event.received", title: "Event received", requiredScopes, dataClass: "internal" }];
+  const requiredScopes2 = readScope ? [readScope] : [];
+  if (pack === "email") return [{ id: "message.received", title: "Message received", requiredScopes: requiredScopes2, dataClass: "private" }];
+  if (pack === "calendar") return [{ id: "event.changed", title: "Event changed", requiredScopes: requiredScopes2, dataClass: "private" }];
+  if (pack === "chat") return [{ id: "message.posted", title: "Message posted", requiredScopes: requiredScopes2, dataClass: "private" }];
+  if (pack === "crm") return [{ id: "record.changed", title: "Record changed", requiredScopes: requiredScopes2, dataClass: "private" }];
+  if (pack === "support") return [{ id: "ticket.changed", title: "Ticket changed", requiredScopes: requiredScopes2, dataClass: "private" }];
+  if (pack === "commerce") return [{ id: "order.changed", title: "Order changed", requiredScopes: requiredScopes2, dataClass: "sensitive" }];
+  if (pack === "finance") return [{ id: "transaction.changed", title: "Transaction changed", requiredScopes: requiredScopes2, dataClass: "sensitive" }];
+  if (pack === "workflow" || pack === "webhook") return [{ id: "event.received", title: "Event received", requiredScopes: requiredScopes2, dataClass: "internal" }];
   return void 0;
 }
 function scopesFor(id, pack) {
@@ -1175,6 +1178,8 @@ 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 (connector.actions.length > 0) return "gatewayExecutable";
   return "catalogOnly";
 }
 function registryEntry(canonicalId, candidates, precedence, aliases) {
@@ -1221,7 +1226,7 @@ function registryEntry(canonicalId, candidates, precedence, aliases) {
           sources,
           conflicts,
           toolBindable: actions.length > 0,
-          catalogOnlyActionCount: ordered.filter((candidate) => candidate.supportTier === "catalogOnly").reduce((sum, candidate) => sum + candidate.connector.actions.length, 0)
+          catalogOnlyActionCount: ordered.filter((candidate) => candidate.supportTier === "catalogOnly").reduce((sum, candidate) => sum + catalogActionCount(candidate.connector), 0)
         }
       }
     }
@@ -1252,6 +1257,10 @@ function toolBindableCandidates(candidates) {
   const bindable = candidates.filter((candidate) => candidate.supportTier !== "catalogOnly");
   return bindable.length > 0 ? bindable : [];
 }
+function catalogActionCount(connector) {
+  const value = connector.metadata?.catalogActionCount;
+  return typeof value === "number" ? value : connector.actions.length;
+}
 function conflictDiagnostics(candidates) {
   return [
     conflictFor("auth", candidates.map((candidate) => ({
@@ -5244,6 +5253,295 @@ function unique4(values) {
   return [...new Set(values)];
 }
 
+// src/runtime.ts
+var InMemoryIntegrationGrantStore = class {
+  grants = /* @__PURE__ */ new Map();
+  get(grantId) {
+    return this.grants.get(grantId);
+  }
+  put(grant) {
+    this.grants.set(grant.id, grant);
+  }
+  listByManifest(manifestId, grantee) {
+    return [...this.grants.values()].filter(
+      (grant) => grant.manifestId === manifestId && (!grantee || sameActor(grant.grantee, grantee))
+    );
+  }
+  listByGrantee(grantee) {
+    return [...this.grants.values()].filter((grant) => sameActor(grant.grantee, grantee));
+  }
+  delete(grantId) {
+    this.grants.delete(grantId);
+  }
+};
+var IntegrationRuntime = class {
+  hub;
+  grants;
+  now;
+  constructor(options) {
+    this.hub = options.hub;
+    this.grants = options.grants ?? new InMemoryIntegrationGrantStore();
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  async registry() {
+    return this.hub.listRegistry();
+  }
+  async resolveManifest(manifest, owner) {
+    const registry = await this.registry();
+    const connections = await this.hub.listConnections(owner);
+    const resolutions = manifest.requirements.map(
+      (requirement) => resolveRequirement(requirement, owner, registry, connections)
+    );
+    return {
+      manifest,
+      owner,
+      ready: resolutions.filter((resolution) => resolution.status === "ready"),
+      missing: resolutions.filter((resolution) => resolution.status !== "ready" && !resolution.requirement.optional),
+      optionalMissing: resolutions.filter((resolution) => resolution.status !== "ready" && resolution.requirement.optional === true)
+    };
+  }
+  async createGrants(input) {
+    const resolution = await this.resolveManifest(input.manifest, input.owner);
+    if (resolution.missing.length > 0) {
+      throw new Error(`Cannot create integration grants; missing requirements: ${resolution.missing.map((r) => r.requirement.id).join(", ")}`);
+    }
+    const now = this.now().toISOString();
+    const grants = resolution.ready.map((ready) => ({
+      id: `grant_${input.manifest.id}_${ready.requirement.id}_${ready.connection.id}`,
+      manifestId: input.manifest.id,
+      requirementId: ready.requirement.id,
+      owner: input.owner,
+      grantee: input.grantee,
+      connectionId: ready.connection.id,
+      connectorId: ready.connector.id,
+      scopes: requiredScopes(ready.requirement, ready.connector),
+      allowedActions: requiredActions(ready.requirement, ready.connector),
+      allowedTriggers: requiredTriggers(ready.requirement, ready.connector),
+      status: "active",
+      createdAt: now,
+      updatedAt: now,
+      metadata: input.metadata
+    }));
+    for (const grant of grants) await this.grants.put(grant);
+    return grants;
+  }
+  async buildSandboxBundle(input) {
+    const grants = (await this.grants.listByManifest(input.manifestId, input.grantee)).filter((grant) => grant.status === "active");
+    const registry = await this.registry();
+    const bindings = [];
+    const connectors = [];
+    let expiresAt = "";
+    for (const grant of grants) {
+      const entry = registry.byId.get(grant.connectorId);
+      if (!entry) continue;
+      const connector = {
+        ...entry.connector,
+        actions: entry.connector.actions.filter((action) => grant.allowedActions.includes(action.id)),
+        triggers: entry.connector.triggers?.filter((trigger) => grant.allowedTriggers.includes(trigger.id)),
+        scopes: entry.connector.scopes.filter((scope) => grant.scopes.includes(scope))
+      };
+      const capability = await this.hub.issueCapability({
+        subject: input.subject,
+        connectionId: grant.connectionId,
+        scopes: grant.scopes,
+        allowedActions: grant.allowedActions,
+        ttlMs: input.ttlMs,
+        metadata: {
+          manifestId: grant.manifestId,
+          grantId: grant.id,
+          requirementId: grant.requirementId
+        }
+      });
+      bindings.push({
+        requirementId: grant.requirementId,
+        connectorId: grant.connectorId,
+        connectionId: grant.connectionId,
+        grantId: grant.id,
+        scopes: grant.scopes,
+        allowedActions: grant.allowedActions,
+        allowedTriggers: grant.allowedTriggers,
+        capability
+      });
+      connectors.push(connector);
+      expiresAt = capability.capability.expiresAt;
+    }
+    return {
+      manifestId: input.manifestId,
+      subject: input.subject,
+      capabilities: bindings,
+      connectors,
+      tools: buildIntegrationToolCatalog(connectors),
+      expiresAt
+    };
+  }
+};
+function createIntegrationRuntime(options) {
+  return new IntegrationRuntime(options);
+}
+function resolveRequirement(requirement, owner, registry, connections) {
+  const entry = registry.byId.get(requirement.connectorId);
+  if (!entry) {
+    return missing(requirement, "unknown_connector", `Unknown connector ${requirement.connectorId}.`);
+  }
+  const connector = entry.connector;
+  if (connector.actions.length === 0 && (connector.triggers?.length ?? 0) === 0) {
+    return missing(requirement, "not_executable", `${connector.title} is catalog-only and cannot be invoked yet.`, connector, entry);
+  }
+  const scopes = requiredScopes(requirement, connector);
+  const actions = requiredActions(requirement, connector);
+  const triggers = requiredTriggers(requirement, connector);
+  const connection = connections.find(
+    (candidate) => sameActor(candidate.owner, owner) && candidate.status === "active" && (candidate.connectorId === connector.id || entry.aliases.includes(candidate.connectorId)) && scopes.every((scope) => candidate.grantedScopes.includes(scope))
+  );
+  if (!connection) {
+    return {
+      requirement,
+      status: "missing_connection",
+      connector,
+      registryEntry: entry,
+      missingScopes: scopes,
+      missingActions: actions,
+      missingTriggers: triggers,
+      message: `${connector.title} needs an active user connection with the required scopes.`
+    };
+  }
+  return {
+    requirement,
+    status: "ready",
+    connector,
+    registryEntry: entry,
+    connection,
+    missingScopes: [],
+    missingActions: [],
+    missingTriggers: [],
+    message: `${connector.title} is ready.`
+  };
+}
+function missing(requirement, status, message, connector, registryEntry2) {
+  return {
+    requirement,
+    status,
+    connector,
+    registryEntry: registryEntry2,
+    missingScopes: [],
+    missingActions: [],
+    missingTriggers: [],
+    message
+  };
+}
+function requiredActions(requirement, connector) {
+  if (requirement.mode === "trigger") return [];
+  if (requirement.requiredActions?.length) return unique5(requirement.requiredActions);
+  const actions = connector.actions.filter((action) => {
+    if (requirement.mode === "read") return action.risk === "read";
+    if (requirement.mode === "write") return action.risk !== "read";
+    return false;
+  });
+  return unique5(actions.map((action) => action.id));
+}
+function requiredTriggers(requirement, connector) {
+  if (requirement.requiredTriggers?.length) return unique5(requirement.requiredTriggers);
+  if (requirement.mode !== "trigger") return [];
+  return unique5((connector.triggers ?? []).map((trigger) => trigger.id));
+}
+function requiredScopes(requirement, connector) {
+  if (requirement.requiredScopes?.length) return unique5(requirement.requiredScopes);
+  const actionIds = new Set(requiredActions(requirement, connector));
+  const triggerIds = new Set(requiredTriggers(requirement, connector));
+  return unique5([
+    ...connector.actions.filter((action) => actionIds.has(action.id)).flatMap((action) => action.requiredScopes),
+    ...(connector.triggers ?? []).filter((trigger) => triggerIds.has(trigger.id)).flatMap((trigger) => trigger.requiredScopes)
+  ]);
+}
+function sameActor(a, b) {
+  return a.type === b.type && a.id === b.id;
+}
+function unique5(values) {
+  return [...new Set(values)];
+}
+
+// src/workflow.ts
+var InMemoryIntegrationWorkflowStore = class {
+  workflows = /* @__PURE__ */ new Map();
+  put(workflow) {
+    this.workflows.set(workflow.id, workflow);
+  }
+  get(id) {
+    return this.workflows.get(id);
+  }
+  list() {
+    return [...this.workflows.values()];
+  }
+  listByWorkflow(workflowId) {
+    return [...this.workflows.values()].filter((workflow) => workflow.workflowId === workflowId);
+  }
+  listByOwner(owner) {
+    return [...this.workflows.values()].filter((workflow) => sameActor2(workflow.owner, owner));
+  }
+};
+var IntegrationWorkflowRuntime = class {
+  runtime;
+  hub;
+  grants;
+  store;
+  now;
+  constructor(options) {
+    this.runtime = options.runtime;
+    this.hub = options.hub;
+    this.grants = options.grants;
+    this.store = options.store ?? new InMemoryIntegrationWorkflowStore();
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  async install(input) {
+    const grants = await this.runtime.createGrants({
+      manifest: input.workflow.manifest,
+      owner: input.owner,
+      grantee: input.grantee,
+      metadata: { workflowId: input.workflow.id }
+    });
+    const triggerGrant = findTriggerGrant(grants, input.workflow.trigger.requirementId, input.workflow.trigger.triggerId);
+    const subscription = await this.hub.subscribeTrigger(
+      triggerGrant.connectionId,
+      input.workflow.trigger.triggerId,
+      input.workflow.trigger.targetUrl
+    );
+    const installed = {
+      id: `workflow_${input.workflow.id}_${triggerGrant.id}`,
+      workflowId: input.workflow.id,
+      manifestId: input.workflow.manifest.id,
+      owner: input.owner,
+      grantee: input.grantee,
+      triggerGrantId: triggerGrant.id,
+      subscription,
+      status: "active",
+      createdAt: this.now().toISOString(),
+      metadata: input.workflow.metadata
+    };
+    await this.store.put(installed);
+    return installed;
+  }
+  async dispatchEvent(event, handler) {
+    const workflows = (await this.store.list()).filter(
+      (workflow) => workflow.status === "active" && workflow.subscription.connectionId === event.connectionId && workflow.subscription.trigger === event.trigger
+    );
+    await handler({ event, workflows });
+    return { matched: workflows };
+  }
+};
+function createIntegrationWorkflowRuntime(options) {
+  return new IntegrationWorkflowRuntime(options);
+}
+function findTriggerGrant(grants, requirementId, triggerId) {
+  const grant = grants.find(
+    (candidate) => candidate.requirementId === requirementId && candidate.allowedTriggers.includes(triggerId)
+  );
+  if (!grant) throw new Error(`Missing trigger grant ${requirementId}/${triggerId}.`);
+  return grant;
+}
+function sameActor2(a, b) {
+  return a.type === b.type && a.id === b.id;
+}
+
 // src/specs/types.ts
 function specAuthToConnectorAuth(auth) {
   if (auth.mode === "api_key") return "api_key";
@@ -5433,6 +5731,9 @@ var IntegrationHub = class {
     await this.store.put(connection);
     return connection;
   }
+  async listConnections(owner) {
+    return this.store.listByOwner(owner);
+  }
   async issueCapability(request) {
     const connection = await this.requireConnection(request.connectionId);
     this.assertConnectionActive(connection);
@@ -5442,8 +5743,8 @@ var IntegrationHub = class {
       id: `cap_${randomUUID2()}`,
       subject: request.subject,
       connectionId: request.connectionId,
-      scopes: unique5(request.scopes),
-      allowedActions: unique5(request.allowedActions),
+      scopes: unique6(request.scopes),
+      allowedActions: unique6(request.allowedActions),
       issuedAt: now.toISOString(),
       expiresAt: new Date(now.getTime() + request.ttlMs).toISOString(),
       metadata: request.metadata
@@ -5671,9 +5972,9 @@ async function postJson(fetcher, url, body, bearer) {
   if (!response.ok) throw new IntegrationError(`Integration provider returned HTTP ${response.status}.`, "provider_not_found");
   return response.json();
 }
-function assertScopes(connection, requiredScopes) {
-  const missing = requiredScopes.filter((scope) => !connection.grantedScopes.includes(scope));
-  if (missing.length > 0) throw new IntegrationError(`Missing integration scopes: ${missing.join(", ")}`, "scope_denied");
+function assertScopes(connection, requiredScopes2) {
+  const missing2 = requiredScopes2.filter((scope) => !connection.grantedScopes.includes(scope));
+  if (missing2.length > 0) throw new IntegrationError(`Missing integration scopes: ${missing2.join(", ")}`, "scope_denied");
 }
 function hmac(payload, secret) {
   return createHmac3("sha256", secret).update(payload).digest("base64url");
@@ -5689,7 +5990,7 @@ function base64UrlEncode(value) {
 function base64UrlDecode(value) {
   return Buffer.from(value, "base64url").toString("utf8");
 }
-function unique5(values) {
+function unique6(values) {
   return [...new Set(values)];
 }
 export {
@@ -5698,9 +5999,13 @@ export {
   DEFAULT_SIGNATURE_TOLERANCE_SECONDS,
   INTEGRATION_FAMILIES,
   InMemoryConnectionStore,
+  InMemoryIntegrationGrantStore,
+  InMemoryIntegrationWorkflowStore,
   InMemoryOAuthFlowStore,
   IntegrationError,
   IntegrationHub,
+  IntegrationRuntime,
+  IntegrationWorkflowRuntime,
   ResourceContention,
   StaticIntegrationPolicyEngine,
   _resetPendingFlowsForTests,
@@ -5723,6 +6028,8 @@ export {
   createDefaultIntegrationPolicyEngine,
   createGatewayCatalogProvider,
   createHttpIntegrationProvider,
+  createIntegrationRuntime,
+  createIntegrationWorkflowRuntime,
   createMockIntegrationProvider,
   declarativeRestConnector,
   exchangeAuthorizationCode,