@muxoai/platform 0.0.0-stage → 1.2.1

package/dist/cli.js

@@ -0,0 +1,527 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { getConfig } from "./config.js";
+import { MuxoEngine } from "./engine.js";
+import { handleJsonRpcMcpRequest } from "./mcp.js";
+import { MuxoStore } from "./store.js";
+function getCliConfigPath() {
+    if (process.env.MUXO_CONFIG_PATH) {
+        return path.resolve(process.env.MUXO_CONFIG_PATH);
+    }
+    return path.join(os.homedir(), ".muxo", "config.json");
+}
+function readCliAuthConfig() {
+    try {
+        const cfgPath = getCliConfigPath();
+        if (!fs.existsSync(cfgPath))
+            return null;
+        const raw = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+        if (raw && typeof raw.apiKey === "string" && raw.apiKey.trim()) {
+            return raw;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCliAuthConfig(cfg) {
+    const cfgPath = getCliConfigPath();
+    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", { mode: 0o600 });
+    return cfgPath;
+}
+function parseFlags(args) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = args[i + 1];
+            if (next && !next.startsWith("--")) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return { positional, flags };
+}
+async function runCli() {
+    const config = getConfig();
+    const store = new MuxoStore(config.dbPath, config.vaultMasterKey);
+    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");
+        return;
+    }
+    const savedCliConfig = readCliAuthConfig();
+    const apiKeyFlag = (typeof flags["api-key"] === "string" ? flags["api-key"] : "") ||
+        process.env.MUXO_API_KEY ||
+        savedCliConfig?.apiKey ||
+        "";
+    const tokenAuth = apiKeyFlag ? store.resolveAuthToken(apiKeyFlag) : null;
+    const fallback = store.ensureDefaultWorkspace();
+    const ctx = tokenAuth
+        ? {
+            user: tokenAuth.user,
+            workspace: tokenAuth.workspace,
+            actorId: tokenAuth.actorId,
+            authType: tokenAuth.authType,
+        }
+        : {
+            user: fallback.user,
+            workspace: fallback.workspace,
+            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"
+            ? flags["api-key"]
+            : positional[1]?.startsWith("mk_")
+                ? positional[1]
+                : "";
+        if (explicitKey) {
+            const resolved = store.resolveAuthToken(explicitKey);
+            if (!resolved) {
+                throw new Error("Invalid Muxo API key supplied to 'muxo login'.");
+            }
+            const authPayload = {
+                authenticated: true,
+                apiKey: explicitKey,
+                workspaceId: resolved.workspace.id,
+                workspaceName: resolved.workspace.name,
+                agentId: resolved.user.id,
+                governanceDid: engine.governance.getStatus(resolved.workspace).agentDid,
+                supermemoryNamespace: engine.supermemory.getWorkspaceNamespace(resolved.workspace.id),
+                updatedAt: new Date().toISOString(),
+            };
+            const cfgPath = writeCliAuthConfig(authPayload);
+            console.log(JSON.stringify({
+                ok: true,
+                mode: "api_key",
+                configPath: cfgPath,
+                ...authPayload,
+            }, null, 2));
+            return;
+        }
+        // Create an isolated external workspace + mk_live_* key (`muxo login --signup` or `muxo signup`)
+        const agentName = typeof flags.name === "string"
+            ? flags.name
+            : positional[1] || "Muxo CLI Agent";
+        const harness = typeof flags.harness === "string" ? flags.harness : "muxo-cli";
+        const created = store.createAutonomousAgentSignup({
+            agentName,
+            harness,
+        });
+        const authPayload = {
+            authenticated: true,
+            apiKey: created.apiKey,
+            workspaceId: created.workspace.id,
+            workspaceName: created.workspace.name,
+            agentId: created.user.id,
+            governanceDid: engine.governance.getStatus(created.workspace).agentDid,
+            supermemoryNamespace: engine.supermemory.getWorkspaceNamespace(created.workspace.id),
+            updatedAt: new Date().toISOString(),
+        };
+        const cfgPath = writeCliAuthConfig(authPayload);
+        console.log(JSON.stringify({
+            ok: true,
+            mode: "autonomous_signup",
+            configPath: cfgPath,
+            ...authPayload,
+        }, null, 2));
+        return;
+    }
+    if (cmd === "logout") {
+        const cfgPath = getCliConfigPath();
+        if (fs.existsSync(cfgPath)) {
+            fs.unlinkSync(cfgPath);
+        }
+        console.log(JSON.stringify({ ok: true, authenticated: false, configPath: cfgPath }, null, 2));
+        return;
+    }
+    if (cmd === "claim") {
+        const email = positional[1] || (typeof flags.email === "string" ? flags.email : "");
+        if (!email || !email.includes("@")) {
+            throw new Error("Usage: muxo claim <owner_email>");
+        }
+        const claim = store.createAgentClaim({
+            workspaceId: ctx.workspace.id,
+            email,
+            baseUrl: config.baseUrl,
+        });
+        console.log(JSON.stringify({ ok: true, claim, ...claim }, null, 2));
+        return;
+    }
+    // Stdio MCP Server mode (`muxo mcp`)
+    if (cmd === "mcp") {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            terminal: false,
+        });
+        let queue = Promise.resolve();
+        rl.on("line", (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            queue = queue.then(async () => {
+                try {
+                    const rpc = JSON.parse(trimmed);
+                    const response = await handleJsonRpcMcpRequest(engine, ctx, rpc);
+                    if (response) {
+                        process.stdout.write(JSON.stringify(response) + "\n");
+                    }
+                }
+                catch (err) {
+                    process.stdout.write(JSON.stringify({
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: {
+                            code: -32700,
+                            message: String(err?.message || "Parse error"),
+                        },
+                    }) + "\n");
+                }
+            });
+        });
+        await new Promise((resolve) => {
+            rl.on("close", () => {
+                queue.finally(() => resolve());
+            });
+        });
+        return;
+    }
+    if (cmd === "harness") {
+        console.log(JSON.stringify({
+            ok: true,
+            version: "1.2.0",
+            workspaceId: ctx.workspace.id,
+            data: {
+                mcpServers: {
+                    muxo: {
+                        command: "npx",
+                        args: ["-y", "@muxoai/cli@latest", "mcp"],
+                    },
+                },
+                remoteMcp: {
+                    url: "https://api.muxo.ai/mcp",
+                    transport: "streamable-http",
+                },
+            },
+        }, null, 2));
+        return;
+    }
+    if (cmd === "whoami" || cmd === "status" || cmd === "doctor") {
+        const org = engine.getOrganization(ctx);
+        console.log(JSON.stringify({
+            authenticated: true,
+            authSource: tokenAuth
+                ? savedCliConfig?.apiKey === apiKeyFlag
+                    ? "config_file"
+                    : "api_key"
+                : "local_default",
+            profile: engine.getProfile(ctx),
+            governanceDid: engine.governance.getStatus(ctx.workspace).agentDid,
+            supermemoryNamespace: engine.supermemory.getWorkspaceNamespace(ctx.workspace.id),
+            ...org,
+        }, null, 2));
+        return;
+    }
+    if (cmd === "search") {
+        const query = positional.slice(1).join(" ") || flags.query || "";
+        const lane = flags.lane || "all";
+        const res = await engine.searchTools({
+            query,
+            lane,
+            limit: flags.limit ? Number(flags.limit) : 20,
+        });
+        if (flags.json) {
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        console.log(`\nFound ${res.total} tools matching '${query || "*"}' (lane: ${lane}):\n`);
+        for (const t of res.tools) {
+            console.log(`  • ${t.slug.padEnd(38)} [${t.lane.padEnd(16)}] (${t.riskLevel}, ${t.creditCost} cr)`);
+            console.log(`    ${t.description.slice(0, 100)}`);
+        }
+        return;
+    }
+    if (cmd === "inspect") {
+        const slug = positional[1];
+        if (!slug)
+            throw new Error("Usage: muxo inspect <tool_slug>");
+        const tool = await engine.inspectTool(slug);
+        console.log(JSON.stringify(tool, null, 2));
+        return;
+    }
+    if (cmd === "connections") {
+        const status = await engine.connectionStatus(ctx, {
+            provider: positional[1],
+            syncLive: flags.sync !== "false",
+        });
+        console.log(JSON.stringify(status, null, 2));
+        return;
+    }
+    if (cmd === "connect" || cmd === "link") {
+        const provider = positional[1];
+        if (!provider)
+            throw new Error(`Usage: muxo ${cmd} <provider> [--wait] [--timeout 30]`);
+        const res = await engine.startConnection(ctx, {
+            provider,
+            lane: flags.lane,
+            callbackUrl: typeof flags.callback === "string" ? flags.callback : undefined,
+        });
+        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));
+            return;
+        }
+        console.log(JSON.stringify(res, null, 2));
+        return;
+    }
+    if (cmd === "wait") {
+        const provider = positional[1];
+        if (!provider)
+            throw new Error("Usage: muxo wait <provider> [--timeout 15]");
+        const timeoutSeconds = flags.timeout ? Number(flags.timeout) : 15;
+        const waited = await engine.waitForConnection(ctx, {
+            provider,
+            timeoutSeconds,
+        });
+        console.log(JSON.stringify(waited, null, 2));
+        return;
+    }
+    if (cmd === "plan") {
+        const toolSlug = positional[1];
+        if (!toolSlug)
+            throw new Error("Usage: muxo plan <tool_slug> [--input '{...}']");
+        const input = flags.input ? JSON.parse(String(flags.input)) : {};
+        const reason = flags.reason ? String(flags.reason) : "Planned via Muxo CLI";
+        const planned = await engine.planAction(ctx, { toolSlug, input, reason });
+        console.log(JSON.stringify(planned, null, 2));
+        return;
+    }
+    if (cmd === "approve") {
+        const planId = positional[1];
+        if (!planId)
+            throw new Error("Usage: muxo approve <plan_id>");
+        const approved = engine.approvePlan(ctx, planId, "approved");
+        console.log(JSON.stringify(approved, null, 2));
+        return;
+    }
+    if (cmd === "run") {
+        const planId = positional[1];
+        if (!planId)
+            throw new Error("Usage: muxo run <plan_id>");
+        const plan = engine.getPlan(ctx, planId);
+        const result = await engine.executePlanForRisk(ctx, planId, plan.riskLevel);
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (cmd === "exec" || cmd === "provision") {
+        const toolSlug = positional[1];
+        if (!toolSlug)
+            throw new Error(`Usage: muxo ${cmd} <tool_slug> [--input '{...}'] [--approve]`);
+        const input = flags.input ? JSON.parse(String(flags.input)) : {};
+        const planned = await engine.planAction(ctx, {
+            toolSlug,
+            input,
+            reason: `Direct CLI ${cmd}`,
+        });
+        if (planned.plan.approvalStatus === "pending_approval") {
+            if (flags.approve || cmd === "provision") {
+                engine.approvePlan(ctx, planned.plan.id, "approved");
+            }
+            else {
+                console.log(JSON.stringify({
+                    ok: false,
+                    status: "pending_approval",
+                    plan: planned.plan,
+                    hint: `Pass --approve or run 'muxo approve ${planned.plan.id}' to authorize this ${planned.plan.riskLevel} operation.`,
+                }, null, 2));
+                return;
+            }
+        }
+        const result = await engine.executePlanForRisk(ctx, planned.plan.id, planned.plan.riskLevel);
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (cmd === "resources") {
+        console.log(JSON.stringify(store.listResources(ctx.workspace.id), null, 2));
+        return;
+    }
+    if (cmd === "env" && positional[1] === "pull") {
+        const outFile = String(flags.out || ".env.muxo");
+        const workdirSecrets = await engine.stripeProjects
+            .pullEnvVarsFromWorkdir()
+            .catch(() => ({}));
+        const vaultSecrets = store.getDecryptedWorkspaceEnv(ctx.workspace.id);
+        const merged = { ...workdirSecrets, ...vaultSecrets };
+        const lines = [
+            `# Muxo Provisioned Environment (${ctx.workspace.slug})`,
+            ...Object.entries(merged).map(([k, v]) => `${k}=${JSON.stringify(v)}`),
+            "",
+        ];
+        const resolvedPath = path.resolve(process.cwd(), outFile);
+        fs.writeFileSync(resolvedPath, lines.join("\n"), { mode: 0o600 });
+        console.log(JSON.stringify({
+            ok: true,
+            outputFile: resolvedPath,
+            keysWritten: Object.keys(merged),
+        }, null, 2));
+        return;
+    }
+    if (cmd === "receipts") {
+        const receiptId = positional[1];
+        if (receiptId) {
+            console.log(JSON.stringify(engine.getReceipt(ctx, receiptId), null, 2));
+        }
+        else {
+            console.log(JSON.stringify(store.listReceipts(ctx.workspace.id, 20), null, 2));
+        }
+        return;
+    }
+    if (cmd === "billing" || cmd === "topup") {
+        const sub = cmd === "topup" ? "topup" : positional[1] || "status";
+        if (sub === "topup") {
+            const credits = Math.max(1, Number(flags.credits || (cmd === "topup" ? positional[1] : positional[2]) || 1000));
+            const usdPaid = (credits * 0.01).toFixed(2);
+            const refId = `cli_topup_${Date.now()}`;
+            const updated = store.addWorkspaceCredits({
+                workspaceId: ctx.workspace.id,
+                credits,
+                referenceId: refId,
+                description: `User purchased +${credits.toLocaleString()} Muxo Credits ($${usdPaid} USD -> Muxo Master Wallet)`,
+            });
+            console.log(JSON.stringify({
+                ok: true,
+                creditsAdded: credits,
+                usdPaid: Number(usdPaid),
+                creditsBalance: updated.creditsBalance,
+                settlementSummary: store.getSupplierSettlementSummary(ctx.workspace.id),
+            }, null, 2));
+            return;
+        }
+        if (sub === "checkout") {
+            const kind = flags.kind === "starter_subscription" || positional[2] === "starter"
+                ? "starter_subscription"
+                : "credit_topup";
+            const session = await engine.stripeBilling.createCheckoutSession({
+                workspace: ctx.workspace,
+                customerEmail: ctx.user.email,
+                kind,
+                returnBaseUrl: config.baseUrl,
+            });
+            console.log(JSON.stringify({ ok: true, kind, ...session }, null, 2));
+            return;
+        }
+        console.log(JSON.stringify({
+            ok: true,
+            settlementSummary: store.getSupplierSettlementSummary(ctx.workspace.id),
+            recentLedger: store.listLedgerEntries(ctx.workspace.id, 25),
+        }, null, 2));
+        return;
+    }
+    if (cmd === "memory") {
+        const sub = positional[1];
+        if (sub === "add") {
+            const content = positional.slice(2).join(" ") || String(flags.content || "");
+            if (!content)
+                throw new Error("Usage: muxo memory add <text>");
+            const entry = await engine.addWorkspaceMemory(ctx, {
+                content,
+                title: flags.title ? String(flags.title) : content.slice(0, 60),
+            });
+            console.log(JSON.stringify({ ok: true, memory: entry }, null, 2));
+            return;
+        }
+        const query = sub === "recall" || sub === "search"
+            ? 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));
+        return;
+    }
+    if (cmd === "governance") {
+        console.log(JSON.stringify(engine.governance.getGovernanceStatus(ctx.workspace), null, 2));
+        return;
+    }
+    if (cmd === "serve") {
+        const { createMuxoServer } = await import("./server.js");
+        const port = flags.port ? Number(flags.port) : config.port;
+        const baseUrl = `http://localhost:${port}`;
+        const srvConfig = { ...config, port, baseUrl };
+        const { server } = createMuxoServer(srvConfig);
+        await new Promise((resolve) => {
+            server.listen(port, () => {
+                console.log(`\n⚡ Muxo Platform running at ${baseUrl}`);
+                console.log(`   ├─ Web Console:     ${baseUrl}/`);
+                console.log(`   ├─ Landing Page:    ${baseUrl}/landing`);
+                console.log(`   ├─ MCP Server:      ${baseUrl}/mcp`);
+                console.log(`   ├─ OAuth Callback:  ${baseUrl}/oauth/callback`);
+                console.log(`   └─ Agent Skill:     ${baseUrl}/skill.md\n`);
+            });
+            process.on("SIGINT", () => {
+                server.close(() => resolve());
+            });
+            process.on("SIGTERM", () => {
+                server.close(() => resolve());
+            });
+        });
+        return;
+    }
+    console.log(`
+Muxo CLI — Unified Execution, Provisioning & Governance Platform
+
+Commands:
+  muxo login [--api-key <key> | --signup]      Sign in or create an autonomous workspace (~/.muxo/config.json)
+  muxo logout                                  Remove saved CLI authentication config
+  muxo claim <owner_email>                     Generate a human owner claim link for this workspace
+  muxo whoami                                  Show workspace profile, plan, DID, and credit balance
+  muxo search <query> [--lane <lane>]          Search across Instant, Composio Apps, and Stripe Projects
+  muxo inspect <tool_slug>                     Inspect tool schema, risk level, and credit cost
+  muxo connections [--sync true|false]         List Composio OAuth & Stripe Projects provider connections
+  muxo link <provider> [--wait]                Start OAuth handoff for a service and optionally wait
+  muxo connect <provider> [--wait]             Alias for 'muxo link'
+  muxo wait <provider> [--timeout 15]          Poll until a pending OAuth connection handoff becomes active
+  muxo plan <tool_slug> --input '{...}'        Create a governed execution plan (plan_*)
+  muxo approve <plan_id>                       Approve a pending high-risk plan
+  muxo run <plan_id>                           Execute an approved plan and issue a signed receipt
+  muxo exec <tool_slug> --input '{...}'        Plan and execute in one step (pass --approve for high-risk)
+  muxo resources                               List provisioned Stripe Projects infrastructure resources
+  muxo env pull [--out .env.muxo]              Decrypt and write provisioned credentials to local .env
+  muxo receipts [<receipt_id>]                 List or cryptographically verify execution receipts
+  muxo billing [status|topup|checkout]         Buy Muxo credits & inspect User -> Muxo -> Supplier settlements
+  muxo memory [<query>]                        Recall Supermemory v5 workspace brain & hybrid memories
+  muxo governance                              Inspect Microsoft Agent Governance Ed25519 DID & audit chain
+  muxo serve [--port 4310]                     Start unified HTTP Console, Landing, OAuth Callback & MCP server
+  muxo mcp                                     Run stdio MCP server (19 canonical tools)
+`);
+}
+runCli().catch((err) => {
+    console.error("Error:", err?.message || err);
+    process.exit(1);
+});

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(),
+    };
+}