@muxoai/sdk 1.2.2 → 1.3.0

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+export declare const ROOT_DIR: string;
+export interface MuxoConfig {
+    port: number;
+    baseUrl: string;
+    dbPath: string;
+    composioApiKey: string;
+    composioBaseUrl: string;
+    stripeSecretKey: string;
+    stripeStarterPriceId: string;
+    stripeCreditsPriceId: string;
+    stripeWebhookSecret: string;
+    stripeProjectsWorkdir: string;
+    stripeBinaryPath: string;
+    supermemoryApiKey: string;
+    supermemoryBaseUrl: string;
+    publicWebUrl: string;
+    docsUrl: string;
+    vaultMasterKey: Buffer;
+}
+export declare function getConfig(): MuxoConfig;

package/dist/config.js

@@ -0,0 +1,89 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const ROOT_DIR = path.resolve(__dirname, "..");
+function loadDotEnv(envPath) {
+    if (!fs.existsSync(envPath))
+        return;
+    const raw = fs.readFileSync(envPath, "utf8");
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx <= 0)
+            continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const val = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+        if (process.env[key] === undefined || process.env[key] === "") {
+            process.env[key] = val;
+        }
+    }
+}
+if (process.env.MUXO_EXTERNAL_MODE !== "1") {
+    loadDotEnv(path.join(ROOT_DIR, ".env"));
+}
+function resolveStripeBinary() {
+    const candidates = [
+        process.env.STRIPE_BINARY_PATH,
+        "/Users/test/.local/bin/stripe",
+        "/opt/homebrew/bin/stripe",
+        "/usr/local/bin/stripe",
+        "stripe",
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+        if (candidate === "stripe" || fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return "stripe";
+}
+function deriveVaultMasterKey() {
+    const seed = process.env.MUXO_VAULT_SECRET ||
+        process.env.COMPOSIO_API_KEY ||
+        "muxo-local-vault-default-seed-v1";
+    return crypto.scryptSync(seed, "muxo-aes256gcm-salt-v1", 32);
+}
+export function getConfig() {
+    const port = Number(process.env.PORT || 4310);
+    const isExternalPackage = process.env.MUXO_EXTERNAL_MODE === "1" ||
+        !fs.existsSync(path.join(ROOT_DIR, "src", "server.ts"));
+    const dataDir = process.env.MUXO_HOME
+        ? path.join(process.env.MUXO_HOME, "data")
+        : isExternalPackage
+            ? path.join(os.homedir(), ".muxo", "data")
+            : path.join(ROOT_DIR, "data");
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+    return {
+        port,
+        baseUrl: process.env.MUXO_BASE_URL || `http://localhost:${port}`,
+        dbPath: process.env.MUXO_DB_PATH || path.join(dataDir, "muxo.db"),
+        composioApiKey: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? ""
+            : process.env.COMPOSIO_API_KEY || "",
+        composioBaseUrl: process.env.COMPOSIO_BASE_URL || "https://backend.composio.dev/api/v3",
+        stripeSecretKey: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? ""
+            : process.env.STRIPE_SECRET_KEY || "",
+        stripeStarterPriceId: process.env.STRIPE_STARTER_PRICE_ID || "",
+        stripeCreditsPriceId: process.env.STRIPE_CREDITS_PRICE_ID || "",
+        stripeWebhookSecret: process.env.STRIPE_WEBHOOK_SECRET || "",
+        stripeProjectsWorkdir: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? "/nonexistent/external-user-workdir"
+            : process.env.STRIPE_PROJECTS_WORKDIR ||
+                "/Users/test/Documents/muxo2/muxo-production-qualification",
+        stripeBinaryPath: resolveStripeBinary(),
+        supermemoryApiKey: process.env.MUXO_EXTERNAL_MODE === "1"
+            ? ""
+            : process.env.SUPERMEMORY_API_KEY || "",
+        supermemoryBaseUrl: process.env.SUPERMEMORY_BASE_URL || "https://api.supermemory.ai",
+        publicWebUrl: process.env.MUXO_PUBLIC_WEB_URL || "https://muxo.ai",
+        docsUrl: process.env.MUXO_DOCS_URL || "https://docs.muxo.ai",
+        vaultMasterKey: deriveVaultMasterKey(),
+    };
+}

package/dist/engine.d.ts

@@ -0,0 +1,156 @@
+import type { MuxoConfig } from "./config.js";
+import { type NaturalLanguageResolution } from "./nl.js";
+import { ComposioInstantAdapter } from "./providers/composio-instant.js";
+import { ComposioSdkAdapter } from "./providers/composio-sdk.js";
+import { MicrosoftGovernanceAdapter } from "./providers/microsoft-governance.js";
+import { StripeBillingAdapter } from "./providers/stripe-billing.js";
+import { StripeProjectsAdapter } from "./providers/stripe-projects.js";
+import { SupermemoryAdapter } from "./providers/supermemory.js";
+import type { MuxoStore } from "./store.js";
+import type { ActionPlan, ConnectionRecord, ExecutionReceipt, ExecutionRun, GovernanceDecisionRecord, MemoryContextSummary, MuxoTool, ProviderLane, RiskLevel, User, Workspace, WorkspaceMemoryRecord } from "./types.js";
+export interface ExecutionContext {
+    user: User;
+    workspace: Workspace;
+    actorId: string;
+    authType: "session" | "api_key";
+}
+export declare class MuxoEngine {
+    readonly config: MuxoConfig;
+    readonly store: MuxoStore;
+    readonly composioSdk: ComposioSdkAdapter;
+    readonly composioInstant: ComposioInstantAdapter;
+    readonly stripeProjects: StripeProjectsAdapter;
+    readonly stripeBilling: StripeBillingAdapter;
+    readonly governance: MicrosoftGovernanceAdapter;
+    readonly supermemory: SupermemoryAdapter;
+    constructor(config: MuxoConfig, store: MuxoStore);
+    getProfile(ctx: ExecutionContext): Record<string, unknown>;
+    getOrganization(ctx: ExecutionContext): Record<string, unknown>;
+    searchTools(params: {
+        query?: string;
+        lane?: ProviderLane | "all";
+        riskLevel?: RiskLevel;
+        limit?: number;
+    }): Promise<{
+        tools: MuxoTool[];
+        total: number;
+    }>;
+    listAllCatalogTools(): Promise<MuxoTool[]>;
+    inspectTool(slug: string): Promise<MuxoTool>;
+    connectionStatus(ctx: ExecutionContext, params?: {
+        provider?: string;
+        syncLive?: boolean;
+    }): Promise<Record<string, unknown>>;
+    startConnection(ctx: ExecutionContext, params: {
+        provider: string;
+        lane?: ProviderLane;
+        callbackUrl?: string;
+    }): Promise<ConnectionRecord & {
+        message: string;
+        callbackUrl?: string;
+    }>;
+    waitForConnection(ctx: ExecutionContext, params: {
+        provider: string;
+        timeoutSeconds?: number;
+        pollIntervalMs?: number;
+    }): Promise<{
+        connected: boolean;
+        provider: string;
+        status: ConnectionRecord["status"];
+        connection: ConnectionRecord;
+        redirectUrl: string | null;
+        message: string;
+    }>;
+    handleOAuthCallback(params: {
+        workspaceId: string;
+        provider: string;
+        connectedAccountId?: string;
+        status?: string;
+    }): Promise<{
+        ok: boolean;
+        workspaceId: string;
+        providerSlug: string;
+        providerName: string;
+        status: ConnectionRecord["status"];
+        externalAccountId: string | null;
+    }>;
+    planAction(ctx: ExecutionContext, params: {
+        toolSlug: string;
+        input?: Record<string, unknown>;
+        reason?: string;
+    }): Promise<{
+        plan: ActionPlan;
+        tool: MuxoTool;
+        decisionRecord: GovernanceDecisionRecord;
+        memoryContext: MemoryContextSummary;
+        authHandoff?: {
+            required: boolean;
+            provider: string;
+            status: ConnectionRecord["status"];
+            redirectUrl: string | null;
+            externalAccountId: string | null;
+            instructions: string;
+        };
+        nextStep: string;
+    }>;
+    getPlan(ctx: ExecutionContext, planId: string): ActionPlan;
+    approvePlan(ctx: ExecutionContext, planId: string, decision?: "approved" | "rejected"): ActionPlan;
+    getRunContext(ctx: ExecutionContext, query?: string): Promise<Record<string, unknown>>;
+    getMemoryOverview(ctx: ExecutionContext, query?: string): Promise<{
+        enabled: boolean;
+        namespace: string;
+        context: MemoryContextSummary;
+        recentMemories: WorkspaceMemoryRecord[];
+        memories: WorkspaceMemoryRecord[];
+    }>;
+    addWorkspaceMemory(ctx: ExecutionContext, params: {
+        title: string;
+        content: string;
+        kind?: WorkspaceMemoryRecord["kind"];
+        metadata?: Record<string, unknown>;
+    }): Promise<WorkspaceMemoryRecord>;
+    deleteWorkspaceMemory(ctx: ExecutionContext, idOrDocId: string): Promise<{
+        deleted: boolean;
+        record: WorkspaceMemoryRecord | null;
+    }>;
+    executePlanForRisk(ctx: ExecutionContext, planId: string, expectedRisk: RiskLevel): Promise<{
+        run: ExecutionRun;
+        receipt: ExecutionReceipt;
+    }>;
+    getRun(ctx: ExecutionContext, runId: string): ExecutionRun;
+    cancelRun(ctx: ExecutionContext, runId: string): {
+        run: ExecutionRun;
+        receipt: ExecutionReceipt | null;
+    };
+    getReceipt(ctx: ExecutionContext, receiptOrRunId: string): {
+        receipt: ExecutionReceipt;
+        signatureValid: boolean;
+        governanceSignatureValid: boolean;
+    };
+    doNaturalLanguage(ctx: ExecutionContext, params: {
+        prompt: string;
+        input?: Record<string, unknown>;
+        autoApprove?: boolean;
+        dryRun?: boolean;
+        planOnly?: boolean;
+        fundingMode?: "muxo_funded" | "byok";
+    }): Promise<{
+        ok: boolean;
+        executed: boolean;
+        status: "executed" | "planned_dry_run" | "awaiting_approval" | "awaiting_oauth_connection" | "missing_inputs" | "unresolved";
+        intent: NaturalLanguageResolution;
+        resolution: NaturalLanguageResolution;
+        plan?: ActionPlan;
+        run?: ExecutionRun;
+        receipt?: ExecutionReceipt;
+        authHandoff?: Record<string, unknown>;
+        byokPrompt?: {
+            needed: boolean;
+            provider: string;
+            envVarName: string;
+            cliCommand: string;
+            message: string;
+        };
+        humanMessage: string;
+    }>;
+}