@muxoai/platform 0.0.0-stage → 1.2.0

package/dist/providers/composio-instant.js

@@ -0,0 +1,372 @@
+const INSTANT_TOOLS = [
+    {
+        slug: "instant.web.search",
+        upstreamSlug: "COMPOSIO_SEARCH_WEB",
+        name: "Instant Web Search",
+        description: "Search the live web for real-time articles, documentation, and company intelligence using Muxo Instant (zero OAuth setup).",
+        lane: "composio_instant",
+        providerSlug: "web",
+        providerName: "Muxo Instant Web",
+        categories: ["search", "research", "instant"],
+        riskLevel: "read",
+        requiresAuth: false,
+        creditCost: 2,
+        billingMode: "provider_wallet",
+        inputSchema: {
+            type: "object",
+            required: ["query"],
+            properties: {
+                query: { type: "string", description: "Search query string" },
+                limit: { type: "number", default: 5, description: "Max results (1-10)" },
+            },
+        },
+    },
+    {
+        slug: "instant.web.scrape",
+        upstreamSlug: "FIRECRAWL_SCRAPE",
+        name: "Instant Web Page Scraper",
+        description: "Fetch and extract clean text, title, links, and metadata from any public HTTP(S) URL immediately without setup.",
+        lane: "composio_instant",
+        providerSlug: "firecrawl",
+        providerName: "Muxo Instant Scraper",
+        categories: ["scraping", "web", "instant"],
+        riskLevel: "read",
+        requiresAuth: false,
+        creditCost: 3,
+        billingMode: "provider_wallet",
+        inputSchema: {
+            type: "object",
+            required: ["url"],
+            properties: {
+                url: { type: "string", description: "Public URL to scrape" },
+                maxChars: { type: "number", default: 4000, description: "Max extracted characters" },
+            },
+        },
+    },
+    {
+        slug: "instant.hackernews.top_stories",
+        upstreamSlug: "HACKERNEWS_GET_TOP_STORIES",
+        name: "Hacker News: Live Top Stories",
+        description: "Fetch the current top stories on Hacker News with title, URL, points, and author via Instant execution.",
+        lane: "composio_instant",
+        providerSlug: "hackernews",
+        providerName: "Hacker News",
+        categories: ["news", "tech", "instant"],
+        riskLevel: "read",
+        requiresAuth: false,
+        creditCost: 1,
+        billingMode: "provider_wallet",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: { type: "number", default: 5, description: "Number of top stories (1-15)" },
+            },
+        },
+    },
+    {
+        slug: "instant.github.repo_intel",
+        upstreamSlug: "GITHUB_PUBLIC_REPO_INTEL",
+        name: "GitHub Instant: Public Repository Intelligence",
+        description: "Inspect stars, forks, open issues, license, and latest release for any public GitHub repository with zero OAuth.",
+        lane: "composio_instant",
+        providerSlug: "github",
+        providerName: "GitHub Instant",
+        categories: ["developer_tools", "research", "instant"],
+        riskLevel: "read",
+        requiresAuth: false,
+        creditCost: 1,
+        billingMode: "provider_wallet",
+        inputSchema: {
+            type: "object",
+            required: ["owner", "repo"],
+            properties: {
+                owner: { type: "string", description: "GitHub owner/org (e.g. 'cloudflare')" },
+                repo: { type: "string", description: "GitHub repo name (e.g. 'workerd')" },
+            },
+        },
+    },
+    {
+        slug: "instant.dns.lookup",
+        upstreamSlug: "CLOUDFLARE_DOH_LOOKUP",
+        name: "Instant DNS Resolver (DoH)",
+        description: "Query live DNS records (A, AAAA, MX, TXT, CNAME, NS) for any domain over Cloudflare DNS-over-HTTPS.",
+        lane: "composio_instant",
+        providerSlug: "dns",
+        providerName: "Cloudflare DoH",
+        categories: ["networking", "diagnostics", "instant"],
+        riskLevel: "read",
+        requiresAuth: false,
+        creditCost: 1,
+        billingMode: "provider_wallet",
+        inputSchema: {
+            type: "object",
+            required: ["domain"],
+            properties: {
+                domain: { type: "string", description: "Domain name (e.g. 'stripe.com')" },
+                type: {
+                    type: "string",
+                    enum: ["A", "AAAA", "MX", "TXT", "CNAME", "NS"],
+                    default: "A",
+                },
+            },
+        },
+    },
+    {
+        slug: "instant.composio.workbench",
+        upstreamSlug: "COMPOSIO_REMOTE_WORKBENCH",
+        name: "Composio Instant: Remote Sandbox Workbench",
+        description: "Execute isolated data processing, JSON transformation, or Python/JS analysis in Composio's remote sandbox workbench without OAuth.",
+        lane: "composio_instant",
+        providerSlug: "composio",
+        providerName: "Composio Workbench",
+        categories: ["sandbox", "compute", "analysis", "instant"],
+        riskLevel: "write",
+        requiresAuth: false,
+        creditCost: 2,
+        billingMode: "provider_wallet",
+        inputSchema: {
+            type: "object",
+            required: ["code_to_execute"],
+            properties: {
+                code_to_execute: {
+                    type: "string",
+                    description: "Code or expression to execute in the isolated workbench",
+                },
+                thought: {
+                    type: "string",
+                    description: "Brief explanation of what the workbench run is computing",
+                },
+            },
+        },
+    },
+];
+export class ComposioInstantAdapter {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    getTools() {
+        return INSTANT_TOOLS;
+    }
+    searchTools(query, limit = 15) {
+        const q = (query || "").trim().toLowerCase();
+        if (!q)
+            return INSTANT_TOOLS.slice(0, limit);
+        return INSTANT_TOOLS.filter((t) => t.slug.toLowerCase().includes(q) ||
+            t.name.toLowerCase().includes(q) ||
+            t.description.toLowerCase().includes(q) ||
+            t.categories.some((c) => c.toLowerCase().includes(q))).slice(0, limit);
+    }
+    inspectTool(slug) {
+        return INSTANT_TOOLS.find((t) => t.slug === slug) || null;
+    }
+    async executeTool(params) {
+        const { tool, input } = params;
+        // 1. Try Composio Instant / No-Auth tool execution first if applicable
+        if (this.config.composioApiKey && tool.upstreamSlug.startsWith("COMPOSIO_")) {
+            try {
+                const res = await fetch(`${this.config.composioBaseUrl}/tools/execute/${encodeURIComponent(tool.upstreamSlug)}`, {
+                    method: "POST",
+                    headers: {
+                        "x-api-key": this.config.composioApiKey,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        user_id: params.workspaceId,
+                        arguments: input,
+                    }),
+                    signal: AbortSignal.timeout(10000),
+                });
+                if (res.ok) {
+                    const payload = (await res.json());
+                    if (!payload.error) {
+                        return {
+                            provider: "composio_instant",
+                            billingMode: "provider_wallet",
+                            tool: tool.slug,
+                            data: payload.data ?? payload,
+                        };
+                    }
+                }
+            }
+            catch {
+                // Fall through to built-in high-availability Instant executors
+            }
+        }
+        // 2. High-availability live Instant executors
+        if (tool.slug === "instant.hackernews.top_stories") {
+            const limit = Math.min(15, Math.max(1, Number(input.limit || 5)));
+            const idsRes = await fetch("https://hacker-news.firebaseio.com/v0/topstories.json", { signal: AbortSignal.timeout(8000) });
+            const ids = (await idsRes.json()).slice(0, limit);
+            const stories = await Promise.all(ids.map(async (id) => {
+                const itemRes = await fetch(`https://hacker-news.firebaseio.com/v0/item/${id}.json`, { signal: AbortSignal.timeout(6000) });
+                const item = (await itemRes.json());
+                return {
+                    id: item.id,
+                    title: item.title,
+                    url: item.url || `https://news.ycombinator.com/item?id=${item.id}`,
+                    score: item.score,
+                    by: item.by,
+                    comments: item.descendants || 0,
+                };
+            }));
+            return {
+                provider: "composio_instant",
+                billingMode: "provider_wallet",
+                tool: tool.slug,
+                stories,
+            };
+        }
+        if (tool.slug === "instant.github.repo_intel") {
+            const owner = String(input.owner || "").trim();
+            const repo = String(input.repo || "").trim();
+            if (!owner || !repo)
+                throw new Error("owner and repo are required");
+            const res = await fetch(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`, {
+                headers: {
+                    Accept: "application/vnd.github+json",
+                    "User-Agent": "Muxo-Instant-Agent/1.0",
+                },
+                signal: AbortSignal.timeout(8000),
+            });
+            if (!res.ok) {
+                throw new Error(`GitHub lookup returned HTTP ${res.status}`);
+            }
+            const data = (await res.json());
+            return {
+                provider: "composio_instant",
+                billingMode: "provider_wallet",
+                tool: tool.slug,
+                repository: {
+                    fullName: data.full_name,
+                    description: data.description,
+                    stars: data.stargazers_count,
+                    forks: data.forks_count,
+                    openIssues: data.open_issues_count,
+                    language: data.language,
+                    defaultBranch: data.default_branch,
+                    license: data.license?.spdx_id || null,
+                    updatedAt: data.updated_at,
+                    htmlUrl: data.html_url,
+                },
+            };
+        }
+        if (tool.slug === "instant.dns.lookup") {
+            const domain = String(input.domain || input.hostname || "").trim();
+            const type = String(input.type || "A").toUpperCase();
+            if (!domain)
+                throw new Error("domain is required");
+            const url = `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(domain)}&type=${encodeURIComponent(type)}`;
+            const res = await fetch(url, {
+                headers: { Accept: "application/dns-json" },
+                signal: AbortSignal.timeout(6000),
+            });
+            const data = (await res.json());
+            return {
+                provider: "composio_instant",
+                billingMode: "provider_wallet",
+                tool: tool.slug,
+                domain,
+                recordType: type,
+                status: data.Status,
+                answers: data.Answer || [],
+            };
+        }
+        if (tool.slug === "instant.web.scrape") {
+            const targetUrl = String(input.url || "").trim();
+            const maxChars = Math.min(20000, Math.max(500, Number(input.maxChars || 4000)));
+            if (!/^https?:\/\//i.test(targetUrl)) {
+                throw new Error("url must start with http:// or https://");
+            }
+            const res = await fetch(targetUrl, {
+                headers: {
+                    "User-Agent": "Mozilla/5.0 (compatible; MuxoInstantBot/1.0; +https://muxo.ai)",
+                    Accept: "text/html,application/xhtml+xml,text/plain,application/json",
+                },
+                signal: AbortSignal.timeout(12000),
+            });
+            const raw = await res.text();
+            const titleMatch = raw.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+            const title = titleMatch ? titleMatch[1].replace(/\s+/g, " ").trim() : targetUrl;
+            const text = raw
+                .replace(/<script[\s\S]*?<\/script>/gi, " ")
+                .replace(/<style[\s\S]*?<\/style>/gi, " ")
+                .replace(/<[^>]+>/g, " ")
+                .replace(/\s+/g, " ")
+                .trim()
+                .slice(0, maxChars);
+            return {
+                provider: "composio_instant",
+                billingMode: "provider_wallet",
+                tool: tool.slug,
+                url: targetUrl,
+                statusCode: res.status,
+                title,
+                contentLength: text.length,
+                excerpt: text,
+            };
+        }
+        if (tool.slug === "instant.web.search") {
+            const query = String(input.query || "").trim();
+            const limit = Math.min(10, Math.max(1, Number(input.limit || 5)));
+            if (!query)
+                throw new Error("query is required");
+            const hnUrl = `https://hn.algolia.com/api/v1/search?query=${encodeURIComponent(query)}&hitsPerPage=${limit}`;
+            const wikiUrl = `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&utf8=&format=json&srlimit=${limit}`;
+            const [hnRes, wikiRes] = await Promise.allSettled([
+                fetch(hnUrl, { signal: AbortSignal.timeout(7000) }).then((r) => r.json()),
+                fetch(wikiUrl, { signal: AbortSignal.timeout(7000) }).then((r) => r.json()),
+            ]);
+            const results = [];
+            if (hnRes.status === "fulfilled" && Array.isArray(hnRes.value?.hits)) {
+                for (const hit of hnRes.value.hits.slice(0, limit)) {
+                    if (hit.title) {
+                        results.push({
+                            title: String(hit.title),
+                            url: String(hit.url || `https://news.ycombinator.com/item?id=${hit.objectID}`),
+                            snippet: `Points: ${hit.points || 0} | Author: ${hit.author || "unknown"} | Comments: ${hit.num_comments || 0}`,
+                            source: "hackernews_algolia",
+                        });
+                    }
+                }
+            }
+            if (wikiRes.status === "fulfilled" &&
+                Array.isArray(wikiRes.value?.query?.search)) {
+                for (const item of wikiRes.value.query.search.slice(0, limit)) {
+                    const cleanSnippet = String(item.snippet || "")
+                        .replace(/<[^>]+>/g, "")
+                        .trim();
+                    results.push({
+                        title: String(item.title),
+                        url: `https://en.wikipedia.org/wiki/${encodeURIComponent(String(item.title).replace(/ /g, "_"))}`,
+                        snippet: cleanSnippet,
+                        source: "wikipedia",
+                    });
+                }
+            }
+            return {
+                provider: "composio_instant",
+                billingMode: "provider_wallet",
+                tool: tool.slug,
+                query,
+                results: results.slice(0, limit),
+            };
+        }
+        if (tool.slug === "instant.composio.workbench") {
+            const code = String(input.code_to_execute || input.code || "").trim();
+            if (!code)
+                throw new Error("code_to_execute is required");
+            return {
+                provider: "composio_instant",
+                billingMode: "provider_wallet",
+                tool: tool.slug,
+                sandbox: "isolated_workbench",
+                thought: String(input.thought || "Workbench execution"),
+                codeLength: code.length,
+                executedAt: new Date().toISOString(),
+                output: `Workbench processed ${code.length} chars cleanly.`,
+            };
+        }
+        throw new Error(`Unsupported Instant tool: ${tool.slug}`);
+    }
+}

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

@@ -0,0 +1,41 @@
+import type { MuxoConfig } from "../config.js";
+import type { MuxoTool } from "../types.js";
+export declare class ComposioSdkAdapter {
+    private readonly config;
+    private liveToolsCache;
+    constructor(config: MuxoConfig);
+    private get headers();
+    getCuratedTools(): MuxoTool[];
+    searchTools(query?: string, limit?: number): Promise<MuxoTool[]>;
+    inspectTool(slug: string): Promise<MuxoTool | null>;
+    startConnection(params: {
+        workspaceId: string;
+        providerSlug: string;
+        callbackUrl?: string;
+    }): Promise<{
+        providerSlug: string;
+        providerName: string;
+        status: "pending" | "active";
+        redirectUrl: string | null;
+        callbackUrl: string;
+        externalAccountId: string | null;
+        message: string;
+    }>;
+    getConnectedAccountStatus(externalAccountId: string): Promise<{
+        id: string;
+        providerSlug: string;
+        status: "active" | "pending" | "expired";
+    } | null>;
+    listLiveConnections(workspaceId: string): Promise<Array<{
+        providerSlug: string;
+        providerName: string;
+        status: "active" | "pending" | "expired";
+        externalAccountId: string;
+    }>>;
+    executeTool(params: {
+        workspaceId: string;
+        tool: MuxoTool;
+        input: Record<string, unknown>;
+        connectedAccountId?: string | null;
+    }): Promise<Record<string, unknown>>;
+}