@muxoai/platform 1.4.1 → 1.4.2

package/dist/providers/composio-sdk.d.ts

@@ -1,8 +1,8 @@
 import { Composio } from "@composio/core";
 import type { MuxoConfig } from "../config.js";
 import type { MuxoTool, RiskLevel } from "../types.js";
-import { type ComposioToolkitMetadata, type ComposioTriggerEventRecord, type ComposioTriggerSubscription, type ComposioTriggerType } from "../composio-catalog.js";
-export type { ComposioToolkitMetadata, ComposioTriggerEventRecord, ComposioTriggerSubscription };
+import { parseComposioWebhookEnvelope, type ComposioToolkitMetadata, type ComposioTriggerEventRecord, type ComposioTriggerSubscription, type ComposioTriggerType, type ComposioWebhookEventType } from "../composio-catalog.js";
+export type { ComposioToolkitMetadata, ComposioTriggerEventRecord, ComposioTriggerSubscription, ComposioTriggerType, ComposioWebhookEventType, };
 export declare class ComposioSdkAdapter {
     private readonly config;
     private liveToolsCache;
@@ -26,6 +26,17 @@ export declare class ComposioSdkAdapter {
         cachedToolCount: number;
         capabilities: string[];
     };
+    getWebhookConfigInfo(): {
+        webhookUrl: string;
+        legacyWebhookUrl: string;
+        version: "V3";
+        events: ComposioWebhookEventType[];
+        secretConfigured: boolean;
+        subscriptionId: string | null;
+        projectId: string | null;
+        orgId: string | null;
+        userId: string | null;
+    };
     getCuratedTools(): MuxoTool[];
     static classifyActionRisk(upstreamSlug: string, description?: string): RiskLevel;
     listToolkits(params?: {
@@ -55,15 +66,61 @@ export declare class ComposioSdkAdapter {
         source: "composio_v3_sdk" | "muxo_managed";
     }>;
     listTriggerTypes(providerSlug?: string): ComposioTriggerType[];
+    /**
+     * Check what configuration is required for a trigger (`composio.triggers.getType(slug)`).
+     */
+    getTriggerType(triggerSlug: string, composioApiKey?: string | null): Promise<ComposioTriggerType & {
+        source: "composio_v3_sdk" | "muxo_trigger_catalog";
+    }>;
+    /**
+     * Create a trigger with required config (`composio.triggers.create(userId, slug, { triggerConfig })`)
+     * and optionally subscribe to real-time trigger events (`composio.triggers.subscribe`).
+     */
     enableTrigger(params: {
         workspaceId: string;
+        userId?: string;
         triggerSlug: string;
         providerSlug: string;
         connectedAccountId?: string;
         webhookUrl?: string;
         config?: Record<string, unknown>;
+        subscribe?: boolean;
         composioApiKey?: string | null;
     }): Promise<ComposioTriggerSubscription>;
+    /**
+     * Subscribe to real-time trigger events via `@composio/core` (`composio.triggers.subscribe`).
+     */
+    subscribeToTriggerEvents(params: {
+        workspaceId: string;
+        triggerId?: string;
+        toolkits?: string[];
+        onEvent?: (data: Record<string, unknown>) => void;
+        composioApiKey?: string | null;
+    }): Promise<{
+        subscribed: boolean;
+        triggerId?: string;
+    }>;
+    /**
+     * Verify an incoming Composio webhook payload and HMAC-SHA256 signature.
+     */
+    verifyWebhook(params: {
+        rawPayload: string;
+        signatureHeader?: string | null;
+        webhookIdHeader?: string | null;
+        webhookTimestampHeader?: string | null;
+        secret?: string | null;
+        toleranceSeconds?: number;
+    }): Promise<{
+        verified: boolean;
+        reason?: string;
+        envelope: ReturnType<typeof parseComposioWebhookEnvelope>;
+    }>;
+    disableTriggersMatching(params: {
+        workspaceId?: string;
+        triggerId?: string;
+        triggerSlug?: string;
+        connectedAccountId?: string;
+    }): number;
     listActiveTriggers(workspaceId: string): ComposioTriggerSubscription[];
     recordTriggerEvent(record: ComposioTriggerEventRecord): void;
     listTriggerEvents(workspaceId: string, limit?: number): ComposioTriggerEventRecord[];

package/dist/providers/composio-sdk.js

@@ -1,6 +1,6 @@
 import { Composio } from "@composio/core";
 import { matchAppToolSlug } from "../mcp-schema.js";
-import { composioAuthConfigScopes, ENTERPRISE_TOOLKITS_CATALOG, filterComposioToolkits, getSampleActionSchema, listComposioTriggerTypes, } from "../composio-catalog.js";
+import { composioAuthConfigScopes, COMPOSIO_V3_WEBHOOK_EVENTS, ensureOAuthCallbackParams, ENTERPRISE_TOOLKITS_CATALOG, filterComposioToolkits, getComposioTriggerType, getSampleActionSchema, isStripeProjectsExclusiveProvider, listComposioTriggerTypes, parseComposioWebhookEnvelope, verifyComposioWebhookSignature, wrapMuxoConnectUrl, } from "../composio-catalog.js";
 const CURATED_APP_TOOLS = [
     {
         slug: "app.github.list_repos",
@@ -404,13 +404,17 @@ export class ComposioSdkAdapter {
     }
     hydrateEnterpriseSampleActions() {
         for (const tk of ENTERPRISE_TOOLKITS_CATALOG) {
+            if (isStripeProjectsExclusiveProvider(tk.slug))
+                continue;
             for (const act of tk.sampleActions) {
+                if (act.muxoSlug.startsWith("resource."))
+                    continue;
                 if (!this.liveToolsCache.has(act.muxoSlug)) {
                     this.liveToolsCache.set(act.muxoSlug, {
                         slug: act.muxoSlug,
                         upstreamSlug: act.upstreamSlug,
                         name: act.name,
-                        description: `${tk.name}: ${act.name} (Composio v3 toolkit version ${tk.pinnedVersion})`,
+                        description: `${tk.name}: ${act.name} (Muxo Connected Apps toolkit v${tk.pinnedVersion})`,
                         lane: "composio_sdk",
                         providerSlug: tk.slug,
                         providerName: tk.name,
@@ -483,9 +487,26 @@ export class ComposioSdkAdapter {
                 "connectedAccounts.get",
                 "connectedAccounts.list",
                 "authConfigs.list",
+                "triggers.getType",
+                "triggers.create",
+                "triggers.subscribe",
+                "triggers.verifyWebhook",
             ],
         };
     }
+    getWebhookConfigInfo() {
+        return {
+            webhookUrl: "https://api.muxo.ai/webhooks",
+            legacyWebhookUrl: "https://api.muxo.ai/api/v1/triggers/webhook",
+            version: "V3",
+            events: [...COMPOSIO_V3_WEBHOOK_EVENTS],
+            secretConfigured: Boolean(this.config.composioWebhookSecret),
+            subscriptionId: this.config.composioWebhookSubscriptionId || null,
+            projectId: this.config.composioProjectId || null,
+            orgId: this.config.composioOrgId || null,
+            userId: this.config.composioUserId || null,
+        };
+    }
     getCuratedTools() {
         return Array.from(this.liveToolsCache.values());
     }
@@ -563,23 +584,194 @@ export class ComposioSdkAdapter {
     listTriggerTypes(providerSlug) {
         return listComposioTriggerTypes(providerSlug);
     }
+    /**
+     * Check what configuration is required for a trigger (`composio.triggers.getType(slug)`).
+     */
+    async getTriggerType(triggerSlug, composioApiKey) {
+        const normalizedSlug = String(triggerSlug || "GITHUB_COMMIT_EVENT")
+            .toUpperCase()
+            .trim();
+        const fallback = getComposioTriggerType(normalizedSlug);
+        const sdk = this.getComposioClient(composioApiKey);
+        if (sdk) {
+            try {
+                const triggerType = await Promise.race([
+                    sdk.triggers.getType(normalizedSlug),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK triggers.getType timeout")), 4500)),
+                ]);
+                if (triggerType) {
+                    const toolkitSlug = String(triggerType.toolkit?.slug || fallback.providerSlug).toLowerCase();
+                    return {
+                        slug: String(triggerType.slug || normalizedSlug),
+                        providerSlug: toolkitSlug,
+                        name: String(triggerType.name || fallback.name),
+                        description: String(triggerType.description || fallback.description),
+                        config: triggerType.config && typeof triggerType.config === "object"
+                            ? triggerType.config
+                            : fallback.config,
+                        source: "composio_v3_sdk",
+                    };
+                }
+            }
+            catch {
+                // Fall back to Muxo trigger catalog when offline or unconfigured
+            }
+        }
+        return {
+            ...fallback,
+            source: "muxo_trigger_catalog",
+        };
+    }
+    /**
+     * Create a trigger with required config (`composio.triggers.create(userId, slug, { triggerConfig })`)
+     * and optionally subscribe to real-time trigger events (`composio.triggers.subscribe`).
+     */
     async enableTrigger(params) {
-        const id = `trg_${params.providerSlug}_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+        const normalizedTriggerSlug = params.triggerSlug.toUpperCase().trim();
+        const triggerType = await this.getTriggerType(normalizedTriggerSlug, params.composioApiKey);
+        const providerSlug = (params.providerSlug ||
+            triggerType.providerSlug ||
+            "github")
+            .toLowerCase()
+            .trim();
+        const userId = params.userId || this.config.composioUserId || params.workspaceId;
+        const triggerConfig = params.config || {};
+        let upstreamTriggerId;
+        let source = "muxo_managed";
+        const sdk = this.getComposioClient(params.composioApiKey);
+        if (sdk) {
+            try {
+                const created = await Promise.race([
+                    sdk.triggers.create(userId, normalizedTriggerSlug, {
+                        ...(params.connectedAccountId
+                            ? { connectedAccountId: params.connectedAccountId }
+                            : {}),
+                        triggerConfig,
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK triggers.create timeout")), 6000)),
+                ]);
+                if (created?.triggerId) {
+                    upstreamTriggerId = String(created.triggerId);
+                    source = "composio_v3_sdk";
+                    if (params.subscribe) {
+                        await this.subscribeToTriggerEvents({
+                            workspaceId: params.workspaceId,
+                            triggerId: upstreamTriggerId,
+                            composioApiKey: params.composioApiKey,
+                        }).catch(() => { });
+                    }
+                }
+            }
+            catch {
+                // Fall through to deterministic local subscription record
+            }
+        }
+        const id = upstreamTriggerId ||
+            `trg_${providerSlug}_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
         const sub = {
             id,
+            upstreamTriggerId,
             workspaceId: params.workspaceId,
-            triggerSlug: params.triggerSlug.toUpperCase().trim(),
-            providerSlug: params.providerSlug.toLowerCase().trim(),
-            connectedAccountId: params.connectedAccountId || `ca_${params.providerSlug}_${params.workspaceId.slice(0, 8)}`,
+            userId,
+            triggerSlug: normalizedTriggerSlug,
+            providerSlug,
+            connectedAccountId: params.connectedAccountId || `ca_${providerSlug}_${params.workspaceId.slice(0, 8)}`,
             webhookUrl: params.webhookUrl ||
-                `https://api.muxo.ai/api/v1/triggers/webhook`,
-            config: params.config || {},
+                `https://api.muxo.ai/webhooks`,
+            config: triggerConfig,
             status: "active",
+            source,
             createdAt: new Date().toISOString(),
         };
         this.activeTriggers.set(id, sub);
         return sub;
     }
+    /**
+     * Subscribe to real-time trigger events via `@composio/core` (`composio.triggers.subscribe`).
+     */
+    async subscribeToTriggerEvents(params) {
+        const sdk = this.getComposioClient(params.composioApiKey);
+        if (!sdk) {
+            return { subscribed: false, triggerId: params.triggerId };
+        }
+        await sdk.triggers.subscribe((data) => {
+            const recordPayload = (data?.payload || data || {});
+            const triggerSlug = String(data?.triggerSlug || "GITHUB_COMMIT_EVENT").toUpperCase();
+            const providerSlug = String(data?.toolkitSlug || triggerSlug.split("_")[0] || "github").toLowerCase();
+            this.recordTriggerEvent({
+                id: `trgevt_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+                workspaceId: params.workspaceId,
+                eventType: "composio.trigger.message",
+                webhookVersion: "V3",
+                triggerId: data?.id || params.triggerId,
+                triggerSlug,
+                providerSlug,
+                connectedAccountId: data?.metadata?.connectedAccount?.id,
+                userId: data?.userId || data?.metadata?.connectedAccount?.userId,
+                receivedAt: new Date().toISOString(),
+                promptInjectionScan: {
+                    safe: true,
+                    riskScore: 0,
+                    findings: [],
+                },
+                disposition: "dispatched",
+                payloadPreview: recordPayload,
+            });
+            params.onEvent?.(data);
+        }, {
+            ...(params.triggerId ? { triggerId: params.triggerId } : {}),
+            ...(params.toolkits ? { toolkits: params.toolkits } : {}),
+        });
+        return { subscribed: true, triggerId: params.triggerId };
+    }
+    /**
+     * Verify an incoming Composio webhook payload and HMAC-SHA256 signature.
+     */
+    async verifyWebhook(params) {
+        const secret = (params.secret ?? this.config.composioWebhookSecret ?? "").trim();
+        const sigCheck = await verifyComposioWebhookSignature({
+            rawPayload: params.rawPayload,
+            signatureHeader: params.signatureHeader,
+            webhookIdHeader: params.webhookIdHeader,
+            webhookTimestampHeader: params.webhookTimestampHeader,
+            secret,
+            toleranceSeconds: params.toleranceSeconds,
+        });
+        let parsedJson = {};
+        try {
+            parsedJson = JSON.parse(params.rawPayload || "{}");
+        }
+        catch {
+            parsedJson = {};
+        }
+        const envelope = parseComposioWebhookEnvelope(parsedJson, {
+            webhookId: params.webhookIdHeader,
+            webhookTimestamp: params.webhookTimestampHeader,
+        });
+        return {
+            verified: sigCheck.verified,
+            reason: sigCheck.reason,
+            envelope,
+        };
+    }
+    disableTriggersMatching(params) {
+        let count = 0;
+        for (const sub of this.activeTriggers.values()) {
+            if (params.workspaceId && sub.workspaceId !== params.workspaceId)
+                continue;
+            const matchesTriggerId = Boolean(params.triggerId) &&
+                (sub.id === params.triggerId || sub.upstreamTriggerId === params.triggerId);
+            const matchesConnectedAccount = Boolean(params.connectedAccountId) &&
+                sub.connectedAccountId === params.connectedAccountId;
+            const matchesSlug = Boolean(params.triggerSlug) &&
+                sub.triggerSlug.toUpperCase() === params.triggerSlug.toUpperCase();
+            if (matchesTriggerId || matchesConnectedAccount || matchesSlug) {
+                sub.status = "disabled";
+                count += 1;
+            }
+        }
+        return count;
+    }
     listActiveTriggers(workspaceId) {
         return Array.from(this.activeTriggers.values()).filter((t) => t.workspaceId === workspaceId);
     }
@@ -601,6 +793,10 @@ export class ComposioSdkAdapter {
             return null;
         const toolkitObj = (item.toolkit || {});
         const providerSlug = String(toolkitObj.slug || upstreamSlug.split("_")[0] || "app").toLowerCase();
+        // Never surface Stripe Projects cloud infrastructure providers as Composio OAuth tools
+        if (isStripeProjectsExclusiveProvider(providerSlug)) {
+            return null;
+        }
         const providerName = String(toolkitObj.name || providerSlug.charAt(0).toUpperCase() + providerSlug.slice(1));
         const actionPart = upstreamSlug
             .toLowerCase()
@@ -617,7 +813,7 @@ export class ComposioSdkAdapter {
             slug: muxoSlug,
             upstreamSlug,
             name: `${providerName}: ${String(item.name || actionPart)}`,
-            description: String(item.description || `Execute ${upstreamSlug} via Composio`),
+            description: String(item.description || `Execute ${upstreamSlug} via Muxo Connected Apps`),
             lane: "composio_sdk",
             providerSlug,
             providerName,
@@ -634,6 +830,10 @@ export class ComposioSdkAdapter {
     async searchTools(query, limit = 15, composioApiKey, toolkit) {
         const q = (query || "").trim().toLowerCase();
         const tk = (toolkit || "").trim().toLowerCase();
+        // Stripe Projects infrastructure providers belong to stripe_projects lane, not Composio OAuth
+        if (tk && isStripeProjectsExclusiveProvider(tk)) {
+            return [];
+        }
         const localMatches = this.getCuratedTools().filter((t) => {
             if (tk && t.providerSlug.toLowerCase() !== tk)
                 return false;
@@ -716,6 +916,9 @@ export class ComposioSdkAdapter {
         if (!normalizedSlug.startsWith("app.") || !apiKey)
             return null;
         const parts = normalizedSlug.split(".");
+        if (parts.length >= 2 && isStripeProjectsExclusiveProvider(parts[1] || "")) {
+            return null;
+        }
         if (parts.length >= 3) {
             const upstreamCandidate = parts.slice(1).join("_").toUpperCase();
             const sdk = this.getComposioClient(composioApiKey);
@@ -743,8 +946,15 @@ export class ComposioSdkAdapter {
     async startConnection(params) {
         const providerSlug = params.providerSlug.toLowerCase().replace(/^app\./, "");
         const providerName = providerSlug.charAt(0).toUpperCase() + providerSlug.slice(1);
-        const callbackUrl = params.callbackUrl ||
+        const rawCallbackUrl = params.callbackUrl ||
             `${this.config.baseUrl}/oauth/callback?workspace_id=${encodeURIComponent(params.workspaceId)}&provider=${encodeURIComponent(providerSlug)}`;
+        const callbackUrl = ensureOAuthCallbackParams(rawCallbackUrl, params.workspaceId, providerSlug);
+        const wrapRedirect = (url, externalAccountId) => wrapMuxoConnectUrl(url, this.config.baseUrl, {
+            workspaceId: params.workspaceId,
+            providerSlug,
+            callbackUrl,
+            externalAccountId: externalAccountId || null,
+        });
         const apiKey = this.resolveApiKey(params.composioApiKey);
         if (!apiKey) {
             const externalAccountId = `ca_ext_${providerSlug}_${params.workspaceId.slice(-8)}`;
@@ -758,7 +968,52 @@ export class ComposioSdkAdapter {
                 message: `Open the authorization URL to connect ${providerName} to your Muxo workspace.`,
             };
         }
-        // 1. Official @composio/core SDK Tool Router & Connected Accounts initiation
+        // 1. Try creating a Tool Router Session & link for the workspace user (supports expected_input_fields + callback_url)
+        try {
+            const sessionRes = await fetch(`${this.config.composioBaseUrl}/tool_router/session`, {
+                method: "POST",
+                headers: this.getHeaders(params.composioApiKey),
+                body: JSON.stringify({
+                    user_id: params.workspaceId,
+                    toolkits: { enable: [providerSlug] },
+                }),
+                signal: AbortSignal.timeout(8000),
+            });
+            if (sessionRes.ok) {
+                const sessionData = (await sessionRes.json());
+                const sessionId = sessionData.session_id;
+                if (sessionId) {
+                    const linkRes = await fetch(`${this.config.composioBaseUrl}/tool_router/session/${sessionId}/link`, {
+                        method: "POST",
+                        headers: this.getHeaders(params.composioApiKey),
+                        body: JSON.stringify({
+                            toolkit: providerSlug,
+                            callback_url: callbackUrl,
+                        }),
+                        signal: AbortSignal.timeout(8000),
+                    });
+                    if (linkRes.ok) {
+                        const linkData = (await linkRes.json());
+                        if (linkData.redirect_url) {
+                            const extId = linkData.connected_account_id || sessionId;
+                            return {
+                                providerSlug,
+                                providerName,
+                                status: "pending",
+                                redirectUrl: wrapRedirect(linkData.redirect_url, extId),
+                                callbackUrl,
+                                externalAccountId: extId,
+                                message: `Open the authorization URL to connect ${providerName} to your Muxo workspace.`,
+                            };
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Fall through to @composio/core SDK / connected_accounts flow
+        }
+        // 2. Official @composio/core SDK Connected Accounts initiation fallback
         const sdk = this.getComposioClient(params.composioApiKey);
         if (sdk) {
             try {
@@ -776,10 +1031,11 @@ export class ComposioSdkAdapter {
                         new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK initiate timeout")), 6000)),
                     ]);
                     const externalAccountId = connRequest?.id || null;
-                    const redirectUrl = connRequest?.redirectUrl ||
+                    const rawRedirectUrl = connRequest?.redirectUrl ||
                         (externalAccountId
                             ? `${callbackUrl}&connected_account_id=${encodeURIComponent(externalAccountId)}`
                             : null);
+                    const redirectUrl = wrapRedirect(rawRedirectUrl, externalAccountId);
                     if (redirectUrl) {
                         return {
                             providerSlug,
@@ -798,10 +1054,11 @@ export class ComposioSdkAdapter {
                         new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK toolkits.authorize timeout")), 6000)),
                     ]);
                     const externalAccountId = authReq?.id || null;
-                    const redirectUrl = authReq?.redirectUrl ||
+                    const rawRedirectUrl = authReq?.redirectUrl ||
                         (externalAccountId
                             ? `${callbackUrl}&connected_account_id=${encodeURIComponent(externalAccountId)}`
                             : null);
+                    const redirectUrl = wrapRedirect(rawRedirectUrl, externalAccountId);
                     if (redirectUrl) {
                         return {
                             providerSlug,
@@ -816,53 +1073,9 @@ export class ComposioSdkAdapter {
                 }
             }
             catch {
-                // Fall through to Tool Router REST session / v3 API fallback
+                // Fall through to v3 API fallback
             }
         }
-        // 2. Try creating a Composio Tool Router Session & link for the workspace user
-        try {
-            const sessionRes = await fetch(`${this.config.composioBaseUrl}/tool_router/session`, {
-                method: "POST",
-                headers: this.getHeaders(params.composioApiKey),
-                body: JSON.stringify({
-                    user_id: params.workspaceId,
-                    toolkits: { enable: [providerSlug] },
-                }),
-                signal: AbortSignal.timeout(8000),
-            });
-            if (sessionRes.ok) {
-                const sessionData = (await sessionRes.json());
-                const sessionId = sessionData.session_id;
-                if (sessionId) {
-                    const linkRes = await fetch(`${this.config.composioBaseUrl}/tool_router/session/${sessionId}/link`, {
-                        method: "POST",
-                        headers: this.getHeaders(params.composioApiKey),
-                        body: JSON.stringify({
-                            toolkit: providerSlug,
-                            callback_url: callbackUrl,
-                        }),
-                        signal: AbortSignal.timeout(8000),
-                    });
-                    if (linkRes.ok) {
-                        const linkData = (await linkRes.json());
-                        if (linkData.redirect_url) {
-                            return {
-                                providerSlug,
-                                providerName,
-                                status: "pending",
-                                redirectUrl: linkData.redirect_url,
-                                callbackUrl,
-                                externalAccountId: linkData.connected_account_id || sessionId,
-                                message: `Open the authorization URL to connect ${providerName} to your Muxo workspace.`,
-                            };
-                        }
-                    }
-                }
-            }
-        }
-        catch {
-            // Fall through to auth_configs / connected_accounts flow
-        }
         // 3. Fallback: look up or create an auth_config for the toolkit and initiate connected_accounts
         const authCfgRes = await fetch(`${this.config.composioBaseUrl}/auth_configs?toolkit_slug=${encodeURIComponent(providerSlug)}&limit=5`, {
             headers: this.getHeaders(params.composioApiKey),
@@ -887,9 +1100,10 @@ export class ComposioSdkAdapter {
                 if (connRes.ok) {
                     const connData = (await connRes.json());
                     const fallbackRedirect = `${callbackUrl}&connected_account_id=${encodeURIComponent(connData.id || `ca_${providerSlug}`)}`;
-                    const redirectUrl = connData.redirect_url ||
+                    const rawRedirectUrl = connData.redirect_url ||
                         connData.connectionData?.val?.redirectUrl ||
                         fallbackRedirect;
+                    const redirectUrl = wrapRedirect(rawRedirectUrl, connData.id || null);
                     return {
                         providerSlug,
                         providerName,

package/dist/providers/stripe-projects.d.ts

@@ -225,9 +225,13 @@ export declare class StripeProjectsAdapter {
     getTools(): MuxoTool[];
     searchTools(query?: string, limit?: number): MuxoTool[];
     inspectTool(slug: string): MuxoTool | null;
+    hasProvider(providerSlug: string): boolean;
     private runStripeProjectsCli;
     private get hasLocalProjectsWorkdir();
     private provisioningAuditLog;
+    private hostedSites;
+    getHostedSiteHtml(slug: string, filePath?: string): string | null;
+    private attachHostingDeployment;
     getProvisioningAuditLog(limit?: number): StripeProvisioningAuditEntry[];
     private resolveStripeSecretKey;
     isLivemodeKey(apiKeyOverride?: string | null): boolean;