@muxoai/sdk 1.4.2 → 1.4.4

package/dist/server.js

@@ -10,6 +10,7 @@ import { MuxoStore } from "./store.js";
 import { managedProviderConnectionList, managedProviderConnectionRequest, managedProviderConnectionUnlink, managedResource, managedResourceAction, } from "./provisioning-managed.js";
 import { DEFAULT_WORKSPACE_POLICY, describePolicyInPlainEnglish, sanitizePolicyPatch, } from "./policy.js";
 import { parseNaturalLanguageMemoryInstruction } from "./providers/supermemory.js";
+import { getMuxoSkill, listMuxoSkills, renderMuxoSkillMarkdown, } from "./skills-catalog.js";
 import { MUXO_VERSION } from "./version.js";
 import { fetchMuxoConnectLinkMetadata, isStripeProjectsExclusiveProvider, normalizeStripeProjectsProviderSlug, parseComposioWebhookEnvelope, submitMuxoConnectLink, verifyComposioWebhookSignature, wrapMuxoConnectUrl, } from "./composio-catalog.js";
 import { isConsolePath, renderApprovalPageHtml, renderConsoleHtml, renderLandingHtml, renderOAuthCallbackPageHtml, renderOAuthConnectPageHtml, renderOAuthConsentHtml, } from "./ui/console-html.js";
@@ -134,6 +135,16 @@ Teach preferences in plain English and Muxo auto-fills matching tool inputs on e
 - "What do you remember?"
 
 \`plan_action\` recalls workspace memory before governance checks and reports \`memoryContext.autoFilledInput\` plus \`activeDefaults\` so callers can see exactly which parameters were filled from memory.
+
+## Natural-Language Saga Playbooks, Temporal Rollbacks, Cedar, OTel & One-Shot Harness Config
+
+Pass plain English to \`POST /api/v1/do\` or MCP \`get_run_context({ prompt: "..." })\`:
+- **Playbooks**: "Run the fullstack cloud bootstrap playbook", "Create playbook daily-seo-slack that runs instant.seo.audit and app.slack.send_message" (\`GET/POST /api/v1/playbooks\`, \`POST /api/v1/playbooks/:slug/run\`)
+- **Temporal Workflows ("latest" supported)**: "Rollback the latest workflow because staging healthcheck failed", "Show Temporal history for latest workflow" (\`POST /api/v1/workflows/latest/rollback\`, \`GET /api/v1/workflows/latest/history\`)
+- **Time-Travel & BFS Memory Graph**: "Show my knowledge graph as of 2026-10-20T00:00:00Z within 2 hops of workspace" (\`GET /api/v1/memory/graph?as_of=...&focal_entity=...&max_hops=2\`)
+- **AWS Cedar 4.0 & OPA Rego v1**: "Compile our guardrails to AWS Cedar", "Evaluate Cedar policy for resource.turso.database with DROP TABLE users" (\`GET /api/v1/governance/cedar\`, \`POST /api/v1/governance/cedar/evaluate\`)
+- **OTel GenAI & FinOps ROI**: "Export OpenTelemetry traces", "What is our ROI and engineering hours saved?" (\`GET /api/v1/telemetry/otlp\`, \`GET /api/v1/analytics/roi\`)
+- **One-Shot Harness Configurator**: "Configure harness preset strict-production" (\`GET/POST /api/v1/harness/configure\`, presets: \`startup-builder\`, \`strict-production\`, \`read-only-auditor\`, \`finops-byok-zero-cost\`).
 `;
 }
 async function readBody(req) {
@@ -825,6 +836,22 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 res.end(renderSkillMarkdown(config.baseUrl));
                 return;
             }
+            const publicSkillMatch = pathname.match(/^\/skills\/([^/]+?)(?:\/SKILL\.md|\.md)$/i);
+            if (publicSkillMatch && req.method === "GET") {
+                const slug = decodeURIComponent(publicSkillMatch[1]);
+                const md = renderMuxoSkillMarkdown(slug, config.baseUrl);
+                if (!md) {
+                    sendJson(res, 404, {
+                        ok: false,
+                        code: "SKILL_NOT_FOUND",
+                        error: `Skill not found: ${slug}`,
+                    });
+                    return;
+                }
+                res.writeHead(200, { "Content-Type": "text/markdown; charset=utf-8" });
+                res.end(md);
+                return;
+            }
             if (pathname === "/llms.txt" && req.method === "GET") {
                 res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
                 res.end(`# Muxo\n> Unified agent execution across Connected Apps, Instant Tools, Cloud Infrastructure, Workspace Memory, and Safety Guardrails.\n\n- Skill Document: ${config.baseUrl}/skill.md\n- Auth Guide: ${config.baseUrl}/auth.md\n- OpenAPI 3.1 Spec: ${config.baseUrl}/api/openapi.json\n- MCP Endpoint: ${config.baseUrl}/mcp\n- OAuth Callback Handoff: ${config.baseUrl}/oauth/callback\n- Plugin Marketplace (Codex/OpenAI): ${config.baseUrl}/.agents/plugins/marketplace.json\n- Plugin Marketplace (Claude/Droid): ${config.baseUrl}/.claude-plugin/marketplace.json\n- Console (app.muxo.ai): ${config.baseUrl}/\n- Landing & Provider Canvas (muxo.ai): ${config.baseUrl}/landing\n- Documentation (docs.muxo.ai): ${config.docsUrl}\n\n## Agent-Native Policy, Context & Governance Interface\n- MCP Control Plane (\`get_run_context\`): \`action: "recall" | "remember" | "forget" | "set_guardrail" | "reset_guardrails" | "check_policy" | "governance_status" | "kill_switch" | "scan_context"\`\n- Strict /v1 Organization Brief: \`get_organization({ company_context: { required: false } })\` returns accepted workspace policy facts + learned defaults in \`company_context.packet\`\n- Dry-Run Policy Simulator: \`POST ${config.baseUrl}/api/v1/guardrails/check\` (\`{ "tool_slug": "...", "input": { ... } }\`) or MCP \`get_run_context({ action: "check_policy", tool_slug, input })\`\n- Guardrails & Policy Brief: \`GET/POST ${config.baseUrl}/api/v1/guardrails\`, \`POST ${config.baseUrl}/api/v1/guardrails/reset\`, \`GET ${config.baseUrl}/api/v1/governance\` (includes \`llmPolicyBrief\`)\n- MCP Resources: \`muxo://policy/brief\`, \`muxo://governance/policy\`, \`muxo://context\`, \`muxo://memory/graph\`\n- MCP Prompts: \`context\`, \`policy_guardrails\`, \`governed_execution\`, \`security_audit\`\n`);
@@ -1948,11 +1975,35 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 });
                 return;
             }
-            if (pathname === "/api/v1/memory/graph" && req.method === "GET") {
+            if (pathname === "/api/v1/memory/graph" &&
+                (req.method === "GET" || req.method === "POST")) {
+                const body = req.method === "POST"
+                    ? JSON.parse((await readBody(req)) || "{}")
+                    : {};
                 const query = url.searchParams.get("query") ||
                     url.searchParams.get("q") ||
-                    undefined;
-                const graph = await engine.getMemoryGraph(ctx, query);
+                    (body.query ? String(body.query) : undefined);
+                const asOf = url.searchParams.get("as_of") ||
+                    url.searchParams.get("asOf") ||
+                    (body.as_of || body.asOf ? String(body.as_of || body.asOf) : null);
+                const focalEntity = url.searchParams.get("focal_entity") ||
+                    url.searchParams.get("focalEntity") ||
+                    (body.focal_entity || body.focalEntity
+                        ? String(body.focal_entity || body.focalEntity)
+                        : null);
+                const rawMaxHops = url.searchParams.get("max_hops") ??
+                    url.searchParams.get("maxHops") ??
+                    body.max_hops ??
+                    body.maxHops;
+                const maxHops = rawMaxHops !== undefined && rawMaxHops !== null && rawMaxHops !== ""
+                    ? Number(rawMaxHops)
+                    : undefined;
+                const graph = await engine.getMemoryGraph(ctx, {
+                    query,
+                    asOf,
+                    focalEntity,
+                    maxHops,
+                });
                 sendJson(res, 200, { ok: true, ...graph });
                 return;
             }
@@ -2990,6 +3041,13 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 sendJson(res, 200, cancelled);
                 return;
             }
+            const runReconcileMatch = pathname.match(/^\/api\/v1\/runs\/([^/]+)\/reconcile$/);
+            if (runReconcileMatch && (req.method === "GET" || req.method === "POST")) {
+                const runOrPlanId = decodeURIComponent(runReconcileMatch[1]);
+                const report = engine.reconcileRun(ctx, runOrPlanId);
+                sendJson(res, 200, report);
+                return;
+            }
             const runGetMatch = pathname.match(/^\/api\/v1\/runs\/([^/]+)$/);
             if (runGetMatch && req.method === "GET") {
                 const runId = decodeURIComponent(runGetMatch[1]);
@@ -3543,6 +3601,176 @@ Users purchase Muxo Credits (\`POST /api/v1/billing/topup\` or \`muxo billing to
                 sendJson(res, 200, { ok: true, workflow });
                 return;
             }
+            const wfHistoryMatch = pathname.match(/^\/api\/v1\/workflows\/([^/]+)\/history$/);
+            if (wfHistoryMatch && req.method === "GET") {
+                const wfId = decodeURIComponent(wfHistoryMatch[1]);
+                const history = engine.getDurableWorkflowHistory(ctx, wfId);
+                sendJson(res, 200, { ok: true, ...history });
+                return;
+            }
+            const wfSignalMatch = pathname.match(/^\/api\/v1\/workflows\/([^/]+)\/signal$/);
+            if (wfSignalMatch && req.method === "POST") {
+                const wfId = decodeURIComponent(wfSignalMatch[1]);
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const signalName = String(body.signalName || body.signal_name || body.name || "workflow.signal");
+                const workflow = engine.signalDurableWorkflow(ctx, wfId, {
+                    signalName,
+                    payload: body.payload && typeof body.payload === "object"
+                        ? body.payload
+                        : body,
+                });
+                sendJson(res, 200, { ok: true, workflow });
+                return;
+            }
+            const wfRollbackMatch = pathname.match(/^\/api\/v1\/workflows\/([^/]+)\/rollback$/);
+            if (wfRollbackMatch && req.method === "POST") {
+                const wfId = decodeURIComponent(wfRollbackMatch[1]);
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const workflow = engine.rollbackDurableWorkflow(ctx, wfId, {
+                    reason: body.reason ? String(body.reason) : undefined,
+                    failedStep: body.failedStep || body.failed_step
+                        ? String(body.failedStep || body.failed_step)
+                        : undefined,
+                });
+                sendJson(res, 200, { ok: true, workflow });
+                return;
+            }
+            if ((pathname === "/api/v1/governance/cedar" ||
+                pathname === "/api/v1/policy/cedar") &&
+                req.method === "GET") {
+                const bundle = engine.getPolicyAsCodeBundle(ctx);
+                sendJson(res, 200, { ok: true, ...bundle });
+                return;
+            }
+            if ((pathname === "/api/v1/governance/cedar/evaluate" ||
+                pathname === "/api/v1/policy/cedar/evaluate") &&
+                req.method === "POST") {
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const evaluated = await engine.evaluatePolicyAsCode(ctx, {
+                    toolSlug: String(body.toolSlug || body.tool_slug || body.action || "instant.web.search"),
+                    input: body.input && typeof body.input === "object"
+                        ? body.input
+                        : {},
+                    riskLevel: (body.riskLevel || body.risk_level),
+                    creditCost: typeof body.creditCost === "number"
+                        ? body.creditCost
+                        : typeof body.credit_cost === "number"
+                            ? body.credit_cost
+                            : undefined,
+                    lane: body.lane ? String(body.lane) : undefined,
+                });
+                sendJson(res, 200, { ok: true, ...evaluated });
+                return;
+            }
+            if ((pathname === "/api/v1/telemetry/otlp" ||
+                pathname === "/api/v1/governance/telemetry") &&
+                req.method === "GET") {
+                const limit = Number(url.searchParams.get("limit") || 25);
+                const otel = engine.exportOtelTraces(ctx, limit);
+                sendJson(res, 200, { ok: true, ...otel });
+                return;
+            }
+            if (pathname === "/api/v1/skills" && req.method === "GET") {
+                const category = url.searchParams.get("category") || undefined;
+                const provider = url.searchParams.get("provider") || undefined;
+                const query = url.searchParams.get("q") ||
+                    url.searchParams.get("query") ||
+                    undefined;
+                const skills = listMuxoSkills({ category, provider, query }, config.baseUrl);
+                sendJson(res, 200, {
+                    ok: true,
+                    count: skills.length,
+                    skills,
+                });
+                return;
+            }
+            const apiSkillMatch = pathname.match(/^\/api\/v1\/skills\/([^/]+)$/);
+            if (apiSkillMatch && req.method === "GET") {
+                const slug = decodeURIComponent(apiSkillMatch[1]).replace(/\.md$/i, "");
+                const skill = getMuxoSkill(slug, config.baseUrl);
+                const markdown = renderMuxoSkillMarkdown(slug, config.baseUrl);
+                if (!skill || !markdown) {
+                    sendJson(res, 404, {
+                        ok: false,
+                        code: "SKILL_NOT_FOUND",
+                        error: `Skill not found: ${slug}`,
+                    });
+                    return;
+                }
+                sendJson(res, 200, {
+                    ok: true,
+                    skill,
+                    markdown,
+                    skillUrl: `${config.baseUrl}/skills/${skill.slug}/SKILL.md`,
+                    mcpResourceUri: `muxo://skills/${skill.slug}`,
+                });
+                return;
+            }
+            if (pathname === "/api/v1/playbooks" && req.method === "GET") {
+                const playbooks = engine.listCommercialPlaybooks(ctx);
+                sendJson(res, 200, {
+                    ok: true,
+                    count: playbooks.length,
+                    playbooks,
+                });
+                return;
+            }
+            if (pathname === "/api/v1/playbooks" && req.method === "POST") {
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const created = engine.createCustomPlaybook(ctx, {
+                    prompt: body.prompt || body.instruction || body.description || "",
+                    input: body,
+                });
+                sendJson(res, 201, created);
+                return;
+            }
+            const playbookRunMatch = pathname.match(/^\/api\/v1\/playbooks\/([^/]+)\/run$/);
+            if ((playbookRunMatch || pathname === "/api/v1/playbooks/run") &&
+                req.method === "POST") {
+                const body = JSON.parse((await readBody(req)) || "{}");
+                const slug = playbookRunMatch
+                    ? decodeURIComponent(playbookRunMatch[1])
+                    : String(body.slug || body.playbook || body.prompt || "");
+                const result = engine.runCommercialPlaybook(ctx, {
+                    slug,
+                    input: body.input && typeof body.input === "object"
+                        ? body.input
+                        : body,
+                });
+                sendJson(res, 201, result);
+                return;
+            }
+            if ((pathname === "/api/v1/harness/configure" ||
+                pathname === "/api/v1/harness/presets") &&
+                (req.method === "GET" || req.method === "POST")) {
+                const body = req.method === "POST"
+                    ? JSON.parse((await readBody(req)) || "{}")
+                    : {};
+                const preset = body.preset ||
+                    url.searchParams.get("preset") ||
+                    null;
+                const harness = body.harness ||
+                    url.searchParams.get("harness") ||
+                    null;
+                const prompt = body.prompt ||
+                    body.instruction ||
+                    url.searchParams.get("prompt") ||
+                    null;
+                const configured = await engine.configureHarness(ctx, {
+                    preset: preset ? String(preset) : null,
+                    harness: harness ? String(harness) : null,
+                    prompt: prompt ? String(prompt) : null,
+                });
+                sendJson(res, 200, configured);
+                return;
+            }
+            if ((pathname === "/api/v1/analytics/roi" ||
+                pathname === "/api/v1/billing/roi") &&
+                req.method === "GET") {
+                const roi = engine.getCommercialRoiReport(ctx);
+                sendJson(res, 200, { ok: true, ...roi });
+                return;
+            }
             if (pathname === "/api/v1/governance/archive" && req.method === "GET") {
                 const archive = engine.exportTamperEvidentArchive(ctx.workspace.id);
                 sendJson(res, 200, { ok: true, ...archive });

package/dist/skills-catalog.d.ts

@@ -0,0 +1,66 @@
+export type MuxoSkillCategory = "governance" | "app_automation" | "cloud_infrastructure" | "workflow";
+export interface MuxoSkillDefinition {
+    slug: string;
+    name: string;
+    title: string;
+    description: string;
+    category: MuxoSkillCategory;
+    lane: "composio_sdk" | "stripe_projects" | "composio_instant" | "hybrid";
+    providerSlug: string;
+    providerName: string;
+    requiresMcp: string[];
+    mcpServerUrl: string;
+    recommendedTools: string[];
+    workflowSteps: string[];
+    pitfalls: string[];
+    stripeProjectsOverride?: {
+        enforced: boolean;
+        canonicalToolSlug: string;
+        reason: string;
+    };
+    sourceRepo: string;
+}
+export interface MuxoMcpSkillBundle {
+    name: string;
+    description: string;
+    version: string;
+    uri: string;
+    frontmatter: {
+        name: string;
+        description: string;
+    };
+    content: string;
+    files: Array<{
+        path: string;
+        uri: string;
+        mimeType: string;
+        content: string;
+    }>;
+}
+export declare function transpileAwesomeClaudeSkillToMuxo(rawMarkdown: string, baseUrl?: string): string;
+export declare function listMuxoSkills(filter?: {
+    category?: string;
+    provider?: string;
+    query?: string;
+}, baseUrl?: string): MuxoSkillDefinition[];
+export declare function getMuxoSkill(slug: string, baseUrl?: string): MuxoSkillDefinition | null;
+export declare function renderMuxoSkillMarkdown(slug: string, baseUrl?: string): string | null;
+export interface MuxoDomainSkillHint {
+    slug: string;
+    title: string;
+    category: MuxoSkillCategory;
+    lane: string;
+    mcpResourceUri: string;
+    skillUrl: string;
+    recommendedTools: string[];
+    pitfalls: string[];
+    stripeProjectsOverride?: {
+        enforced: boolean;
+        canonicalToolSlug: string;
+        reason: string;
+    };
+}
+export declare function getProviderSkillHint(toolOrProviderSlug: string, baseUrl?: string): MuxoDomainSkillHint | null;
+export declare function buildMuxoMcpSkillBundles(baseUrl?: string, options?: {
+    includeAll?: boolean;
+}): MuxoMcpSkillBundle[];