@mugwork/mug 0.1.0

package/dist/src/commands/ai-gateway-route.d.ts

@@ -0,0 +1,24 @@
+interface RoutingConfig {
+    fast?: string;
+    balanced?: string;
+    powerful?: string;
+}
+interface RouteElement {
+    id: string;
+    type: string;
+    properties?: Record<string, unknown>;
+    outputs: Record<string, {
+        elementId: string;
+    } | Record<string, never>>;
+}
+export declare function buildDynamicRouteConfig(workspaceId: string, routing: RoutingConfig | undefined, plan: string): {
+    name: string;
+    elements: RouteElement[];
+};
+export declare function deployDynamicRoute(cfApiToken: string, workspaceId: string, routing: RoutingConfig | undefined, plan: string): Promise<{
+    success: boolean;
+    routeName: string;
+    error?: string;
+}>;
+export declare function deleteDynamicRoute(cfApiToken: string, workspaceId: string): Promise<boolean>;
+export {};

package/dist/src/commands/ai-gateway-route.js

@@ -0,0 +1,192 @@
+const CF_API = "https://api.cloudflare.com/client/v4";
+const ACCOUNT_ID = "dc4e6e6b6ceac3b63aa836729d31e5b4";
+const GATEWAY_ID = "mug-production";
+const PLATFORM_DEFAULTS = {
+    fast: "openai/gpt-5.4-nano",
+    balanced: "@cf/moonshotai/kimi-k2.6",
+    powerful: "anthropic/claude-sonnet-4-6",
+};
+const PLAN_CREDIT_LIMITS = {
+    free: 2500,
+    starter: 15000,
+    pro: 50000,
+    business: 100000,
+};
+const PLAN_RATE_LIMITS = {
+    free: 100,
+    starter: 1000,
+    pro: 5000,
+    business: 20000,
+};
+function parseProviderModel(spec) {
+    if (spec.startsWith("@cf/"))
+        return { provider: "workers-ai", model: spec };
+    const slash = spec.indexOf("/");
+    if (slash > 0)
+        return { provider: spec.slice(0, slash), model: spec.slice(slash + 1) };
+    return { provider: "anthropic", model: spec };
+}
+export function buildDynamicRouteConfig(workspaceId, routing, plan) {
+    const config = { ...PLATFORM_DEFAULTS, ...routing };
+    const fast = parseProviderModel(config.fast);
+    const balanced = parseProviderModel(config.balanced);
+    const powerful = parseProviderModel(config.powerful);
+    const creditLimit = PLAN_CREDIT_LIMITS[plan] ?? PLAN_CREDIT_LIMITS.starter;
+    const rateLimit = PLAN_RATE_LIMITS[plan] ?? PLAN_RATE_LIMITS.starter;
+    const elements = [
+        {
+            id: "start",
+            type: "start",
+            outputs: { next: { elementId: "rate_limit" } },
+        },
+        {
+            id: "rate_limit",
+            type: "rate",
+            properties: {
+                limitType: "count",
+                key: "metadata.workspace",
+                limit: rateLimit,
+                window: 3600,
+            },
+            outputs: {
+                success: { elementId: "budget_limit" },
+                fallback: { elementId: "end" },
+            },
+        },
+        {
+            id: "budget_limit",
+            type: "rate",
+            properties: {
+                limitType: "cost",
+                key: "metadata.workspace",
+                limit: creditLimit,
+                window: 2592000,
+            },
+            outputs: {
+                success: { elementId: "tier_check" },
+                fallback: { elementId: "end" },
+            },
+        },
+        {
+            id: "tier_check",
+            type: "conditional",
+            properties: {
+                conditions: { "metadata.tier": { $eq: "fast" } },
+            },
+            outputs: {
+                true: { elementId: "model_fast" },
+                false: { elementId: "tier_check_powerful" },
+            },
+        },
+        {
+            id: "tier_check_powerful",
+            type: "conditional",
+            properties: {
+                conditions: { "metadata.tier": { $eq: "powerful" } },
+            },
+            outputs: {
+                true: { elementId: "model_powerful" },
+                false: { elementId: "model_balanced" },
+            },
+        },
+        {
+            id: "model_fast",
+            type: "model",
+            properties: {
+                provider: fast.provider,
+                model: fast.model,
+                timeout: 30000,
+                retries: 2,
+            },
+            outputs: {
+                success: { elementId: "end" },
+                fallback: { elementId: "model_balanced" },
+            },
+        },
+        {
+            id: "model_balanced",
+            type: "model",
+            properties: {
+                provider: balanced.provider,
+                model: balanced.model,
+                timeout: 30000,
+                retries: 2,
+            },
+            outputs: {
+                success: { elementId: "end" },
+                fallback: { elementId: "model_powerful" },
+            },
+        },
+        {
+            id: "model_powerful",
+            type: "model",
+            properties: {
+                provider: powerful.provider,
+                model: powerful.model,
+                timeout: 60000,
+                retries: 2,
+            },
+            outputs: {
+                success: { elementId: "end" },
+                fallback: { elementId: "end" },
+            },
+        },
+        {
+            id: "end",
+            type: "end",
+            outputs: {},
+        },
+    ];
+    return { name: `ws-${workspaceId}`, elements };
+}
+export async function deployDynamicRoute(cfApiToken, workspaceId, routing, plan) {
+    const routeConfig = buildDynamicRouteConfig(workspaceId, routing, plan);
+    const baseUrl = `${CF_API}/accounts/${ACCOUNT_ID}/ai-gateway/gateways/${GATEWAY_ID}/routes`;
+    const existing = await fetch(baseUrl, {
+        headers: {
+            "Authorization": `Bearer ${cfApiToken}`,
+            "Content-Type": "application/json",
+        },
+    });
+    let routeId = null;
+    if (existing.ok) {
+        const data = (await existing.json());
+        routeId = data.result?.find((r) => r.name === routeConfig.name)?.id ?? null;
+    }
+    const method = routeId ? "PUT" : "POST";
+    const url = routeId ? `${baseUrl}/${routeId}` : baseUrl;
+    const res = await fetch(url, {
+        method,
+        headers: {
+            "Authorization": `Bearer ${cfApiToken}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(routeConfig),
+    });
+    if (!res.ok) {
+        const err = await res.text();
+        return { success: false, routeName: routeConfig.name, error: err };
+    }
+    return { success: true, routeName: routeConfig.name };
+}
+export async function deleteDynamicRoute(cfApiToken, workspaceId) {
+    const routeName = `ws-${workspaceId}`;
+    const baseUrl = `${CF_API}/accounts/${ACCOUNT_ID}/ai-gateway/gateways/${GATEWAY_ID}/routes`;
+    const existing = await fetch(baseUrl, {
+        headers: {
+            "Authorization": `Bearer ${cfApiToken}`,
+            "Content-Type": "application/json",
+        },
+    });
+    if (!existing.ok)
+        return false;
+    const data = (await existing.json());
+    const routeId = data.result?.find((r) => r.name === routeName)?.id;
+    if (!routeId)
+        return true;
+    const res = await fetch(`${baseUrl}/${routeId}`, {
+        method: "DELETE",
+        headers: { "Authorization": `Bearer ${cfApiToken}` },
+    });
+    return res.ok;
+}

package/dist/src/commands/auth.d.ts

@@ -0,0 +1 @@
+export declare function auth(provider: string): Promise<void>;

package/dist/src/commands/auth.js

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { exec } from "node:child_process";
+const API_URL = "https://api.mug.work";
+function openBrowser(url) {
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    exec(`${cmd} "${url}"`);
+}
+export async function auth(provider) {
+    const cwd = process.cwd();
+    const mugJsonPath = join(cwd, "mug.json");
+    if (!existsSync(mugJsonPath)) {
+        console.error("No mug.json found. Run `mug init` first.");
+        process.exit(1);
+    }
+    const config = JSON.parse(readFileSync(mugJsonPath, "utf-8"));
+    const workspace = config.name;
+    const state = crypto.randomUUID();
+    const startUrl = `${API_URL}/oauth/${provider}/start?workspace=${encodeURIComponent(workspace)}&state=${state}`;
+    console.log(`Opening browser to authorize ${provider}...`);
+    openBrowser(startUrl);
+    console.log("Waiting for authorization...");
+    const pollUrl = `${API_URL}/oauth/poll/${state}`;
+    const start = Date.now();
+    const timeout = 5 * 60 * 1000;
+    while (Date.now() - start < timeout) {
+        await new Promise((r) => setTimeout(r, 2000));
+        try {
+            const res = await fetch(pollUrl);
+            const data = (await res.json());
+            if (data.complete) {
+                console.log(`\n${provider} connected to workspace "${workspace}".`);
+                return;
+            }
+        }
+        catch {
+            // retry
+        }
+    }
+    console.error("\nTimed out waiting for authorization. Try again with `mug auth " + provider + "`");
+    process.exit(1);
+}

package/dist/src/commands/billing.d.ts

@@ -0,0 +1,6 @@
+export declare function buyPack(): Promise<void>;
+export declare function billingSettings(opts: {
+    autoPacks?: string;
+    maxPacks?: string;
+    email?: string;
+}): Promise<void>;

package/dist/src/commands/billing.js

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAccountToken } from "./login.js";
+const DISPATCH_URL = "https://api.mug.work";
+function getWorkspaceName() {
+    const mugJsonPath = join(process.cwd(), "mug.json");
+    if (!existsSync(mugJsonPath)) {
+        console.error("No mug.json found. Run `mug init` first.");
+        process.exit(1);
+    }
+    return JSON.parse(readFileSync(mugJsonPath, "utf-8")).name;
+}
+export async function buyPack() {
+    const workspace = getWorkspaceName();
+    const token = getAccountToken();
+    console.log(`Purchasing overage pack for ${workspace}...`);
+    const res = await fetch(`${DISPATCH_URL}/workspace/${workspace}/usage/pack`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    const data = await res.json();
+    if (!res.ok || data.error) {
+        console.error(`Failed: ${data.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    if (data.url) {
+        console.log(`\nOpen this URL to complete payment:\n\n  ${data.url}\n`);
+    }
+    else {
+        console.log(`Overage pack added. Total packs this period: ${data.overage_packs}`);
+    }
+}
+export async function billingSettings(opts) {
+    const workspace = getWorkspaceName();
+    const token = getAccountToken();
+    const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
+    // If no flags, show current settings
+    if (opts.autoPacks === undefined && opts.maxPacks === undefined && opts.email === undefined) {
+        const res = await fetch(`${DISPATCH_URL}/workspace/${workspace}/billing`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            console.error(`Failed: ${data.error ?? res.statusText}`);
+            process.exit(1);
+        }
+        console.log(`\n  Billing settings: ${workspace}\n`);
+        console.log(`  Plan tier:           ${data.plan_tier}`);
+        console.log(`  Auto-purchase packs: ${data.auto_purchase_packs ? "on" : "off"}`);
+        console.log(`  Max packs/month:     ${data.max_packs_per_month || "unlimited"}`);
+        console.log(`  Billing email:       ${data.billing_email ?? "(not set — uses account email)"}`);
+        console.log("");
+        return;
+    }
+    const body = {};
+    if (opts.autoPacks !== undefined) {
+        body.auto_purchase_packs = opts.autoPacks === "on" || opts.autoPacks === "true";
+    }
+    if (opts.maxPacks !== undefined) {
+        body.max_packs_per_month = parseInt(opts.maxPacks) || 0;
+    }
+    if (opts.email !== undefined) {
+        body.billing_email = opts.email || null;
+    }
+    const res = await fetch(`${DISPATCH_URL}/workspace/${workspace}/billing`, {
+        method: "PUT",
+        headers,
+        body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    if (!res.ok || data.error) {
+        console.error(`Failed: ${data.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    console.log(`Updated: ${data.updated?.join(", ")}`);
+}

package/dist/src/commands/brain.d.ts

@@ -0,0 +1 @@
+export declare function brain(agentName: string, subcommand?: string, ...args: string[]): void;

package/dist/src/commands/brain.js

@@ -0,0 +1,194 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+function findBrainDb(agentName) {
+    const cwd = process.cwd();
+    const brainPath = join(cwd, "src", "agents", agentName, "brain.db");
+    if (!existsSync(brainPath)) {
+        const agentsDir = join(cwd, "src", "agents");
+        if (!existsSync(agentsDir)) {
+            console.error("No src/agents/ directory found. Run `mug init` first.");
+            process.exit(1);
+        }
+        const folders = readdirSync(agentsDir).filter((f) => {
+            if (f === "shared-skills")
+                return false;
+            return statSync(join(agentsDir, f)).isDirectory() && existsSync(join(agentsDir, f, "agent.json"));
+        });
+        if (folders.length === 0) {
+            console.error("No agents found. Create an agent folder with agent.json + soul.md.");
+            process.exit(1);
+        }
+        console.error(`Agent "${agentName}" has no brain.db yet.`);
+        console.error(`Run \`mug pull\` to download runtime brain data, or the agent hasn't been invoked yet.`);
+        console.error(`\nAvailable agents: ${folders.join(", ")}`);
+        process.exit(1);
+    }
+    return brainPath;
+}
+function formatTable(rows, cols) {
+    if (rows.length === 0)
+        return "  (none)\n";
+    const widths = cols.map((col) => {
+        const values = rows.map((r) => String(r[col] ?? "").slice(0, 60));
+        return Math.min(60, Math.max(col.length, ...values.map((v) => v.length)));
+    });
+    const header = cols.map((c, i) => c.padEnd(widths[i])).join("  ");
+    const sep = widths.map((w) => "-".repeat(w)).join("  ");
+    const body = rows.map((r) => cols.map((c, i) => String(r[c] ?? "").slice(0, 60).padEnd(widths[i])).join("  ")).join("\n");
+    return `${header}\n${sep}\n${body}\n`;
+}
+function overview(agentName) {
+    const db = new Database(findBrainDb(agentName), { readonly: true });
+    try {
+        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((r) => r.name);
+        if (!tables.includes("brain_entities")) {
+            console.log(`${agentName}: brain.db exists but has no schema (agent may not have run yet).`);
+            return;
+        }
+        const entities = db.prepare("SELECT COUNT(*) as c FROM brain_entities").get().c;
+        const facts = db.prepare("SELECT COUNT(*) as c FROM brain_facts").get().c;
+        const outcomes = db.prepare("SELECT COUNT(*) as c FROM brain_outcomes").get().c;
+        const struggles = db.prepare("SELECT COUNT(*) as c FROM brain_struggles").get().c;
+        const unresolvedStruggles = db.prepare("SELECT COUNT(*) as c FROM brain_struggles WHERE resolved = 0").get().c;
+        const sessions = db.prepare("SELECT COUNT(*) as c FROM brain_sessions").get().c;
+        console.log(`\n  ${agentName} brain\n`);
+        console.log(`  Entities:   ${entities}`);
+        console.log(`  Facts:      ${facts}`);
+        console.log(`  Outcomes:   ${outcomes}`);
+        console.log(`  Struggles:  ${struggles} (${unresolvedStruggles} unresolved)`);
+        console.log(`  Sessions:   ${sessions}`);
+        if (unresolvedStruggles > 0) {
+            console.log(`\n  Recent unresolved struggles:`);
+            const rows = db.prepare("SELECT category, description, recorded_at FROM brain_struggles WHERE resolved = 0 ORDER BY recorded_at DESC LIMIT 5").all();
+            for (const r of rows) {
+                console.log(`    [${r.category}] ${r.description} (${r.recorded_at?.slice(0, 10)})`);
+            }
+        }
+        console.log();
+    }
+    finally {
+        db.close();
+    }
+}
+function struggles(agentName) {
+    const db = new Database(findBrainDb(agentName), { readonly: true });
+    try {
+        const rows = db.prepare("SELECT category, description, context, resolved, recorded_at FROM brain_struggles ORDER BY resolved ASC, recorded_at DESC").all();
+        if (rows.length === 0) {
+            console.log(`\n  ${agentName}: no struggles recorded.\n`);
+            return;
+        }
+        const unresolved = rows.filter((r) => !r.resolved);
+        const resolved = rows.filter((r) => r.resolved);
+        console.log(`\n  ${agentName} struggles (${unresolved.length} unresolved, ${resolved.length} resolved)\n`);
+        const grouped = {};
+        for (const r of unresolved) {
+            (grouped[r.category] ??= []).push(r);
+        }
+        for (const [cat, items] of Object.entries(grouped)) {
+            console.log(`  [${cat}] (${items.length})`);
+            for (const item of items) {
+                console.log(`    - ${item.description}`);
+                if (item.context)
+                    console.log(`      context: ${item.context.slice(0, 100)}`);
+            }
+            console.log();
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+function entities(agentName) {
+    const db = new Database(findBrainDb(agentName), { readonly: true });
+    try {
+        const rows = db.prepare("SELECT name, type, summary, mention_count, last_seen FROM brain_entities ORDER BY mention_count DESC").all();
+        console.log(`\n  ${agentName} entities (${rows.length})\n`);
+        console.log(formatTable(rows, ["name", "type", "summary", "mention_count"]));
+    }
+    finally {
+        db.close();
+    }
+}
+function outcomes(agentName) {
+    const db = new Database(findBrainDb(agentName), { readonly: true });
+    try {
+        const rows = db.prepare("SELECT action, result, CASE WHEN effective = 1 THEN 'yes' WHEN effective = 0 THEN 'no' ELSE '?' END as effective, recorded_at FROM brain_outcomes ORDER BY recorded_at DESC LIMIT 30").all();
+        console.log(`\n  ${agentName} outcomes (last 30)\n`);
+        console.log(formatTable(rows, ["action", "result", "effective", "recorded_at"]));
+        const stats = db.prepare("SELECT COUNT(*) as total, SUM(CASE WHEN effective = 1 THEN 1 ELSE 0 END) as successes FROM brain_outcomes").get();
+        if (stats.total > 0) {
+            const rate = Math.round((stats.successes / stats.total) * 100);
+            console.log(`  Success rate: ${rate}% (${stats.successes}/${stats.total})\n`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+function sessionsList(agentName) {
+    const db = new Database(findBrainDb(agentName), { readonly: true });
+    try {
+        const rows = db.prepare("SELECT workflow, started_at, credits_used, turns_used, CASE WHEN capped = 1 THEN 'yes' ELSE '' END as capped, outcome_count, struggle_count FROM brain_sessions ORDER BY started_at DESC LIMIT 30").all();
+        console.log(`\n  ${agentName} sessions (last 30)\n`);
+        console.log(formatTable(rows, ["workflow", "started_at", "credits_used", "turns_used", "capped"]));
+    }
+    finally {
+        db.close();
+    }
+}
+function search(agentName, query) {
+    const db = new Database(findBrainDb(agentName), { readonly: true });
+    try {
+        const q = `%${query}%`;
+        const entityRows = db.prepare("SELECT 'entity' as type, name as title, summary as detail FROM brain_entities WHERE LOWER(name) LIKE LOWER(?) OR LOWER(summary) LIKE LOWER(?)").all(q, q);
+        const factRows = db.prepare("SELECT 'fact' as type, content as title, observed_at as detail FROM brain_facts WHERE LOWER(content) LIKE LOWER(?)").all(q);
+        const struggleRows = db.prepare("SELECT 'struggle' as type, description as title, category as detail FROM brain_struggles WHERE LOWER(description) LIKE LOWER(?)").all(q);
+        const all = [...entityRows, ...factRows, ...struggleRows];
+        if (all.length === 0) {
+            console.log(`\n  No results for "${query}"\n`);
+            return;
+        }
+        console.log(`\n  ${agentName} brain search: "${query}" (${all.length} results)\n`);
+        console.log(formatTable(all, ["type", "title", "detail"]));
+    }
+    finally {
+        db.close();
+    }
+}
+export function brain(agentName, subcommand, ...args) {
+    if (!agentName) {
+        const cwd = process.cwd();
+        const agentsDir = join(cwd, "src", "agents");
+        if (existsSync(agentsDir)) {
+            const folders = readdirSync(agentsDir).filter((f) => {
+                if (f === "shared-skills")
+                    return false;
+                return statSync(join(agentsDir, f)).isDirectory() && existsSync(join(agentsDir, f, "agent.json"));
+            });
+            if (folders.length > 0) {
+                console.log(`\nAvailable agents: ${folders.join(", ")}`);
+                console.log(`Usage: mug brain <agent-name> [struggles|entities|outcomes|sessions|search <query>]\n`);
+                return;
+            }
+        }
+        console.error("Usage: mug brain <agent-name> [subcommand]");
+        process.exit(1);
+    }
+    switch (subcommand) {
+        case "struggles": return struggles(agentName);
+        case "entities": return entities(agentName);
+        case "outcomes": return outcomes(agentName);
+        case "sessions": return sessionsList(agentName);
+        case "search": {
+            const query = args.join(" ");
+            if (!query) {
+                console.error("Usage: mug brain <agent> search <query>");
+                process.exit(1);
+            }
+            return search(agentName, query);
+        }
+        default: return overview(agentName);
+    }
+}

package/dist/src/commands/demo.d.ts

@@ -0,0 +1,12 @@
+export interface DemoEnableOpts {
+    as: string;
+    expires?: string;
+    notify?: string;
+    emailTo?: string;
+    smsTo?: string;
+    slackTo?: string;
+    noWorkflows?: boolean;
+}
+export declare function demoEnable(surfaceId: string, opts: DemoEnableOpts): Promise<void>;
+export declare function demoDisable(surfaceId: string): Promise<void>;
+export declare function demoStatus(): Promise<void>;