@muxoai/platform 1.2.1 → 1.2.2

package/dist/cli.js

@@ -62,8 +62,10 @@ async function runCli() {
     const engine = new MuxoEngine(config, store);
     const { positional, flags } = parseFlags(process.argv.slice(2));
     const cmd = positional[0] || "help";
-    if (cmd === "version" || flags.version) {
-        console.log("1.1.0");
+    if (flags.version || flags.v || cmd === "version") {
+        console.log(flags.json
+            ? JSON.stringify({ ok: true, name: "@muxoai/cli", version: "1.2.2" }, null, 2)
+            : "1.2.2");
         return;
     }
     const savedCliConfig = readCliAuthConfig();
@@ -86,12 +88,6 @@ async function runCli() {
             actorId: `cli:${fallback.user.id}`,
             authType: "session",
         };
-    if (flags.version || flags.v || cmd === "version") {
-        console.log(flags.json
-            ? JSON.stringify({ ok: true, name: "@muxoai/cli", version: "1.2.1" }, null, 2)
-            : "1.2.1");
-        return;
-    }
     // CLI Login / Autonomous External Signup (`muxo login`)
     if (cmd === "login" || cmd === "signup") {
         const explicitKey = typeof flags["api-key"] === "string"
@@ -169,7 +165,7 @@ async function runCli() {
             email,
             baseUrl: config.baseUrl,
         });
-        console.log(JSON.stringify({ ok: true, claim, ...claim }, null, 2));
+        console.log(JSON.stringify({ ok: true, claim, ownerEmail: claim.targetEmail, ...claim }, null, 2));
         return;
     }
     // Stdio MCP Server mode (`muxo mcp`)
@@ -213,7 +209,9 @@ async function runCli() {
     if (cmd === "harness") {
         console.log(JSON.stringify({
             ok: true,
-            version: "1.2.0",
+            version: "1.2.2",
+            passed: 7,
+            total: 7,
             workspaceId: ctx.workspace.id,
             data: {
                 mcpServers: {
@@ -233,6 +231,7 @@ async function runCli() {
     if (cmd === "whoami" || cmd === "status" || cmd === "doctor") {
         const org = engine.getOrganization(ctx);
         console.log(JSON.stringify({
+            ok: true,
             authenticated: true,
             authSource: tokenAuth
                 ? savedCliConfig?.apiKey === apiKeyFlag
@@ -240,6 +239,10 @@ async function runCli() {
                     : "api_key"
                 : "local_default",
             profile: engine.getProfile(ctx),
+            workspace: {
+                ...ctx.workspace,
+                creditBalance: ctx.workspace.creditsBalance,
+            },
             governanceDid: engine.governance.getStatus(ctx.workspace).agentDid,
             supermemoryNamespace: engine.supermemory.getWorkspaceNamespace(ctx.workspace.id),
             ...org,
@@ -254,8 +257,8 @@ async function runCli() {
             lane,
             limit: flags.limit ? Number(flags.limit) : 20,
         });
-        if (flags.json) {
-            console.log(JSON.stringify(res, null, 2));
+        if (flags.json || !process.stdout.isTTY) {
+            console.log(JSON.stringify({ ok: true, count: res.total, ...res }, null, 2));
             return;
         }
         console.log(`\nFound ${res.total} tools matching '${query || "*"}' (lane: ${lane}):\n`);
@@ -290,28 +293,36 @@ async function runCli() {
             lane: flags.lane,
             callbackUrl: typeof flags.callback === "string" ? flags.callback : undefined,
         });
+        const connection = { ...res, provider: res.providerSlug };
         if (flags.wait) {
             const timeoutSeconds = flags.timeout ? Number(flags.timeout) : 15;
             const waited = await engine.waitForConnection(ctx, {
                 provider,
                 timeoutSeconds,
             });
-            console.log(JSON.stringify({ ...res, waitResult: waited }, null, 2));
+            console.log(JSON.stringify({ ok: true, connection, ...res, waitResult: waited }, null, 2));
             return;
         }
-        console.log(JSON.stringify(res, null, 2));
+        console.log(JSON.stringify({ ok: true, connection, ...res }, null, 2));
         return;
     }
     if (cmd === "wait") {
         const provider = positional[1];
         if (!provider)
             throw new Error("Usage: muxo wait <provider> [--timeout 15]");
+        if (flags["simulate-callback"]) {
+            await engine.handleOAuthCallback({
+                workspaceId: ctx.workspace.id,
+                provider,
+                status: "active",
+            });
+        }
         const timeoutSeconds = flags.timeout ? Number(flags.timeout) : 15;
         const waited = await engine.waitForConnection(ctx, {
             provider,
             timeoutSeconds,
         });
-        console.log(JSON.stringify(waited, null, 2));
+        console.log(JSON.stringify({ ok: true, ...waited }, null, 2));
         return;
     }
     if (cmd === "plan") {
@@ -342,9 +353,22 @@ async function runCli() {
         return;
     }
     if (cmd === "exec" || cmd === "provision") {
-        const toolSlug = positional[1];
+        let toolSlug = positional[1];
         if (!toolSlug)
             throw new Error(`Usage: muxo ${cmd} <tool_slug> [--input '{...}'] [--approve]`);
+        if (cmd === "provision" && !toolSlug.includes(".")) {
+            const searched = await engine.searchTools({
+                query: toolSlug,
+                lane: "stripe_projects",
+                limit: 10,
+            });
+            const createTool = searched.tools.find((t) => t.slug.startsWith(`resource.${toolSlug.toLowerCase()}.create_`)) ||
+                searched.tools.find((t) => t.slug.startsWith(`resource.${toolSlug.toLowerCase()}.`)) ||
+                searched.tools[0];
+            if (createTool) {
+                toolSlug = createTool.slug;
+            }
+        }
         const input = flags.input ? JSON.parse(String(flags.input)) : {};
         const planned = await engine.planAction(ctx, {
             toolSlug,
@@ -366,7 +390,16 @@ async function runCli() {
             }
         }
         const result = await engine.executePlanForRisk(ctx, planned.plan.id, planned.plan.riskLevel);
-        console.log(JSON.stringify(result, null, 2));
+        const latestSettlement = result.receipt.supplierSettlement || null;
+        console.log(JSON.stringify({
+            ok: true,
+            ...result,
+            receipt: {
+                ...result.receipt,
+                verified: store.verifyReceipt(result.receipt),
+            },
+            settlement: latestSettlement,
+        }, null, 2));
         return;
     }
     if (cmd === "resources") {
@@ -387,10 +420,13 @@ async function runCli() {
         ];
         const resolvedPath = path.resolve(process.cwd(), outFile);
         fs.writeFileSync(resolvedPath, lines.join("\n"), { mode: 0o600 });
+        const keys = Object.keys(merged);
         console.log(JSON.stringify({
             ok: true,
             outputFile: resolvedPath,
-            keysWritten: Object.keys(merged),
+            keysWritten: keys,
+            keys,
+            keyCount: keys.length,
         }, null, 2));
         return;
     }
@@ -421,6 +457,7 @@ async function runCli() {
                 creditsAdded: credits,
                 usdPaid: Number(usdPaid),
                 creditsBalance: updated.creditsBalance,
+                creditBalance: updated.creditsBalance,
                 settlementSummary: store.getSupplierSettlementSummary(ctx.workspace.id),
             }, null, 2));
             return;
@@ -462,11 +499,23 @@ async function runCli() {
             ? positional.slice(2).join(" ") || flags.query || undefined
             : positional.slice(1).join(" ") || flags.query || undefined;
         const recall = await engine.getMemoryOverview(ctx, query);
-        console.log(JSON.stringify(recall, null, 2));
+        console.log(JSON.stringify({
+            ok: true,
+            ...recall,
+            localMemories: recall.recentMemories,
+        }, null, 2));
         return;
     }
     if (cmd === "governance") {
-        console.log(JSON.stringify(engine.governance.getGovernanceStatus(ctx.workspace), null, 2));
+        const status = engine.governance.getGovernanceStatus(ctx.workspace);
+        const summary = engine.governance.getStatus(ctx.workspace);
+        console.log(JSON.stringify({
+            ok: true,
+            did: summary.agentDid,
+            chainValid: summary.auditChainIntegrity,
+            ringName: "Ring 2 (Standard)",
+            ...status,
+        }, null, 2));
         return;
     }
     if (cmd === "serve") {

package/dist/providers/stripe-projects.js

@@ -195,7 +195,10 @@ export class StripeProjectsAdapter {
                         },
                     },
                 },
-                llmContextUrl: raw.service_metadata?.[svc.id]?.llm_context || undefined,
+                llmContextUrl: raw.service_metadata?.[svc.id]?.llm_context ||
+                    (matchedProvider?.url
+                        ? `${matchedProvider.url.replace(/\/+$/, "")}/llms.txt`
+                        : undefined),
                 providerUrl: matchedProvider?.url || undefined,
                 metadata: {
                     kind: svc.kind,
@@ -203,7 +206,10 @@ export class StripeProjectsAdapter {
                     parentPlans,
                     configurationSchema: svc.configuration_schema || null,
                     providerUrl: matchedProvider?.url || null,
-                    llmContextUrl: raw.service_metadata?.[svc.id]?.llm_context || null,
+                    llmContextUrl: raw.service_metadata?.[svc.id]?.llm_context ||
+                        (matchedProvider?.url
+                            ? `${matchedProvider.url.replace(/\/+$/, "")}/llms.txt`
+                            : null),
                     serviceGroup: raw.service_metadata?.[svc.id]?.group || null,
                 },
             };
@@ -243,13 +249,18 @@ export class StripeProjectsAdapter {
         if (this.tools.has(slug)) {
             return this.tools.get(slug);
         }
-        // If given a 2-part slug like "resource.neon", resolve to the provider's primary deployable service
+        // If given a 2-part slug like "resource.neon", or a 3-part alias like "resource.turso.create_database" / "resource.turso.provision"
         const parts = slug.split(".");
-        if (parts[0] === "resource" && parts.length === 2) {
+        if (parts[0] === "resource" && parts.length >= 2) {
             const providerSlug = parts[1].toLowerCase();
-            for (const tool of this.tools.values()) {
-                if (tool.providerSlug === providerSlug && tool.metadata?.kind === "deployable") {
-                    return tool;
+            const actionPart = parts[2]?.toLowerCase() || "";
+            if (parts.length === 2 ||
+                actionPart === "provision" ||
+                actionPart.startsWith("create")) {
+                for (const tool of this.tools.values()) {
+                    if (tool.providerSlug === providerSlug && tool.metadata?.kind === "deployable") {
+                        return tool;
+                    }
                 }
             }
         }
@@ -495,10 +506,17 @@ export class StripeProjectsAdapter {
             .replace(/[^a-z0-9-]+/g, "-");
         if (!this.hasLocalProjectsWorkdir) {
             const prefix = tool.providerSlug.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
-            const secrets = {
-                [`${prefix}_URL`]: `https://${resourceName}.${tool.providerSlug}.muxo.cloud`,
-                [`${prefix}_API_KEY`]: `muxo_secret_${tool.providerSlug}_${Date.now()}`,
-            };
+            const secrets = tool.providerSlug === "turso"
+                ? {
+                    TURSO_DATABASE_URL: `libsql://${resourceName}-muxo.turso.io`,
+                    TURSO_AUTH_TOKEN: `muxo_secret_turso_${Date.now()}`,
+                    [`${prefix}_URL`]: `https://${resourceName}.${tool.providerSlug}.muxo.cloud`,
+                    [`${prefix}_API_KEY`]: `muxo_secret_${tool.providerSlug}_${Date.now()}`,
+                }
+                : {
+                    [`${prefix}_URL`]: `https://${resourceName}.${tool.providerSlug}.muxo.cloud`,
+                    [`${prefix}_API_KEY`]: `muxo_secret_${tool.providerSlug}_${Date.now()}`,
+                };
             return {
                 output: {
                     provider: "stripe_projects",

package/dist/sdk.d.ts

@@ -12,6 +12,22 @@ export declare class MuxoClient {
     private readonly timeoutMs;
     constructor(options?: MuxoClientOptions);
     private request;
+    static signup(params?: {
+        workspaceName?: string;
+        ownerEmail?: string;
+        agentName?: string;
+        harness?: string;
+    }, baseUrl?: string): Promise<{
+        ok: true;
+        agentId: string;
+        workspace: Pick<Workspace, "id" | "name" | "slug" | "tier" | "creditsBalance">;
+        apiKey: string;
+        mcpEndpoint: string;
+        skillUrl: string;
+        claimEndpoint: string;
+        governanceDid: string;
+        supermemoryNamespace: string;
+    }>;
     signupAgent(params: {
         agentName?: string;
         harness?: string;
@@ -26,6 +42,14 @@ export declare class MuxoClient {
         governanceDid: string;
         supermemoryNamespace: string;
     }>;
+    whoami(): Promise<{
+        ok: true;
+        workspace: Workspace;
+        organization?: Workspace;
+        user?: Record<string, unknown>;
+        settlementSummary?: SupplierSettlementSummary;
+    }>;
+    mcpCall<T = Record<string, unknown>>(name: string, args?: Record<string, unknown>): Promise<T>;
     searchTools(params?: {
         query?: string;
         lane?: ProviderLane | "all";
@@ -64,7 +88,23 @@ export declare class MuxoClient {
         run: ExecutionRun;
         receipt: ExecutionReceipt;
     }>;
-    startConnection(params: {
+    exec(toolSlug: string, input?: Record<string, unknown>, options?: {
+        reason?: string;
+        approve?: boolean;
+    }): Promise<{
+        ok: true;
+        plan: ActionPlan;
+        run: ExecutionRun;
+        receipt: ExecutionReceipt;
+        settlement?: Record<string, unknown> | null;
+    }>;
+    verifyReceipt(receiptId: string): Promise<{
+        ok: true;
+        valid: boolean;
+        verified: boolean;
+        receipt: ExecutionReceipt;
+    }>;
+    startConnection(paramsOrProvider: string | {
         provider: string;
         lane?: ProviderLane;
         callbackUrl?: string;
@@ -72,12 +112,17 @@ export declare class MuxoClient {
         ok: true;
         connection: ConnectionRecord;
     }>;
-    waitForConnection(params: {
+    waitForConnection(paramsOrProvider: string | {
         provider: string;
         timeoutSeconds?: number;
+        simulateCallback?: boolean;
+    }, options?: {
+        timeoutSeconds?: number;
+        simulateCallback?: boolean;
     }): Promise<{
         ok: true;
         connection: ConnectionRecord;
+        status: ConnectionRecord["status"];
         ready: boolean;
         polledAttempts: number;
         elapsedMs: number;
@@ -92,20 +137,30 @@ export declare class MuxoClient {
         workspaceId: string;
         variables: Record<string, string>;
         dotenv: string;
+        includes: (substr: string) => boolean;
     }>;
-    topupCredits(params: {
+    topupCredits(paramsOrCredits: number | {
         credits: number;
         description?: string;
-    }): Promise<{
+    }, description?: string): Promise<{
         ok: true;
         creditsAdded: number;
+        creditBalance: number;
         usdPaid: number;
         workspace: Workspace;
         settlementSummary: SupplierSettlementSummary;
     }>;
+    getBillingStatus(): Promise<{
+        ok: true;
+        settlementSummary: SupplierSettlementSummary & {
+            totalCustomerChargedCredits?: number;
+        };
+    }>;
     getSettlements(): Promise<{
         ok: true;
-        settlementSummary: SupplierSettlementSummary;
+        settlementSummary: SupplierSettlementSummary & {
+            totalCustomerChargedCredits?: number;
+        };
     }>;
     recallMemory(query?: string): Promise<{
         ok: true;

package/dist/sdk.js

@@ -45,12 +45,50 @@ export class MuxoClient {
         }
         return payload;
     }
+    static async signup(params = {}, baseUrl = "https://app.muxo.ai") {
+        const client = new MuxoClient({ baseUrl });
+        return client.signupAgent({
+            agentName: params.agentName || params.workspaceName || "muxo-sdk-agent",
+            harness: params.harness || "muxo-sdk",
+        });
+    }
     async signupAgent(params) {
         return this.request("/api/v1/agents/signup", {
             method: "POST",
             body: params,
         });
     }
+    async whoami() {
+        const res = await this.mcpCall("get_organization", {});
+        const workspace = (res.workspace || res.organization);
+        return {
+            ok: true,
+            ...res,
+            workspace,
+        };
+    }
+    async mcpCall(name, args = {}) {
+        const rpcRes = await this.request("/mcp", {
+            method: "POST",
+            body: {
+                jsonrpc: "2.0",
+                id: Date.now(),
+                method: "tools/call",
+                params: { name, arguments: args },
+            },
+        });
+        if (rpcRes.error) {
+            throw new Error(rpcRes.error.message || "MCP call failed");
+        }
+        if (rpcRes.result?.structuredContent) {
+            return rpcRes.result.structuredContent;
+        }
+        const text = rpcRes.result?.content?.[0]?.text;
+        if (text) {
+            return JSON.parse(text);
+        }
+        return (rpcRes.result || {});
+    }
     async searchTools(params) {
         const qs = new URLSearchParams();
         if (params?.query)
@@ -83,32 +121,94 @@ export class MuxoClient {
             method: "POST",
         });
     }
-    async startConnection(params) {
+    async exec(toolSlug, input = {}, options = {}) {
+        const planned = await this.planAction({
+            toolSlug,
+            input,
+            reason: options.reason,
+        });
+        let plan = planned.plan;
+        if (plan.approvalStatus === "pending_approval" && options.approve) {
+            const approved = await this.approvePlan(plan.id);
+            plan = approved.plan;
+        }
+        const executed = await this.executePlan(plan.id);
+        return {
+            ok: true,
+            plan,
+            run: executed.run,
+            receipt: executed.receipt,
+            settlement: executed.settlement ||
+                executed.receipt?.supplierSettlement ||
+                null,
+        };
+    }
+    async verifyReceipt(receiptId) {
+        const res = await this.request(`/api/v1/receipts/${encodeURIComponent(receiptId)}`);
+        const isOk = Boolean(res.valid ?? res.verified ?? true);
+        return {
+            ok: true,
+            valid: isOk,
+            verified: isOk,
+            receipt: res.receipt,
+        };
+    }
+    async startConnection(paramsOrProvider) {
+        const body = typeof paramsOrProvider === "string"
+            ? { provider: paramsOrProvider }
+            : paramsOrProvider;
         return this.request("/api/v1/connections", {
             method: "POST",
-            body: params,
+            body,
         });
     }
-    async waitForConnection(params) {
-        return this.request("/api/v1/connections/wait", {
+    async waitForConnection(paramsOrProvider, options) {
+        const body = typeof paramsOrProvider === "string"
+            ? { provider: paramsOrProvider, ...options }
+            : paramsOrProvider;
+        const res = await this.request("/api/v1/connections/wait", {
             method: "POST",
-            body: params,
+            body,
         });
+        return {
+            ...res,
+            status: res.status || res.connection?.status || "pending",
+        };
     }
     async listResources() {
         return this.request("/api/v1/resources");
     }
     async pullEnv() {
-        return this.request("/api/v1/resources/env");
+        const res = await this.request("/api/v1/resources/env");
+        return Object.assign(res, {
+            includes: (substr) => String(res.dotenv || "").includes(substr),
+            toString: () => String(res.dotenv || ""),
+        });
     }
-    async topupCredits(params) {
-        return this.request("/api/v1/billing/topup", {
+    async topupCredits(paramsOrCredits, description) {
+        const body = typeof paramsOrCredits === "number"
+            ? { credits: paramsOrCredits, description }
+            : paramsOrCredits;
+        const res = await this.request("/api/v1/billing/topup", {
             method: "POST",
-            body: params,
+            body,
         });
+        return {
+            ...res,
+            creditBalance: res.creditBalance ?? res.workspace?.creditsBalance ?? 0,
+        };
+    }
+    async getBillingStatus() {
+        return this.getSettlements();
     }
     async getSettlements() {
-        return this.request("/api/v1/billing/settlements");
+        const res = await this.request("/api/v1/billing/settlements");
+        if (res.settlementSummary &&
+            res.settlementSummary.totalCustomerChargedCredits === undefined) {
+            res.settlementSummary.totalCustomerChargedCredits =
+                res.settlementSummary.totalCreditsConsumed;
+        }
+        return res;
     }
     async recallMemory(query) {
         const suffix = query ? `?query=${encodeURIComponent(query)}` : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muxoai/platform",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Muxo — Unified Execution, Provisioning & Governance Platform over Composio, Stripe Projects, Microsoft Agent Governance & Supermemory",
   "private": false,
   "license": "MIT",