@muxoai/sdk 1.3.0 → 1.4.3

package/dist/config.d.ts

@@ -1,11 +1,23 @@
+import type { ClerkEnv } from "./clerk.js";
 export declare const ROOT_DIR: string;
 export interface MuxoConfig {
     port: number;
     baseUrl: string;
     dbPath: string;
     composioApiKey: string;
+    composioInstantApiKey: string;
     composioBaseUrl: string;
+    composioWebhookSecret: string;
+    composioWebhookSubscriptionId: string;
+    composioProjectId: string;
+    composioOrgId: string;
+    composioUserId: string;
     stripeSecretKey: string;
+    stripePublishableKey: string;
+    stripeApiBaseUrl: string;
+    stripeProvisioningApiVersion: string;
+    stripeProjectId: string;
+    stripeConnectedAccountId?: string;
     stripeStarterPriceId: string;
     stripeCreditsPriceId: string;
     stripeWebhookSecret: string;
@@ -16,5 +28,9 @@ export interface MuxoConfig {
     publicWebUrl: string;
     docsUrl: string;
     vaultMasterKey: Buffer;
+    /** Clerk sign-in settings; sign-in stays password-based unless CLERK_PUBLISHABLE_KEY is set. */
+    clerkEnv?: ClerkEnv & {
+        MUXO_OWNER_EMAILS?: string;
+    };
 }
 export declare function getConfig(): MuxoConfig;

package/dist/config.js

@@ -65,11 +65,30 @@ export function getConfig() {
         dbPath: process.env.MUXO_DB_PATH || path.join(dataDir, "muxo.db"),
         composioApiKey: process.env.MUXO_EXTERNAL_MODE === "1"
             ? ""
-            : process.env.COMPOSIO_API_KEY || "",
+            : process.env.COMPOSIO_API_KEY || process.env.COMPOSIO_INSTANT_API_KEY || "",
+        composioInstantApiKey: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? ""
+            : process.env.COMPOSIO_INSTANT_API_KEY || process.env.COMPOSIO_API_KEY || "",
         composioBaseUrl: process.env.COMPOSIO_BASE_URL || "https://backend.composio.dev/api/v3",
+        composioWebhookSecret: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? ""
+            : process.env.COMPOSIO_WEBHOOK_SECRET || "",
+        composioWebhookSubscriptionId: process.env.COMPOSIO_WEBHOOK_SUBSCRIPTION_ID || "",
+        composioProjectId: process.env.COMPOSIO_PROJECT_ID || "",
+        composioOrgId: process.env.COMPOSIO_ORG_ID || "",
+        composioUserId: process.env.COMPOSIO_USER_ID || "",
         stripeSecretKey: process.env.MUXO_EXTERNAL_MODE === "1"
             ? ""
             : process.env.STRIPE_SECRET_KEY || "",
+        stripePublishableKey: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? ""
+            : process.env.STRIPE_PUBLISHABLE_KEY || "",
+        stripeApiBaseUrl: process.env.STRIPE_API_BASE_URL || "https://api.stripe.com",
+        stripeProvisioningApiVersion: process.env.STRIPE_PROVISIONING_API_VERSION || "2026-09-30.preview",
+        stripeProjectId: process.env.STRIPE_PROJECT_ID || "",
+        stripeConnectedAccountId: process.env.STRIPE_CONNECTED_ACCOUNT_ID ||
+            process.env.STRIPE_CONTEXT ||
+            "",
         stripeStarterPriceId: process.env.STRIPE_STARTER_PRICE_ID || "",
         stripeCreditsPriceId: process.env.STRIPE_CREDITS_PRICE_ID || "",
         stripeWebhookSecret: process.env.STRIPE_WEBHOOK_SECRET || "",
@@ -85,5 +104,12 @@ export function getConfig() {
         publicWebUrl: process.env.MUXO_PUBLIC_WEB_URL || "https://muxo.ai",
         docsUrl: process.env.MUXO_DOCS_URL || "https://docs.muxo.ai",
         vaultMasterKey: deriveVaultMasterKey(),
+        clerkEnv: {
+            CLERK_PUBLISHABLE_KEY: process.env.CLERK_PUBLISHABLE_KEY,
+            CLERK_SECRET_KEY: process.env.CLERK_SECRET_KEY,
+            CLERK_JWT_KEY: process.env.CLERK_JWT_KEY,
+            CLERK_AUTHORIZED_PARTIES: process.env.CLERK_AUTHORIZED_PARTIES,
+            MUXO_OWNER_EMAILS: process.env.MUXO_OWNER_EMAILS,
+        },
     };
 }

package/dist/durable-workflow.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Temporal-compatible Durable Workflows, Saga Compensations, Signals, and Cloudflare Workflows primitives,
+ * shared by the Node engine (src/engine.ts) and the Cloudflare Edge Worker (worker/index.ts).
+ */
+import { MuxoToolError } from "./mcp-schema.js";
+export type DurableWorkflowStepStatus = "completed" | "waiting" | "pending" | "failed" | "compensated";
+export interface DurableWorkflowStep {
+    name: string;
+    primitive: "step.do" | "step.waitForEvent" | "step.sleep";
+    status: DurableWorkflowStepStatus;
+    output?: Record<string, unknown>;
+    completedAt?: string;
+    compensationAction?: string;
+    compensatedAt?: string;
+}
+export type TemporalEventType = "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED" | "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED" | "EVENT_TYPE_ACTIVITY_TASK_COMPLETED" | "EVENT_TYPE_ACTIVITY_TASK_FAILED" | "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED" | "EVENT_TYPE_TIMER_STARTED" | "EVENT_TYPE_TIMER_FIRED" | "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED" | "EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED" | "EVENT_TYPE_WORKFLOW_EXECUTION_FAILED";
+export interface TemporalHistoryEvent {
+    eventId: number;
+    eventTime: string;
+    eventType: TemporalEventType;
+    taskQueue: string;
+    attributes: Record<string, unknown>;
+}
+export interface SagaCompensationRecord {
+    stepName: string;
+    compensationAction: string;
+    status: "registered" | "executed" | "skipped";
+    description: string;
+    output?: Record<string, unknown>;
+    executedAt?: string;
+}
+export interface DurableWorkflowSignalRecord {
+    signalName: string;
+    payload: Record<string, unknown>;
+    receivedAt: string;
+}
+export interface DurableWorkflow {
+    id: string;
+    runId?: string;
+    workspaceId: string;
+    workflowType: "cloud_provisioning_pipeline" | "approval_handoff_pipeline" | "commercial_playbook_saga";
+    playbookSlug?: string | null;
+    status: "running" | "waiting_for_event" | "completed" | "failed" | "rolled_back";
+    provider: string;
+    serviceRef: string;
+    resourceId: string | null;
+    steps: DurableWorkflowStep[];
+    compensations?: SagaCompensationRecord[];
+    signals?: DurableWorkflowSignalRecord[];
+    temporalEventHistory?: TemporalHistoryEvent[];
+    rollbackReason?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare const WORKFLOW_RESOURCE_COMPLETED_EVENT = "v2.provisioning.resource.completed";
+export declare function workflowNotFoundError(workflowId: string): MuxoToolError;
+export declare function normalizeWorkflowTarget(params: {
+    provider?: string;
+    serviceRef?: string;
+}): {
+    provider: string;
+    serviceRef: string;
+};
+export declare function createCloudProvisioningWorkflow(params: {
+    id: string;
+    workspaceId: string;
+    resourceId: string;
+    provider: string;
+    serviceRef: string;
+    region?: string;
+    apiVersion?: string;
+}): DurableWorkflow;
+/** Completes every outstanding step once the resource-completed event (or a manual advance) arrives. */
+export declare function completeCloudProvisioningWorkflow(wf: DurableWorkflow, params: {
+    secretKeys: string[];
+    triggerEvent?: unknown;
+}): DurableWorkflow;
+/**
+ * Executes LIFO Saga Compensations on a DurableWorkflow, rolling back completed steps in reverse order
+ * and recording Temporal compensation activity events.
+ */
+export declare function rollbackDurableWorkflow(wf: DurableWorkflow, params?: {
+    reason?: string;
+    failedStepName?: string;
+    failedStep?: string;
+}): DurableWorkflow;
+/**
+ * Sends a named Temporal signal to a DurableWorkflow (`human.approval.granted`, `oauth.connection.active`,
+ * `saga.abort`, or `v2.provisioning.resource.completed`).
+ */
+export declare function signalDurableWorkflow(wf: DurableWorkflow, params: {
+    signalName: string;
+    payload?: Record<string, unknown>;
+    secretKeys?: string[];
+}): DurableWorkflow;
+/**
+ * Exports a DurableWorkflow in Temporal Web UI / `temporal workflow show` compatible EventHistory JSON format.
+ */
+export declare function exportTemporalEventHistory(wf: DurableWorkflow): {
+    namespace: string;
+    workflowExecution: {
+        workflowId: string;
+        runId: string;
+    };
+    workflowType: {
+        name: string;
+    };
+    status: DurableWorkflow["status"];
+    eventsCount: number;
+    compensationsCount: number;
+    events: TemporalHistoryEvent[];
+};

package/dist/durable-workflow.js

@@ -0,0 +1,284 @@
+/**
+ * Temporal-compatible Durable Workflows, Saga Compensations, Signals, and Cloudflare Workflows primitives,
+ * shared by the Node engine (src/engine.ts) and the Cloudflare Edge Worker (worker/index.ts).
+ */
+import { MuxoToolError } from "./mcp-schema.js";
+export const WORKFLOW_RESOURCE_COMPLETED_EVENT = "v2.provisioning.resource.completed";
+export function workflowNotFoundError(workflowId) {
+    return new MuxoToolError(`Durable workflow not found: ${workflowId}`, {
+        code: "workflow_not_found",
+        statusCode: 404,
+        payload: { workflowId },
+    });
+}
+export function normalizeWorkflowTarget(params) {
+    return {
+        provider: (params.provider || "neon").toLowerCase().trim(),
+        serviceRef: (params.serviceRef || "postgres").toLowerCase().trim(),
+    };
+}
+function appendTemporalEvent(history, eventType, attributes, now = new Date().toISOString()) {
+    history.push({
+        eventId: history.length + 1,
+        eventTime: now,
+        eventType,
+        taskQueue: "muxo-durable-execution-queue",
+        attributes,
+    });
+}
+export function createCloudProvisioningWorkflow(params) {
+    const now = new Date().toISOString();
+    const region = params.region || "aws-us-east-1";
+    const apiVersion = params.apiVersion || "2026-09-30.preview";
+    const history = [];
+    appendTemporalEvent(history, "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", {
+        workflowType: "cloud_provisioning_pipeline",
+        workflowId: params.id,
+        workspaceId: params.workspaceId,
+        provider: params.provider,
+        serviceRef: params.serviceRef,
+        region,
+    }, now);
+    appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+        activityName: "check_stripe_v2_eligibility",
+        result: { status: "eligible", apiVersion },
+    }, now);
+    appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+        activityName: "ensure_payment_profile_and_provider_connection",
+        result: { provider: params.provider, paymentProfileStatus: "active" },
+    }, now);
+    appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+        activityName: "create_v2_provisioning_resource",
+        result: {
+            resourceId: params.resourceId,
+            provider: params.provider,
+            service_ref: params.serviceRef,
+            region,
+        },
+        compensationAction: `resource.${params.provider}.remove`,
+    }, now);
+    appendTemporalEvent(history, "EVENT_TYPE_TIMER_STARTED", {
+        waitingForSignal: WORKFLOW_RESOURCE_COMPLETED_EVENT,
+        resourceId: params.resourceId,
+    }, now);
+    const compensations = [
+        {
+            stepName: "ensure_payment_profile_and_provider_connection",
+            compensationAction: `provisioning.provider_connection.unlink`,
+            status: "registered",
+            description: `Unlink provider connection for ${params.provider} if downstream provisioning aborts`,
+        },
+        {
+            stepName: "create_v2_provisioning_resource",
+            compensationAction: `resource.${params.provider}.remove`,
+            status: "registered",
+            description: `Deprovision ${params.provider}/${params.serviceRef} (${params.resourceId}) and release reservation`,
+        },
+    ];
+    return {
+        id: params.id,
+        runId: `run_${params.id}`,
+        workspaceId: params.workspaceId,
+        workflowType: "cloud_provisioning_pipeline",
+        playbookSlug: null,
+        status: "waiting_for_event",
+        provider: params.provider,
+        serviceRef: params.serviceRef,
+        resourceId: params.resourceId,
+        steps: [
+            {
+                name: "check_stripe_v2_eligibility",
+                primitive: "step.do",
+                status: "completed",
+                output: { status: "eligible", apiVersion },
+                completedAt: now,
+            },
+            {
+                name: "ensure_payment_profile_and_provider_connection",
+                primitive: "step.do",
+                status: "completed",
+                output: { provider: params.provider, paymentProfileStatus: "active" },
+                completedAt: now,
+                compensationAction: "provisioning.provider_connection.unlink",
+            },
+            {
+                name: "create_v2_provisioning_resource",
+                primitive: "step.do",
+                status: "completed",
+                output: {
+                    resourceId: params.resourceId,
+                    provider: params.provider,
+                    service_ref: params.serviceRef,
+                    region,
+                },
+                completedAt: now,
+                compensationAction: `resource.${params.provider}.remove`,
+            },
+            {
+                name: "wait_for_v2_provisioning_resource_completed",
+                primitive: "step.waitForEvent",
+                status: "waiting",
+                output: {
+                    expectedEvent: WORKFLOW_RESOURCE_COMPLETED_EVENT,
+                    resourceId: params.resourceId,
+                },
+            },
+            {
+                name: "reveal_access_configuration_and_seal_vault",
+                primitive: "step.do",
+                status: "pending",
+                compensationAction: "vault.revoke_secrets",
+            },
+        ],
+        compensations,
+        signals: [],
+        temporalEventHistory: history,
+        rollbackReason: null,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+/** Completes every outstanding step once the resource-completed event (or a manual advance) arrives. */
+export function completeCloudProvisioningWorkflow(wf, params) {
+    const now = new Date().toISOString();
+    const history = wf.temporalEventHistory || [];
+    const trigger = String(params.triggerEvent || WORKFLOW_RESOURCE_COMPLETED_EVENT);
+    appendTemporalEvent(history, "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", {
+        signalName: trigger,
+        resourceId: wf.resourceId,
+    }, now);
+    for (const step of wf.steps) {
+        if (step.status === "completed")
+            continue;
+        step.status = "completed";
+        step.completedAt = now;
+        if (step.name === "reveal_access_configuration_and_seal_vault") {
+            step.output = {
+                vaultEncrypted: true,
+                cipher: "AES-256-GCM",
+                secretKeys: params.secretKeys,
+                triggerEvent: trigger,
+            };
+        }
+        appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+            activityName: step.name,
+            result: step.output || { status: "completed" },
+        }, now);
+    }
+    appendTemporalEvent(history, "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", {
+        workflowId: wf.id,
+        status: "completed",
+        secretKeysSealed: params.secretKeys,
+    }, now);
+    wf.temporalEventHistory = history;
+    wf.status = "completed";
+    wf.updatedAt = now;
+    return wf;
+}
+/**
+ * Executes LIFO Saga Compensations on a DurableWorkflow, rolling back completed steps in reverse order
+ * and recording Temporal compensation activity events.
+ */
+export function rollbackDurableWorkflow(wf, params) {
+    const now = new Date().toISOString();
+    const failedStepName = params?.failedStepName || params?.failedStep;
+    const reason = params?.reason ||
+        "Saga rollback requested by operator or downstream step failure";
+    const history = wf.temporalEventHistory || [];
+    const compensations = wf.compensations || [];
+    if (failedStepName) {
+        appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_FAILED", {
+            activityName: failedStepName,
+            reason,
+        }, now);
+    }
+    // Execute registered compensations in reverse (LIFO) order
+    for (let i = compensations.length - 1; i >= 0; i--) {
+        const comp = compensations[i];
+        if (comp.status === "executed")
+            continue;
+        comp.status = "executed";
+        comp.executedAt = now;
+        comp.output = {
+            rolledBack: true,
+            action: comp.compensationAction,
+            resourceId: wf.resourceId,
+            reason,
+        };
+        appendTemporalEvent(history, "EVENT_TYPE_ACTIVITY_TASK_COMPLETED", {
+            activityName: `compensate:${comp.stepName}`,
+            compensationAction: comp.compensationAction,
+            result: comp.output,
+        }, now);
+    }
+    for (const step of wf.steps) {
+        if (step.status === "completed" && step.compensationAction) {
+            step.status = "compensated";
+            step.compensatedAt = now;
+        }
+        else if (step.status === "waiting" || step.status === "pending") {
+            step.status = "failed";
+        }
+    }
+    appendTemporalEvent(history, "EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED", {
+        workflowId: wf.id,
+        status: "rolled_back",
+        reason,
+        compensatedStepsCount: compensations.filter((c) => c.status === "executed")
+            .length,
+    }, now);
+    wf.compensations = compensations;
+    wf.temporalEventHistory = history;
+    wf.rollbackReason = reason;
+    wf.status = "rolled_back";
+    wf.updatedAt = now;
+    return wf;
+}
+/**
+ * Sends a named Temporal signal to a DurableWorkflow (`human.approval.granted`, `oauth.connection.active`,
+ * `saga.abort`, or `v2.provisioning.resource.completed`).
+ */
+export function signalDurableWorkflow(wf, params) {
+    const now = new Date().toISOString();
+    const signalName = String(params.signalName || WORKFLOW_RESOURCE_COMPLETED_EVENT).trim();
+    const payload = params.payload || {};
+    wf.signals = wf.signals || [];
+    wf.signals.push({
+        signalName,
+        payload,
+        receivedAt: now,
+    });
+    if (signalName === "saga.abort" ||
+        signalName === "human.approval.rejected" ||
+        payload.action === "rollback") {
+        return rollbackDurableWorkflow(wf, {
+            reason: String(payload.reason || `Rolled back via signal ${signalName}`),
+        });
+    }
+    return completeCloudProvisioningWorkflow(wf, {
+        secretKeys: params.secretKeys || ["DATABASE_URL"],
+        triggerEvent: signalName,
+    });
+}
+/**
+ * Exports a DurableWorkflow in Temporal Web UI / `temporal workflow show` compatible EventHistory JSON format.
+ */
+export function exportTemporalEventHistory(wf) {
+    const events = wf.temporalEventHistory || [];
+    return {
+        namespace: `muxo.${wf.workspaceId}`,
+        workflowExecution: {
+            workflowId: wf.id,
+            runId: wf.runId || `run_${wf.id}`,
+        },
+        workflowType: {
+            name: wf.playbookSlug
+                ? `MuxoPlaybookSaga::${wf.playbookSlug}`
+                : `MuxoWorkflow::${wf.workflowType}`,
+        },
+        status: wf.status,
+        eventsCount: events.length,
+        compensationsCount: (wf.compensations || []).length,
+        events,
+    };
+}