@muxoai/platform 0.0.0-stage → 1.2.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { getConfig, ROOT_DIR, type MuxoConfig } from "./config.js";
+export { MuxoEngine, type ExecutionContext } from "./engine.js";
+export { handleJsonRpcMcpRequest, MUXO_MCP_TOOLS, type McpToolDefinition } from "./mcp.js";
+export { MuxoClient, type MuxoClientOptions } from "./sdk.js";
+export { createMuxoServer } from "./server.js";
+export { MuxoStore } from "./store.js";
+export * from "./types.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { getConfig, ROOT_DIR } from "./config.js";
+export { MuxoEngine } from "./engine.js";
+export { handleJsonRpcMcpRequest, MUXO_MCP_TOOLS } from "./mcp.js";
+export { MuxoClient } from "./sdk.js";
+export { createMuxoServer } from "./server.js";
+export { MuxoStore } from "./store.js";
+export * from "./types.js";

package/dist/mcp.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutionContext, MuxoEngine } from "./engine.js";
+export interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export declare const MUXO_MCP_TOOLS: McpToolDefinition[];
+export declare function dispatchMcpToolCall(engine: MuxoEngine, ctx: ExecutionContext, toolName: string, args?: Record<string, unknown>): Promise<unknown>;
+export declare function handleJsonRpcMcpRequest(engine: MuxoEngine, ctx: ExecutionContext, rpc: Record<string, unknown>): Promise<Record<string, unknown> | null>;

package/dist/mcp.js

@@ -0,0 +1,401 @@
+export const MUXO_MCP_TOOLS = [
+    {
+        name: "get_profile",
+        description: "Get the authenticated actor profile, workspace ID, and subscription tier.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "get_organization",
+        description: "Get workspace governance policy, monthly action usage, credit balance, and active connection/resource counts.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "search_tools",
+        description: "Search the unified Muxo catalog across Connected Apps (Composio SDK: app.*), Instant Tools (Composio Instant: instant.*), and Cloud Infrastructure (Stripe Projects: resource.*).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search keywords (e.g. 'postgres', 'github issue', 'web search', 'redis')",
+                },
+                lane: {
+                    type: "string",
+                    enum: ["all", "composio_sdk", "composio_instant", "stripe_projects"],
+                    default: "all",
+                },
+                risk_level: {
+                    type: "string",
+                    enum: ["read", "write", "admin", "financial", "provisioning", "destructive"],
+                },
+                limit: { type: "number", default: 20 },
+            },
+        },
+    },
+    {
+        name: "inspect_tool",
+        description: "Inspect a tool's full input JSON schema, risk classification, provider lane, and credit cost before planning.",
+        inputSchema: {
+            type: "object",
+            required: ["tool_slug"],
+            properties: {
+                tool_slug: {
+                    type: "string",
+                    description: "Canonical Muxo tool slug (e.g. 'instant.hackernews.top_stories' or 'resource.neon.launch')",
+                },
+            },
+        },
+    },
+    {
+        name: "connection_status",
+        description: "Check connection status across Composio OAuth apps, Instant wallet, and linked Stripe Projects cloud providers.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                provider: {
+                    type: "string",
+                    description: "Optional provider filter (e.g. 'github', 'slack', 'neon', 'supabase')",
+                },
+                sync_live: {
+                    type: "boolean",
+                    default: true,
+                    description: "Whether to sync live status from upstream Composio and Stripe Projects",
+                },
+            },
+        },
+    },
+    {
+        name: "start_connection",
+        description: "Initiate an OAuth connection for a Connected App (Composio) or link a cloud provider (Stripe Projects).",
+        inputSchema: {
+            type: "object",
+            required: ["provider"],
+            properties: {
+                provider: {
+                    type: "string",
+                    description: "Provider or toolkit slug (e.g. 'github', 'gmail', 'slack', 'neon')",
+                },
+                lane: {
+                    type: "string",
+                    enum: ["composio_sdk", "stripe_projects"],
+                    description: "Provider lane (defaults to composio_sdk unless prefixed with resource.)",
+                },
+                callback_url: {
+                    type: "string",
+                    description: "Optional OAuth callback URL",
+                },
+            },
+        },
+    },
+    {
+        name: "wait_for_connection",
+        description: "Poll and wait for an external user's pending OAuth connection handoff to become active before resuming a planned operation.",
+        inputSchema: {
+            type: "object",
+            required: ["provider"],
+            properties: {
+                provider: {
+                    type: "string",
+                    description: "Provider or toolkit slug (e.g. 'github', 'gmail', 'slack', 'notion', 'linear')",
+                },
+                timeout_seconds: {
+                    type: "number",
+                    default: 15,
+                    description: "Maximum seconds to poll for OAuth completion (0-120, default 15)",
+                },
+            },
+        },
+    },
+    {
+        name: "plan_action",
+        description: "Create a governed execution plan (plan_*) for any tool or infrastructure provisioning operation. Evaluates workspace policy, risk level, and credit balance.",
+        inputSchema: {
+            type: "object",
+            required: ["tool_slug"],
+            properties: {
+                tool_slug: { type: "string", description: "Muxo tool slug to plan" },
+                input: {
+                    type: "object",
+                    description: "Arguments matching the tool's inputSchema",
+                },
+                reason: {
+                    type: "string",
+                    description: "Audit reason explaining why this action is being planned",
+                },
+            },
+        },
+    },
+    {
+        name: "get_plan",
+        description: "Inspect the status, risk level, and approval state of a planned action.",
+        inputSchema: {
+            type: "object",
+            required: ["plan_id"],
+            properties: {
+                plan_id: { type: "string", description: "Plan ID (plan_*)" },
+            },
+        },
+    },
+    {
+        name: "get_run_context",
+        description: "Get the workspace runtime context, Supermemory v5 contextual brain (static/dynamic profile + hybrid search recall), Microsoft Agent Governance status, active provisioned Stripe Projects resources, and redacted environment variable keys.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Optional semantic search query to recall relevant workspace memories from Supermemory v5",
+                },
+            },
+        },
+    },
+    {
+        name: "execute_read",
+        description: "Execute an approved plan with riskLevel = 'read'.",
+        inputSchema: {
+            type: "object",
+            required: ["plan_id"],
+            properties: {
+                plan_id: { type: "string", description: "Plan ID (plan_*)" },
+            },
+        },
+    },
+    {
+        name: "execute_write",
+        description: "Execute an approved plan with riskLevel = 'write'.",
+        inputSchema: {
+            type: "object",
+            required: ["plan_id"],
+            properties: {
+                plan_id: { type: "string", description: "Plan ID (plan_*)" },
+            },
+        },
+    },
+    {
+        name: "execute_admin",
+        description: "Execute an approved plan with riskLevel = 'admin'.",
+        inputSchema: {
+            type: "object",
+            required: ["plan_id"],
+            properties: {
+                plan_id: { type: "string", description: "Plan ID (plan_*)" },
+            },
+        },
+    },
+    {
+        name: "execute_financial",
+        description: "Execute an approved plan with riskLevel = 'financial'.",
+        inputSchema: {
+            type: "object",
+            required: ["plan_id"],
+            properties: {
+                plan_id: { type: "string", description: "Plan ID (plan_*)" },
+            },
+        },
+    },
+    {
+        name: "execute_provisioning",
+        description: "Execute an approved infrastructure provisioning plan with riskLevel = 'provisioning' via Stripe Projects.",
+        inputSchema: {
+            type: "object",
+            required: ["plan_id"],
+            properties: {
+                plan_id: { type: "string", description: "Plan ID (plan_*)" },
+            },
+        },
+    },
+    {
+        name: "execute_destructive",
+        description: "Execute an approved plan with riskLevel = 'destructive'.",
+        inputSchema: {
+            type: "object",
+            required: ["plan_id"],
+            properties: {
+                plan_id: { type: "string", description: "Plan ID (plan_*)" },
+            },
+        },
+    },
+    {
+        name: "get_run",
+        description: "Get the execution status, output, duration, and metered cost of a run (run_*).",
+        inputSchema: {
+            type: "object",
+            required: ["run_id"],
+            properties: {
+                run_id: { type: "string", description: "Run ID (run_*)" },
+            },
+        },
+    },
+    {
+        name: "cancel_run",
+        description: "Cancel an in-progress run and issue a cancellation receipt.",
+        inputSchema: {
+            type: "object",
+            required: ["run_id"],
+            properties: {
+                run_id: { type: "string", description: "Run ID (run_*)" },
+            },
+        },
+    },
+    {
+        name: "get_receipt",
+        description: "Fetch and cryptographically verify the HMAC-SHA256 chained execution receipt (rcpt_*) for a run.",
+        inputSchema: {
+            type: "object",
+            required: ["receipt_id"],
+            properties: {
+                receipt_id: {
+                    type: "string",
+                    description: "Receipt ID (rcpt_*) or Run ID (run_*)",
+                },
+            },
+        },
+    },
+];
+export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
+    switch (toolName) {
+        case "get_profile":
+            return engine.getProfile(ctx);
+        case "get_organization":
+            return engine.getOrganization(ctx);
+        case "search_tools":
+            return engine.searchTools({
+                query: args.query ? String(args.query) : undefined,
+                lane: args.lane || "all",
+                riskLevel: args.risk_level,
+                limit: args.limit ? Number(args.limit) : 20,
+            });
+        case "inspect_tool":
+            return engine.inspectTool(String(args.tool_slug || args.slug || ""));
+        case "connection_status":
+            return engine.connectionStatus(ctx, {
+                provider: args.provider ? String(args.provider) : undefined,
+                syncLive: args.sync_live !== false,
+            });
+        case "start_connection":
+            return engine.startConnection(ctx, {
+                provider: String(args.provider || ""),
+                lane: args.lane,
+                callbackUrl: args.callback_url ? String(args.callback_url) : undefined,
+            });
+        case "wait_for_connection":
+            return engine.waitForConnection(ctx, {
+                provider: String(args.provider || ""),
+                timeoutSeconds: args.timeout_seconds !== undefined
+                    ? Number(args.timeout_seconds)
+                    : 15,
+            });
+        case "plan_action":
+            return engine.planAction(ctx, {
+                toolSlug: String(args.tool_slug || args.slug || ""),
+                input: args.input || {},
+                reason: args.reason ? String(args.reason) : undefined,
+            });
+        case "get_plan":
+            return engine.getPlan(ctx, String(args.plan_id || ""));
+        case "get_run_context":
+            return engine.getRunContext(ctx, args.query ? String(args.query) : undefined);
+        case "execute_read":
+            return engine.executePlanForRisk(ctx, String(args.plan_id || ""), "read");
+        case "execute_write":
+            return engine.executePlanForRisk(ctx, String(args.plan_id || ""), "write");
+        case "execute_admin":
+            return engine.executePlanForRisk(ctx, String(args.plan_id || ""), "admin");
+        case "execute_financial":
+            return engine.executePlanForRisk(ctx, String(args.plan_id || ""), "financial");
+        case "execute_provisioning":
+            return engine.executePlanForRisk(ctx, String(args.plan_id || ""), "provisioning");
+        case "execute_destructive":
+            return engine.executePlanForRisk(ctx, String(args.plan_id || ""), "destructive");
+        case "get_run":
+            return engine.getRun(ctx, String(args.run_id || ""));
+        case "cancel_run":
+            return engine.cancelRun(ctx, String(args.run_id || ""));
+        case "get_receipt":
+            return engine.getReceipt(ctx, String(args.receipt_id || args.run_id || ""));
+        default:
+            throw new Error(`Unknown MCP tool: ${toolName}`);
+    }
+}
+export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
+    const id = rpc.id ?? null;
+    const method = String(rpc.method || "");
+    const params = (rpc.params || {});
+    if (method === "notifications/initialized") {
+        return null;
+    }
+    try {
+        if (method === "initialize") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    protocolVersion: "2024-11-05",
+                    serverInfo: {
+                        name: "muxo-mcp-server",
+                        version: "1.0.0",
+                    },
+                    capabilities: {
+                        tools: {},
+                    },
+                },
+            };
+        }
+        if (method === "ping") {
+            return { jsonrpc: "2.0", id, result: {} };
+        }
+        if (method === "tools/list") {
+            return {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    tools: MUXO_MCP_TOOLS,
+                },
+            };
+        }
+        if (method === "tools/call") {
+            const toolName = String(params.name || "");
+            const toolArgs = (params.arguments || {});
+            const output = await dispatchMcpToolCall(engine, ctx, toolName, toolArgs);
+            return {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(output, null, 2),
+                        },
+                    ],
+                    isError: false,
+                },
+            };
+        }
+        return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+                code: -32601,
+                message: `Method not found: ${method}`,
+            },
+        };
+    }
+    catch (err) {
+        return {
+            jsonrpc: "2.0",
+            id,
+            result: {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            ok: false,
+                            error: String(err?.message || err || "MCP tool execution failed"),
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { MuxoConfig } from "../config.js";
+import type { MuxoTool } from "../types.js";
+export declare class ComposioInstantAdapter {
+    private readonly config;
+    constructor(config: MuxoConfig);
+    getTools(): MuxoTool[];
+    searchTools(query?: string, limit?: number): MuxoTool[];
+    inspectTool(slug: string): MuxoTool | null;
+    executeTool(params: {
+        workspaceId: string;
+        tool: MuxoTool;
+        input: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+}