@mugwork/mug 0.1.0

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

@@ -0,0 +1,6 @@
+interface UsageOptions {
+    json?: boolean;
+    period?: string;
+}
+export declare function usage(opts: UsageOptions): Promise<void>;
+export {};

package/dist/src/commands/usage.js

@@ -0,0 +1,78 @@
+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 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);
+    }
+    return JSON.parse(readFileSync(mugJsonPath, "utf-8")).name;
+}
+const DIMENSION_LABELS = {
+    operations: { label: "Operations", unit: "", format: (n) => n.toLocaleString() },
+    records: { label: "Database records", unit: "", format: (n) => n.toLocaleString() },
+    storage_bytes: { label: "File storage", unit: "", format: formatBytes },
+    email: { label: "Email sends", unit: "", format: (n) => n.toLocaleString() },
+    sms: { label: "SMS sends", unit: "", format: (n) => n.toLocaleString() },
+    ai_credits: { label: "AI credits", unit: "", format: (n) => n.toLocaleString() },
+};
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1000));
+    return `${(bytes / Math.pow(1000, i)).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}
+function bar(pct, width = 20) {
+    const filled = Math.min(width, Math.round((pct / 100) * width));
+    const empty = width - filled;
+    const color = pct >= 100 ? "\x1b[31m" : pct >= 80 ? "\x1b[33m" : "\x1b[32m";
+    return `${color}${"█".repeat(filled)}${"░".repeat(empty)}\x1b[0m`;
+}
+export async function usage(opts) {
+    const workspace = getWorkspaceName();
+    const token = getAccountToken();
+    const url = opts.period
+        ? `${DISPATCH_URL}/workspace/${workspace}/usage?period=${opts.period}`
+        : `${DISPATCH_URL}/workspace/${workspace}/usage`;
+    const res = await fetch(url, {
+        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 (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const tierLabel = data.tier.charAt(0).toUpperCase() + data.tier.slice(1);
+    console.log(`\n  ${workspace} — ${tierLabel} tier — ${data.period}\n`);
+    if (data.overage_packs > 0 || data.carry_packs > 0) {
+        const total = data.overage_packs + data.carry_packs;
+        console.log(`  Overage packs: ${data.overage_packs} purchased + ${data.carry_packs} carried = ${total} total\n`);
+    }
+    const dims = data.dimensions ?? {};
+    for (const [key, info] of Object.entries(DIMENSION_LABELS)) {
+        const d = dims[key];
+        if (!d)
+            continue;
+        const fmt = info.format;
+        const pct = d.base_limit > 0 ? Math.round((d.used / d.base_limit) * 100) : 0;
+        const limitStr = key === "storage_bytes" ? formatBytes(d.limit) : d.limit.toLocaleString();
+        console.log(`  ${info.label.padEnd(18)} ${bar(pct)} ${String(pct).padStart(3)}%  ${fmt(d.used)} / ${limitStr}`);
+    }
+    if (data.ai_detail && data.ai_detail.length > 0) {
+        console.log("\n  AI model breakdown (last 30 days):");
+        for (const m of data.ai_detail) {
+            const reqs = Number(m.request_count);
+            const tokens = Number(m.total_tokens);
+            console.log(`    ${m.model}: ${reqs} requests, ${tokens.toLocaleString()} tokens`);
+        }
+    }
+    console.log("");
+}

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

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

package/dist/src/commands/webhooks.js

@@ -0,0 +1,102 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { parseWorkflowSteps } from "../workflow-parser.js";
+export async function webhooksCommand() {
+    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 name = config.name;
+    let tunnelUrl;
+    const pidPath = join(cwd, ".mug", "dev.pid");
+    if (existsSync(pidPath)) {
+        try {
+            const pidData = JSON.parse(readFileSync(pidPath, "utf-8"));
+            tunnelUrl = pidData.tunnelUrl;
+        }
+        catch { }
+    }
+    const wfDir = join(cwd, "src", "workflows");
+    if (!existsSync(wfDir)) {
+        console.log("No workflows found (src/workflows/ does not exist).");
+        return;
+    }
+    const files = readdirSync(wfDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    if (files.length === 0) {
+        console.log("No workflow files found in src/workflows/.");
+        return;
+    }
+    let hasWebhooks = false;
+    let hasInbound = false;
+    let hasTriggers = false;
+    const webhooks = [];
+    const inbounds = [];
+    const triggers = [];
+    for (const f of files) {
+        try {
+            const source = readFileSync(join(wfDir, f), "utf-8");
+            const wfName = f.replace(/\.(ts|js)$/, "");
+            const parsed = parseWorkflowSteps(source, wfName, f);
+            if (parsed.webhook) {
+                hasWebhooks = true;
+                const auth = typeof parsed.webhook === "object" ? parsed.webhook.auth : "none";
+                const base = tunnelUrl ? `${tunnelUrl}/hook/${parsed.name}` : `https://api.mug.work/hook/${name}/${parsed.name}`;
+                webhooks.push({ name: parsed.name, auth, url: base });
+            }
+            if (parsed.inbound) {
+                hasInbound = true;
+                const url = tunnelUrl
+                    ? `${tunnelUrl}/inbound/${parsed.inbound}`
+                    : `https://api.mug.work/inbound/${parsed.inbound}/${name}`;
+                inbounds.push({ channel: parsed.inbound, workflow: parsed.name, url });
+            }
+            if (parsed.trigger?.source) {
+                hasTriggers = true;
+                triggers.push({
+                    name: parsed.name,
+                    source: parsed.trigger.source,
+                    table: parsed.trigger.table ?? "*",
+                    on: parsed.trigger.on ?? "change",
+                });
+            }
+        }
+        catch { }
+    }
+    if (!hasWebhooks && !hasInbound && !hasTriggers) {
+        console.log("No webhooks, inbound routes, or event triggers found in workflow files.");
+        return;
+    }
+    if (webhooks.length > 0) {
+        console.log("Webhooks:");
+        for (const wh of webhooks) {
+            console.log(`  ${wh.name} (auth: ${wh.auth})`);
+            console.log(`    POST ${wh.url}`);
+        }
+    }
+    if (inbounds.length > 0) {
+        if (hasWebhooks)
+            console.log();
+        console.log("Inbound channels:");
+        for (const ib of inbounds) {
+            console.log(`  ${ib.channel} → ${ib.workflow}`);
+            console.log(`    POST ${ib.url}`);
+        }
+    }
+    if (triggers.length > 0) {
+        if (hasWebhooks || hasInbound)
+            console.log();
+        console.log("Event triggers:");
+        for (const t of triggers) {
+            console.log(`  ${t.name} — ${t.source}/${t.table} on ${t.on}`);
+        }
+    }
+    if (tunnelUrl) {
+        console.log(`\n  (URLs use active tunnel: ${tunnelUrl})`);
+    }
+    else if (!existsSync(pidPath)) {
+        console.log(`\n  (Production URLs shown — run \`mug dev --tunnel\` for local testing URLs)`);
+    }
+}

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

@@ -0,0 +1,23 @@
+export declare function createWorkspace(name: string, opts: {
+    subdomain?: string;
+    tier?: string;
+}): Promise<void>;
+export declare function workspaceStatus(): Promise<void>;
+export declare function workspacePlan(): Promise<void>;
+export declare function workspaceInvite(email: string): Promise<void>;
+export declare function workspaceTransfer(email: string): Promise<void>;
+export declare function workspaceRemove(email: string): Promise<void>;
+export declare function workspaceArchive(): Promise<void>;
+export declare function workspaceRestore(): Promise<void>;
+export declare function workspaceDelete(): Promise<void>;
+export declare function workspaceExport(opts: {
+    categories?: string;
+    all?: boolean;
+}): Promise<void>;
+export declare function accountInvites(): Promise<void>;
+export declare function accountAccept(inviteId: string): Promise<void>;
+export declare function accountDecline(inviteId: string): Promise<void>;
+export declare function workspaceCancelInvite(inviteId: string): Promise<void>;
+export declare function accountChangeEmail(newEmail: string): Promise<void>;
+export declare function workspaceMembers(): Promise<void>;
+export declare function workspaceCheckSubdomain(subdomain: string): Promise<void>;