@muxoai/platform 1.3.0 → 1.3.2

package/.agents/plugins/marketplace.json

@@ -6,7 +6,7 @@
   "plugins": [
     {
       "name": "muxo",
-      "version": "1.2.3",
+      "version": "1.3.1",
       "description": "Governed execution across 1,000+ Connected Apps, Instant Tools (search, scrape, crawl, SEO audit), Cloud Infrastructure provisioning, Supermemory v5 recall, and Microsoft Agent Governance Ed25519 receipts.",
       "source": {
         "source": "local",

package/.claude-plugin/marketplace.json

@@ -1,17 +1,32 @@
 {
   "name": "muxo",
+  "description": "Official Muxo plugin marketplace for governed execution across Connected Apps, Instant Tools, Cloud Infrastructure, and Workspace Memory.",
   "owner": {
     "name": "Muxo",
     "email": "founders@muxo.ai",
     "url": "https://muxo.ai"
   },
+  "metadata": {
+    "description": "Official Muxo plugin marketplace for governed execution across Connected Apps, Instant Tools, Cloud Infrastructure, and Workspace Memory.",
+    "version": "1.3.1"
+  },
   "plugins": [
     {
       "name": "muxo",
-      "source": "./plugins/muxo",
-      "description": "Governed execution across 1,000+ Connected Apps, Instant Tools (search, scrape, crawl, SEO audit), Cloud Infrastructure provisioning, Supermemory v5 recall, and Microsoft Agent Governance Ed25519 receipts.",
-      "version": "1.2.3",
-      "category": "Productivity"
+      "source": {
+        "source": "npm",
+        "package": "@muxoai/cli"
+      },
+      "strict": false,
+      "description": "Governed execution across 1,000+ Connected Apps, Instant Tools (search, scrape, crawl, SEO audit), Cloud Infrastructure provisioning, Workspace Memory recall, and verifiable audit records.",
+      "version": "1.3.1",
+      "category": "Productivity",
+      "skills": [
+        "./plugins/muxo/skills/muxo",
+        "./plugins/muxo/skills/setup"
+      ],
+      "hooks": "./plugins/muxo/hooks/hooks.json",
+      "mcpServers": "./plugins/muxo/.mcp.json"
     }
   ]
 }

package/.codex/config.toml

@@ -1,5 +1,12 @@
-# OpenAI Codex Local Plugin Configuration for Muxo
-# Reference: https://developers.openai.com/plugins/build/plugins
+# OpenAI Codex Configuration for Muxo
+# Reference: https://developers.openai.com/codex/plugins
 
 [plugins."muxo@muxo"]
 enabled = true
+
+# TOML MCP Alternative (~/.codex/config.toml):
+[mcp_servers.muxo]
+url = "https://api.muxo.ai/mcp"
+# Or for local stdio proxy (requires Node.js 22+):
+# command = "npx"
+# args = ["-y", "@muxoai/cli@latest", "mcp"]

package/README.md

@@ -1,25 +1,27 @@
 # Muxo (`@muxoai/platform` / `@muxoai/cli` / `@muxoai/sdk`)
 
-Muxo (`v1.3.0`) is the unified execution, cloud infrastructure provisioning, contextual memory, and cryptographic governance platform for AI agents and applications. Customers and their agents interact exclusively with **Muxo** — either via structured tool slugs or free-form **Natural Language** (`muxo do`, `POST /api/v1/do`, `client.do()`, and MCP `plan_action`).
+Muxo (`v1.3.2`) is the unified execution, cloud infrastructure provisioning, contextual memory, and cryptographic governance platform for AI agents and applications. Customers and their agents interact exclusively with **Muxo** — either via structured tool slugs or free-form **Natural Language** (`muxo do`, `POST /api/v1/do`, `client.do()`, and MCP `plan_action`).
 
 See [`ARCHITECTURE.md`](./ARCHITECTURE.md) for the complete internal engineering blueprint, open-source ecosystem Keep/Adopt/Drop matrix, and 4-pillar architecture.
 
 Under the hood, Muxo unifies **four core pillars** plus **Natural Language Routing** and **BYOK (Bring Your Own Key) 0-Credit Execution** behind one **19-operation MCP contract**, OpenAI Plugin (`agent-plugins.org/1.0.0`), REST API, Interactive CLI/TUI (`@muxoai/cli`), TypeScript SDK (`@muxoai/sdk`), and Web Console (`https://app.muxo.ai`):
 
-1. **Composio Connected Apps (`app.*`) & Instant (`instant.*`)** — Managed OAuth SaaS integrations (`app.github.*`, `app.gmail.*`, `app.slack.*`, `app.notion.*`, `app.linear.*`) with live browser OAuth handoff (`wait_for_connection`), zero-OAuth instant capabilities (`instant.web.search`, `instant.web.scrape`, `instant.web.crawl`, `instant.seo.audit`, `instant.hackernews.top_stories`, `instant.github.repo_intel`, `instant.dns.lookup`, `instant.composio.workbench`), plus **Autonomous 2-Call Agent Signup & Claim** (`POST /api/v1/agents/signup` + `POST /api/v1/agents/claim`).
-2. **Stripe Projects Cloud Infrastructure (`resource.*`) + Merchant-of-Record Billing (`muxo_funded`) & BYOK (`byok`)** — Governed cloud resource provisioning across 60+ providers (`Turso`, `Neon`, `Supabase`, `Cloudflare`, `Vercel`, `Upstash`, `Resend`, `Railway`, `Render`, etc.) with automatic companion plan resolution, AES-256-GCM encrypted secret custody (`muxo env pull`), unified credit settlement (`muxo_funded`), and **0-credit BYOK mode** (`muxo byok set <provider>`) when you bring your own supplier or LLM API keys.
-3. **Supermemory v5 Contextual Brain (`/ns/muxo-v5-*`)** — Isolated per-workspace long-term static facts, dynamic session context, and hybrid semantic search recalled before every tool plan (`plan_action` & `get_run_context`), with strict secret redaction before memory ingestion.
-4. **Microsoft Agent Governance Toolkit (`@microsoft/agent-governance-sdk` v5.0.0)** — Every planned and executed operation passes through `Agent ──► McpSecurityScanner ──► PolicyEngine ──► AgentIdentity (Ed25519 DID) ──► AuditLogger (SHA-256 chain) ──► DecisionRecord` and produces an HMAC-SHA256 verifiable receipt.
+1. **Connected Apps (`app.*`) & Instant Tools (`instant.*`)** — Managed OAuth SaaS integrations (`app.github.*`, `app.gmail.*`, `app.slack.*`, `app.notion.*`, `app.linear.*`) with live browser OAuth handoff (`wait_for_connection`), zero-OAuth instant capabilities (`instant.web.search`, `instant.web.scrape`, `instant.web.crawl`, `instant.seo.audit`, `instant.hackernews.top_stories`, `instant.github.repo_intel`, `instant.dns.lookup`, `instant.composio.workbench`), plus **CLI-first Autonomous 2-Call Agent Signup & Claim** (`POST /api/v1/agents/signup` + `POST /api/v1/agents/claim`).
+2. **Cloud Infrastructure (`resource.*`) + Unified Credit Billing (`muxo_funded`) & BYOK (`byok`)** — Governed cloud resource provisioning across 60+ providers (`Turso`, `Neon`, `Supabase`, `Cloudflare`, `Vercel`, `Upstash`, `Resend`, `Railway`, `Render`, etc.) with automatic companion plan resolution, AES-256-GCM encrypted secret custody (`muxo env pull`), unified credit settlement (`muxo_funded`), and **0-credit BYOK mode** (`muxo byok set <provider>`) when you bring your own supplier or LLM API keys.
+3. **Workspace Memory (`/ns/muxo-v5-*`)** — Isolated per-workspace long-term static facts, dynamic session context, and hybrid semantic search recalled before every tool plan (`plan_action` & `get_run_context`), with strict secret redaction before memory ingestion.
+4. **Safety & Approvals (Muxo Guardrails)** — Every planned and executed operation passes through prompt-injection security scanning, workspace policy evaluation, cryptographic agent identity (`did:agent:muxo:*`), and produces a verifiable execution audit record.
 
 ---
 
 ## Install & Quickstart (Humans, Harnesses & Agents)
 
+> **Requirement:** `@muxoai/cli` requires **Node.js 22+** (`node >= 22.0.0`).
+
 ```bash
-# 1. Install the Muxo CLI or run directly via npx
+# 1. Install the Muxo CLI or run directly via npx (requires Node.js 22+)
 npm install -g @muxoai/cli@latest
 
-# 2. Zero-browser autonomous signup (creates ~/.muxo/config.json with mk_live_* key + 250 starter credits)
+# 2. CLI-first autonomous signup against the hosted workspace (creates ~/.muxo/config.json with mk_live_* key + 250 starter credits)
 muxo login --signup --name "my-agent"
 
 # 3. Launch the Interactive Terminal TUI (Natural Language bar, BYOK Vault, Billing & Status)
@@ -40,23 +42,64 @@ muxo billing status
 muxo billing topup 1000
 muxo billing upgrade
 
-# 7. Connect an OAuth SaaS App & Provision Live Cloud Infrastructure
+# 7. Connect an OAuth SaaS App (browser consent handoff) & Provision Live Cloud Infrastructure
 muxo link gmail --wait
 muxo provision turso --input '{"database_name":"my-agent-db"}' --approve
 muxo env pull --out .env.muxo
-```
-
-## Official OpenAI Plugin & MCP Server (`https://api.muxo.ai/mcp`)
 
-Muxo ships a portable OpenAI Plugin (`plugins/muxo/plugin.json` & `plugins/muxo/mcp.json`) and Streamable HTTP MCP Server compliant with [OpenAI Plugins](https://developers.openai.com/plugins/build/plugins) and [OpenAI MCP Server](https://developers.openai.com/plugins/build/mcp-server) specifications:
-
-- **Streamable HTTP MCP Endpoint**: `https://api.muxo.ai/mcp` (and `https://app.muxo.ai/mcp`)
-- **Local Stdio MCP Command**: `npx -y @muxoai/cli@latest mcp`
-- **OAuth 2.1 Discovery & DCR/PKCE**:
-  - `https://api.muxo.ai/.well-known/oauth-protected-resource/mcp` (RFC 9728)
-  - `https://api.muxo.ai/.well-known/oauth-authorization-server` (RFC 8414)
-  - `POST https://api.muxo.ai/oauth/register` (Dynamic Client Registration)
-  - `GET https://api.muxo.ai/oauth/authorize` & `POST https://api.muxo.ai/oauth/token` (PKCE `S256`)
+# 8. Check your setup, memory, and safety controls
+muxo harness                                   # API, MCP, auth, kill switch, audit chain, catalog (exit 1 on failure)
+muxo memory facts                              # Facts with history; add --current for current facts only
+muxo memory forget "old staging database"      # Delete matching memories and retire their facts
+muxo governance scan "text to check"           # Prompt-injection check before storing or forwarding text
+muxo governance pause "incident review"        # Kill switch: stop all agent actions in the workspace
+muxo governance resume
+muxo governance policy --ring 2 --block-destructive-sql true --require-approval financial,destructive
+```
+## Official Plugins, Marketplaces & MCP Setup (`https://api.muxo.ai/mcp`)
+
+Muxo ships a portable OpenAI Plugin (`plugins/muxo/plugin.json` & `plugins/muxo/mcp.json`), Claude Code Plugin (`plugins/muxo/.claude-plugin/plugin.json`), and Streamable HTTP MCP Server:
+
+- **Streamable HTTP MCP Endpoints**: `https://api.muxo.ai/mcp` and `https://app.muxo.ai/mcp`
+- **Local Stdio MCP Command** (requires Node.js 22+, proxies to hosted workspace): `npx -y @muxoai/cli@latest mcp`
+- **Claude Code Marketplace (`muxo@muxo`)**:
+  ```bash
+  claude plugin marketplace add https://api.muxo.ai/.claude-plugin/marketplace.json
+  claude plugin install muxo@muxo
+  ```
+- **OpenAI Codex Marketplace & TOML MCP Alternative**:
+  - **Marketplace (Git Repository or Local Directory)**: Add a Git repository or local directory containing `.agents/plugins/marketplace.json`, then enable `[plugins."muxo@muxo"]` in `.codex/config.toml`.
+  - **TOML MCP Alternative (`~/.codex/config.toml`)**:
+    ```toml
+    [mcp_servers.muxo]
+    url = "https://api.muxo.ai/mcp"
+    ```
+    Or for local stdio proxy (requires Node.js 22+):
+    ```toml
+    [mcp_servers.muxo]
+    command = "npx"
+    args = ["-y", "@muxoai/cli@latest", "mcp"]
+    ```
+- **Claude Desktop**:
+  - **Hosted MCP (Custom Connectors)**: Open **Settings → Connectors → Add custom connector** and enter `https://api.muxo.ai/mcp`.
+  - **Local Stdio Server (`claude_desktop_config.json`, requires Node.js 22+)**:
+    ```json
+    {
+      "mcpServers": {
+        "muxo": {
+          "command": "npx",
+          "args": ["-y", "@muxoai/cli@latest", "mcp"]
+        }
+      }
+    }
+    ```
+- **ChatGPT**:
+  - Open **Plugins → + → Add custom MCP server** (at `https://chatgpt.com/plugins`) and enter `https://api.muxo.ai/mcp`.
+  - **OAuth 2.1 Discovery (CIMD or DCR + PKCE)**:
+    - `https://api.muxo.ai/.well-known/oauth-protected-resource/mcp` (RFC 9728)
+    - `https://api.muxo.ai/.well-known/oauth-authorization-server` (RFC 8414)
+    - Client registration can use **Client ID Metadata Documents (CIMD)** or **Dynamic Client Registration (DCR)** (`POST https://api.muxo.ai/oauth/register`); `/oauth/register` is supported when a client uses DCR rather than running on every flow.
+    - `GET https://api.muxo.ai/oauth/authorize` & `POST https://api.muxo.ai/oauth/token` (PKCE `S256`)
 - **SEP-2640 Skills Import Extension (`io.modelcontextprotocol/skills`)**: `skills/list`, `skills/get`, and `resources/read` serving `skill://muxo/muxo/SKILL.md` and `skill://muxo/setup/SKILL.md` with `sha256` integrity digests.
 - **Tool Annotations & Multi-Account Profile**: All 19 tools include `title` and `annotations` (`readOnlyHint`, `destructiveHint`, `openWorldHint`), plus `_meta["openai/profile"]: true` on `get_profile` and Company Knowledge `search`/`fetch` compatibility.
 

package/dist/clerk.d.ts

@@ -0,0 +1,33 @@
+export interface ClerkConfig {
+    publishableKey: string;
+    frontendApi: string;
+    authorizedParties: string[];
+    jwtKey?: string;
+    secretKey?: string;
+}
+export interface ClerkSession {
+    userId: string;
+    sessionId: string;
+    email?: string;
+    emailVerified?: boolean;
+}
+export interface ClerkProfile {
+    email: string | null;
+    emailVerified: boolean;
+    name: string | null;
+}
+export interface ClerkEnv {
+    CLERK_PUBLISHABLE_KEY?: string;
+    CLERK_SECRET_KEY?: string;
+    CLERK_JWT_KEY?: string;
+    CLERK_AUTHORIZED_PARTIES?: string;
+}
+/** Derives the Clerk Frontend API origin encoded in a publishable key (pk_live_/pk_test_). */
+export declare function clerkFrontendApi(publishableKey: string): string | null;
+export declare function readClerkConfig(env: ClerkEnv, fallbackAuthorizedParty?: string): ClerkConfig | null;
+export declare function looksLikeJwt(token: string): boolean;
+/** Verifies a Clerk session JWT (RS256) and returns the session identity, or null if invalid. */
+export declare function verifyClerkSessionToken(token: string, config: ClerkConfig, nowSeconds?: number): Promise<ClerkSession | null>;
+/** Reads the primary email and name for a Clerk user through the Backend API. */
+export declare function fetchClerkProfile(userId: string, secretKey: string): Promise<ClerkProfile | null>;
+export declare function clerkBrowserScriptUrl(frontendApi: string): string;

package/dist/clerk.js

@@ -0,0 +1,198 @@
+const RS256 = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" };
+const JWKS_TTL_MS = 10 * 60 * 1000;
+const JWKS_RETRY_MS = 30 * 1000;
+const CLOCK_SKEW_SECONDS = 5;
+function base64UrlToBytes(input) {
+    const normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+    const binary = atob(padded);
+    const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+    for (let i = 0; i < binary.length; i++)
+        bytes[i] = binary.charCodeAt(i);
+    return bytes;
+}
+function decodeJsonSegment(segment) {
+    try {
+        const parsed = JSON.parse(new TextDecoder().decode(base64UrlToBytes(segment)));
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Derives the Clerk Frontend API origin encoded in a publishable key (pk_live_/pk_test_). */
+export function clerkFrontendApi(publishableKey) {
+    const match = /^pk_(?:live|test)_([A-Za-z0-9+/=_-]{4,512})$/.exec(publishableKey.trim());
+    if (!match)
+        return null;
+    let decoded;
+    try {
+        decoded = new TextDecoder().decode(base64UrlToBytes(match[1]));
+    }
+    catch {
+        return null;
+    }
+    if (!decoded.endsWith("$"))
+        return null;
+    const host = decoded.slice(0, -1);
+    if (!/^(?=.{4,253}$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/i.test(host))
+        return null;
+    return `https://${host.toLowerCase()}`;
+}
+export function readClerkConfig(env, fallbackAuthorizedParty) {
+    const publishableKey = (env.CLERK_PUBLISHABLE_KEY || "").trim();
+    if (!publishableKey)
+        return null;
+    const frontendApi = clerkFrontendApi(publishableKey);
+    if (!frontendApi)
+        return null;
+    const configured = (env.CLERK_AUTHORIZED_PARTIES || "")
+        .split(",")
+        .map((s) => s.trim().replace(/\/+$/, ""))
+        .filter(Boolean);
+    const authorizedParties = configured.length
+        ? configured
+        : fallbackAuthorizedParty
+            ? [fallbackAuthorizedParty.replace(/\/+$/, "")]
+            : [];
+    return {
+        publishableKey,
+        frontendApi,
+        authorizedParties,
+        jwtKey: (env.CLERK_JWT_KEY || "").trim() || undefined,
+        secretKey: (env.CLERK_SECRET_KEY || "").trim() || undefined,
+    };
+}
+export function looksLikeJwt(token) {
+    return /^eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(token);
+}
+async function importPemKey(pem) {
+    const body = pem
+        .replace(/\\n/g, "\n")
+        .replace(/-----BEGIN PUBLIC KEY-----/, "")
+        .replace(/-----END PUBLIC KEY-----/, "")
+        .replace(/\s+/g, "");
+    return crypto.subtle.importKey("spki", base64UrlToBytes(body), RS256, false, ["verify"]);
+}
+// Only public verification keys are cached; never tokens or user data.
+const jwksCache = new Map();
+const pemCache = new Map();
+async function loadJwks(frontendApi) {
+    const res = await fetch(`${frontendApi}/.well-known/jwks.json`, {
+        headers: { Accept: "application/json" },
+        redirect: "manual",
+    });
+    if (res.status !== 200)
+        throw new Error(`Clerk JWKS unavailable (HTTP ${res.status})`);
+    const doc = (await res.json());
+    const keys = new Map();
+    for (const jwk of doc.keys || []) {
+        if (jwk.kty !== "RSA" || typeof jwk.kid !== "string")
+            continue;
+        if (jwk.use && jwk.use !== "sig")
+            continue;
+        const key = await crypto.subtle.importKey("jwk", { kty: "RSA", n: String(jwk.n), e: String(jwk.e), alg: "RS256", ext: true }, RS256, false, ["verify"]);
+        keys.set(jwk.kid, key);
+    }
+    return keys;
+}
+async function verificationKey(config, kid) {
+    if (config.jwtKey) {
+        let key = pemCache.get(config.jwtKey);
+        if (!key) {
+            key = await importPemKey(config.jwtKey);
+            pemCache.set(config.jwtKey, key);
+        }
+        return key;
+    }
+    if (!kid)
+        return null;
+    const now = Date.now();
+    const cached = jwksCache.get(config.frontendApi);
+    const fresh = cached && now - cached.fetchedAt < JWKS_TTL_MS;
+    if (cached?.keys.has(kid) && fresh)
+        return cached.keys.get(kid);
+    // Refetch for unknown kids (key rotation), but not more than once per retry window.
+    if (!cached || !fresh || now - cached.fetchedAt > JWKS_RETRY_MS) {
+        const keys = await loadJwks(config.frontendApi);
+        jwksCache.set(config.frontendApi, { keys, fetchedAt: now });
+        return keys.get(kid) || null;
+    }
+    return cached.keys.get(kid) || null;
+}
+/** Verifies a Clerk session JWT (RS256) and returns the session identity, or null if invalid. */
+export async function verifyClerkSessionToken(token, config, nowSeconds = Math.floor(Date.now() / 1000)) {
+    if (!looksLikeJwt(token) || token.length > 16_384)
+        return null;
+    const [headerPart, payloadPart, signaturePart] = token.split(".");
+    const header = decodeJsonSegment(headerPart);
+    const payload = decodeJsonSegment(payloadPart);
+    if (!header || !payload || header.alg !== "RS256")
+        return null;
+    let key;
+    try {
+        key = await verificationKey(config, typeof header.kid === "string" ? header.kid : undefined);
+    }
+    catch {
+        return null;
+    }
+    if (!key)
+        return null;
+    let valid = false;
+    try {
+        valid = await crypto.subtle.verify(RS256, key, base64UrlToBytes(signaturePart), new TextEncoder().encode(`${headerPart}.${payloadPart}`));
+    }
+    catch {
+        return null;
+    }
+    if (!valid)
+        return null;
+    if (payload.iss !== config.frontendApi)
+        return null;
+    if (typeof payload.exp !== "number" || payload.exp + CLOCK_SKEW_SECONDS < nowSeconds)
+        return null;
+    if (typeof payload.nbf === "number" && payload.nbf - CLOCK_SKEW_SECONDS > nowSeconds)
+        return null;
+    if (typeof payload.iat === "number" && payload.iat - CLOCK_SKEW_SECONDS > nowSeconds)
+        return null;
+    if (typeof payload.azp === "string" &&
+        config.authorizedParties.length > 0 &&
+        !config.authorizedParties.includes(payload.azp.replace(/\/+$/, ""))) {
+        return null;
+    }
+    if (payload.sts !== undefined && payload.sts !== "active")
+        return null;
+    if (typeof payload.sub !== "string" || !/^user_[A-Za-z0-9]{1,128}$/.test(payload.sub))
+        return null;
+    return {
+        userId: payload.sub,
+        sessionId: typeof payload.sid === "string" ? payload.sid : "",
+        email: typeof payload.email === "string" ? payload.email.toLowerCase() : undefined,
+        emailVerified: payload.email_verified === true,
+    };
+}
+/** Reads the primary email and name for a Clerk user through the Backend API. */
+export async function fetchClerkProfile(userId, secretKey) {
+    try {
+        const res = await fetch(`https://api.clerk.com/v1/users/${encodeURIComponent(userId)}`, {
+            headers: { Authorization: `Bearer ${secretKey}`, Accept: "application/json" },
+        });
+        if (!res.ok)
+            return null;
+        const user = (await res.json());
+        const addresses = user.email_addresses || [];
+        const primary = addresses.find((e) => e.id === user.primary_email_address_id) || addresses[0];
+        const name = [user.first_name, user.last_name].filter(Boolean).join(" ").trim() || user.username || null;
+        return {
+            email: primary?.email_address ? primary.email_address.toLowerCase() : null,
+            emailVerified: primary?.verification?.status === "verified",
+            name,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function clerkBrowserScriptUrl(frontendApi) {
+    return `${frontendApi}/npm/@clerk/clerk-js@5/dist/clerk.browser.js`;
+}