@mugwork/mug 0.1.0

package/dist/src/commands/issue.js

@@ -0,0 +1,191 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { createRequire } from "node:module";
+const GITHUB_REPO = "mugwork/mug";
+const GITHUB_API = `https://api.github.com/repos/${GITHUB_REPO}/issues`;
+const CATEGORIES = ["bug", "feature-request", "docs", "connector-pipeline"];
+const CATEGORY_LABELS = {
+    bug: "bug",
+    "feature-request": "enhancement",
+    docs: "documentation",
+    "connector-pipeline": "connector",
+};
+function collectContext(cwd) {
+    const require = createRequire(import.meta.url);
+    const pkg = require("../../package.json");
+    let workspaceName = null;
+    let templateVersion = null;
+    let sourceCount = 0;
+    let workflowCount = 0;
+    let agentCount = 0;
+    let formCount = 0;
+    let portalCount = 0;
+    const mugJsonPath = join(cwd, "mug.json");
+    if (existsSync(mugJsonPath)) {
+        try {
+            const config = JSON.parse(readFileSync(mugJsonPath, "utf-8"));
+            workspaceName = config.name ?? null;
+            templateVersion = config.templateVersion ?? null;
+            if (config.sources)
+                sourceCount = Object.keys(config.sources).length;
+        }
+        catch { }
+    }
+    const srcDir = join(cwd, "src");
+    if (existsSync(srcDir)) {
+        const countFiles = (subdir) => {
+            const dir = join(srcDir, subdir);
+            if (!existsSync(dir))
+                return 0;
+            try {
+                return readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).length;
+            }
+            catch {
+                return 0;
+            }
+        };
+        workflowCount = countFiles("workflows");
+        agentCount = countFiles("agents");
+    }
+    const surfacesDir = join(srcDir, "surfaces");
+    if (existsSync(surfacesDir)) {
+        try {
+            const files = readdirSync(surfacesDir).filter((f) => f.endsWith(".json"));
+            for (const f of files) {
+                try {
+                    const content = JSON.parse(readFileSync(join(surfacesDir, f), "utf-8"));
+                    if (content.type === "form")
+                        formCount++;
+                    else if (content.type === "portal")
+                        portalCount++;
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    return {
+        cliVersion: pkg.version,
+        workspaceName,
+        templateVersion,
+        sourceCount,
+        workflowCount,
+        agentCount,
+        formCount,
+        portalCount,
+    };
+}
+async function prompt(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer.trim()));
+    });
+}
+async function promptCategory(rl) {
+    console.log("\nCategory:");
+    CATEGORIES.forEach((c, i) => console.log(`  ${i + 1}. ${c}`));
+    const answer = await prompt(rl, "> ");
+    const idx = parseInt(answer, 10);
+    if (idx >= 1 && idx <= CATEGORIES.length)
+        return CATEGORIES[idx - 1];
+    const match = CATEGORIES.find((c) => c.startsWith(answer.toLowerCase()));
+    if (match)
+        return match;
+    console.log("  (defaulting to bug)");
+    return "bug";
+}
+function formatIssueBody(category, answers, ctx) {
+    let body = "";
+    body += `## What were you trying to do?\n\n${answers.doing}\n\n`;
+    body += `## What happened?\n\n${answers.happened}\n\n`;
+    body += `## What did you expect?\n\n${answers.expected}\n\n`;
+    if (answers.reproduce && answers.reproduce.toLowerCase() !== "none") {
+        body += `## Steps to reproduce\n\n${answers.reproduce}\n\n`;
+    }
+    if (answers.files && answers.files.toLowerCase() !== "none") {
+        body += `## Relevant files\n\n${answers.files}\n\n`;
+    }
+    body += `<details>\n<summary>Workspace context</summary>\n\n`;
+    body += `| | |\n|---|---|\n`;
+    body += `| CLI version | ${ctx.cliVersion} |\n`;
+    if (ctx.workspaceName)
+        body += `| Workspace | ${ctx.workspaceName} |\n`;
+    if (ctx.templateVersion)
+        body += `| Template version | ${ctx.templateVersion} |\n`;
+    body += `| Sources | ${ctx.sourceCount} |\n`;
+    body += `| Workflows | ${ctx.workflowCount} |\n`;
+    body += `| Agents | ${ctx.agentCount} |\n`;
+    body += `| Forms | ${ctx.formCount} |\n`;
+    body += `| Portals | ${ctx.portalCount} |\n`;
+    body += `\n</details>\n`;
+    return body;
+}
+export async function issue(opts) {
+    const cwd = process.cwd();
+    const ctx = collectContext(cwd);
+    if (opts.attachDiagnostics) {
+        console.log("--attach-diagnostics is not yet available. Filing issue without diagnostics.\n");
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log("Filing an issue on github.com/mugwork/mug\n");
+        const category = await promptCategory(rl);
+        console.log("\nWhat were you trying to do?");
+        const doing = await prompt(rl, "> ");
+        console.log("\nWhat happened?");
+        const happened = await prompt(rl, "> ");
+        console.log("\nWhat did you expect to happen?");
+        const expected = await prompt(rl, "> ");
+        console.log("\nSteps to reproduce (or \"none\"):");
+        const reproduce = await prompt(rl, "> ");
+        console.log("\nRelevant files (comma-separated paths, or \"none\"):");
+        const files = await prompt(rl, "> ");
+        rl.close();
+        const title = doing.length > 70 ? doing.slice(0, 67) + "..." : doing;
+        const body = formatIssueBody(category, { doing, happened, expected, reproduce, files }, ctx);
+        const label = CATEGORY_LABELS[category];
+        if (opts.dryRun) {
+            console.log("\n--- DRY RUN ---");
+            console.log(`Title: ${title}`);
+            console.log(`Labels: [${label}]`);
+            console.log(`\n${body}`);
+            return;
+        }
+        const token = opts.token || process.env.MUG_GITHUB_TOKEN || process.env.GITHUB_TOKEN;
+        if (!token) {
+            console.log("\n--- No GitHub token found ---");
+            console.log("Set MUG_GITHUB_TOKEN or GITHUB_TOKEN env var, or pass --token <token>.");
+            console.log("\nIssue body (copy to github.com/mugwork/mug/issues/new):\n");
+            console.log(`Title: ${title}`);
+            console.log(`Labels: [${label}]`);
+            console.log(`\n${body}`);
+            return;
+        }
+        const res = await fetch(GITHUB_API, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/vnd.github+json",
+                "Content-Type": "application/json",
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+            body: JSON.stringify({
+                title,
+                body,
+                labels: [label],
+            }),
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            console.error(`GitHub API error (${res.status}): ${err}`);
+            console.log("\nIssue body (copy to github.com/mugwork/mug/issues/new):\n");
+            console.log(`Title: ${title}\n\n${body}`);
+            process.exit(1);
+        }
+        const data = (await res.json());
+        console.log(`\nIssue created: ${data.html_url}`);
+    }
+    finally {
+        rl.close();
+    }
+}

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

@@ -0,0 +1,9 @@
+export interface Credentials {
+    email: string;
+    token: string;
+}
+export declare function readCredentials(): Credentials | null;
+export declare function getAccountToken(): string;
+export declare function ensureDevEmail(mugJsonPath: string): void;
+export declare function login(): Promise<void>;
+export declare function whoami(): Promise<void>;

package/dist/src/commands/login.js

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { createInterface } from "node:readline";
+const API_URL = "https://api.mug.work";
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function credentialsPath() {
+    return join(homedir(), ".mug", "credentials");
+}
+export function readCredentials() {
+    const path = credentialsPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function getAccountToken() {
+    const creds = readCredentials();
+    if (!creds) {
+        console.error("Not logged in. Run `mug login` first.");
+        process.exit(1);
+    }
+    return creds.token;
+}
+export function ensureDevEmail(mugJsonPath) {
+    const creds = readCredentials();
+    if (!creds?.email)
+        return;
+    if (!existsSync(mugJsonPath))
+        return;
+    try {
+        const config = JSON.parse(readFileSync(mugJsonPath, "utf-8"));
+        if (config.dev?.email)
+            return;
+        config.dev = { ...config.dev, email: creds.email };
+        writeFileSync(mugJsonPath, JSON.stringify(config, null, 2) + "\n");
+    }
+    catch { }
+}
+function saveCredentials(creds) {
+    const path = credentialsPath();
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(creds, null, 2) + "\n", { mode: 0o600 });
+}
+export async function login() {
+    const email = await prompt("Email: ");
+    if (!email || !email.includes("@")) {
+        console.error("Valid email required.");
+        process.exit(1);
+    }
+    console.log(`Sending verification code to ${email}...`);
+    const sendRes = await fetch(`${API_URL}/auth/send-code`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email }),
+    });
+    if (!sendRes.ok) {
+        const err = (await sendRes.json());
+        console.error(`Failed: ${err.error ?? sendRes.statusText}`);
+        process.exit(1);
+    }
+    const code = await prompt("Verification code: ");
+    if (!code) {
+        console.error("No code provided.");
+        process.exit(1);
+    }
+    const verifyRes = await fetch(`${API_URL}/auth/verify`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, code }),
+    });
+    if (!verifyRes.ok) {
+        const err = (await verifyRes.json());
+        console.error(`Verification failed: ${err.error ?? verifyRes.statusText}`);
+        process.exit(1);
+    }
+    const data = (await verifyRes.json());
+    saveCredentials({ email: data.email, token: data.token });
+    console.log(`\nLogged in as ${data.email}`);
+    console.log(`Credentials saved to ~/.mug/credentials`);
+}
+export async function whoami() {
+    const creds = readCredentials();
+    if (!creds) {
+        console.log("Not logged in. Run `mug login` first.");
+        return;
+    }
+    const res = await fetch(`${API_URL}/auth/me`, {
+        headers: { Authorization: `Bearer ${creds.token}` },
+    });
+    if (!res.ok) {
+        if (res.status === 401) {
+            console.log("Session expired. Run `mug login` to re-authenticate.");
+            return;
+        }
+        console.error(`Failed: ${res.statusText}`);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    console.log(`Account: ${data.email}`);
+    const cwd = process.cwd();
+    const mugJsonPath = join(cwd, "mug.json");
+    if (existsSync(mugJsonPath)) {
+        const config = JSON.parse(readFileSync(mugJsonPath, "utf-8"));
+        const ws = data.workspaces.find((w) => w.id === config.id || w.name === config.name);
+        if (ws) {
+            console.log(`Workspace: ${ws.name} (${ws.id})`);
+            console.log(`Plan: ${ws.plan_tier}`);
+            console.log(`Role: ${ws.role}`);
+            if (ws.status === "archived")
+                console.log(`Status: archived`);
+        }
+        else if (config.name) {
+            console.log(`Workspace: ${config.name} (local only — not registered on platform)`);
+        }
+    }
+    const active = data.workspaces.filter((w) => w.status !== "archived");
+    const archived = data.workspaces.filter((w) => w.status === "archived");
+    if (active.length > 0) {
+        console.log(`\nWorkspaces:`);
+        for (const ws of active) {
+            const domain = ws.subdomain ? `${ws.subdomain}.mug.work` : `${ws.name}.mug.work`;
+            console.log(`  ${ws.name} (${ws.plan_tier}) — ${ws.role}  ${domain}`);
+        }
+    }
+    if (archived.length > 0) {
+        console.log(`\nArchived:`);
+        for (const ws of archived) {
+            const days = ws.archived_at ? Math.floor((Date.now() - new Date(ws.archived_at).getTime()) / 86400000) : 0;
+            const remaining = 365 - days;
+            console.log(`  ${ws.name} — ${remaining} days until deletion`);
+        }
+    }
+    const incoming = data.pendingInvites ?? [];
+    if (incoming.length > 0) {
+        console.log(`\nPending invites:`);
+        for (const inv of incoming) {
+            console.log(`  #${inv.id} — ${inv.workspace_name} (${inv.role}), from ${inv.invited_by_email}`);
+        }
+        console.log(`  Use "mug account accept <id>" or "mug account decline <id>"`);
+    }
+    const sent = (data.sentInvites ?? []).filter((i) => i.status === "pending");
+    if (sent.length > 0) {
+        console.log(`\nSent invites:`);
+        for (const inv of sent) {
+            console.log(`  #${inv.id} — ${inv.email} → ${inv.workspace_name} (${inv.role})`);
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+interface LogsOptions {
+    port?: string;
+    limit?: string;
+    json?: boolean;
+    production?: boolean;
+}
+export declare function logs(workflow: string | undefined, opts: LogsOptions): Promise<void>;
+export {};

package/dist/src/commands/logs.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAccountToken } from "./login.js";
+const DEV_PORTS = [8787, 8788, 8789, 8790, 8791];
+async function tryLogs(port, workflow, limit = 10) {
+    try {
+        const path = workflow ? `/logs/${workflow}?limit=${limit}` : `/logs?limit=${limit}`;
+        const res = await fetch(`http://localhost:${port}${path}`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+function formatLogs(data) {
+    if (data.length === 0)
+        return "(no runs)";
+    const lines = [];
+    for (const run of data) {
+        const icon = run.status === "complete" ? "+" : "x";
+        const dur = run.duration_ms != null ? `${run.duration_ms}ms` : "?";
+        const time = run.started_at.replace("T", " ").replace(/\.\d+Z$/, "");
+        lines.push(`[${icon}] ${run.workflow} — ${run.status} (${dur}) @ ${time}`);
+        lines.push(`    id: ${run.id}`);
+        if (run.error) {
+            lines.push(`    error: ${run.error}`);
+        }
+        if (run.steps && run.steps.length > 0) {
+            for (const step of run.steps) {
+                const dur = step.duration_ms != null ? ` (${step.duration_ms}ms)` : "";
+                const tokens = step.tokens_used ? ` [${step.tokens_used} tokens]` : "";
+                const err = step.error ? ` — ERROR: ${step.error}` : "";
+                const out = step.output && !step.error ? ` → ${step.output}` : "";
+                lines.push(`    ${step.step_name}${dur}${tokens}${out}${err}`);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+async function fetchProductionLogs(workflow, limit) {
+    const mugJsonPath = join(process.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;
+    const token = getAccountToken();
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (workflow)
+        params.set("workflow", workflow);
+    const res = await fetch(`https://api.mug.work/workspace/${name}/logs?${params}`, {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok) {
+        console.error(`Failed to fetch production logs: ${res.status} ${await res.text()}`);
+        process.exit(1);
+    }
+    return res.json();
+}
+export async function logs(workflow, opts) {
+    const limit = parseInt(opts.limit ?? "10");
+    const port = opts.port ? parseInt(opts.port) : undefined;
+    if (opts.production) {
+        const result = await fetchProductionLogs(workflow, limit);
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(formatLogs(result));
+        }
+        return;
+    }
+    if (port) {
+        const result = await tryLogs(port, workflow, limit);
+        if (!result) {
+            console.error(`Could not reach dev server on port ${port}`);
+            process.exit(1);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(formatLogs(result));
+        }
+        return;
+    }
+    for (const p of DEV_PORTS) {
+        const result = await tryLogs(p, workflow, limit);
+        if (result) {
+            if (opts.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log(formatLogs(result));
+            }
+            return;
+        }
+    }
+    const result = await fetchProductionLogs(workflow, limit);
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(formatLogs(result));
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function portalInit(name: string): void;
+export declare function portalList(): void;

package/dist/src/commands/portal.js

@@ -0,0 +1,111 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+function loadMugJson(dir) {
+    const path = join(dir, "mug.json");
+    if (!existsSync(path)) {
+        console.error("No mug.json found. Run `mug init` first.");
+        process.exit(1);
+    }
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+function titleCase(kebab) {
+    return kebab
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+}
+export function portalInit(name) {
+    const dir = process.cwd();
+    const config = loadMugJson(dir);
+    const workspace = config.name;
+    const surfacesDir = join(dir, "src", "surfaces");
+    if (!existsSync(surfacesDir)) {
+        mkdirSync(surfacesDir, { recursive: true });
+    }
+    const configPath = join(surfacesDir, `${name}.json`);
+    if (existsSync(configPath)) {
+        console.error(`Surface config already exists: src/surfaces/${name}.json`);
+        process.exit(1);
+    }
+    const portalConfig = {
+        type: "portal",
+        title: titleCase(name),
+        description: "",
+        access: { mode: "identify", method: "email" },
+        database: workspace,
+        tabs: [
+            {
+                id: "main",
+                label: titleCase(name),
+                sections: [
+                    {
+                        type: "table",
+                        query: `SELECT id, name, status, created_at FROM your_table WHERE email = :user ORDER BY created_at DESC`,
+                        primaryKey: "id",
+                        pageSize: 25,
+                        columns: [
+                            { key: "name", label: "Name" },
+                            { key: "status", label: "Status", badge: true },
+                            { key: "created_at", label: "Created", format: "date" },
+                        ],
+                        detail: {
+                            title: "{{name}}",
+                            fields: [
+                                { key: "name", label: "Name" },
+                                { key: "status", label: "Status", badge: true },
+                                { key: "created_at", label: "Created", format: "datetime" },
+                            ],
+                        },
+                        emptyMessage: "No records found.",
+                    },
+                ],
+            },
+        ],
+    };
+    writeFileSync(configPath, JSON.stringify(portalConfig, null, 2) + "\n");
+    console.log(`  [+] src/surfaces/${name}.json`);
+    console.log(`\nPortal "${name}" ready. Edit the config to set your query and columns.`);
+    console.log(`  mug dev`);
+    console.log(`  open http://localhost:8787/${name}`);
+}
+export function portalList() {
+    const dir = process.cwd();
+    const config = loadMugJson(dir);
+    const workspace = config.name;
+    const surfacesDir = join(dir, "src", "surfaces");
+    if (!existsSync(surfacesDir)) {
+        console.log("No src/surfaces/ directory found.");
+        return;
+    }
+    const files = readdirSync(surfacesDir).filter((f) => f.endsWith(".json"));
+    const portals = [];
+    for (const file of files) {
+        try {
+            const raw = readFileSync(join(surfacesDir, file), "utf-8");
+            const cfg = JSON.parse(raw);
+            if (cfg.type !== "portal")
+                continue;
+            const tabs = Array.isArray(cfg.tabs) ? cfg.tabs.length : 0;
+            portals.push({
+                file: `src/surfaces/${file}`,
+                id: file.replace(/\.json$/, ""),
+                title: cfg.title ?? "(untitled)",
+                tabs,
+            });
+        }
+        catch { }
+    }
+    if (portals.length === 0) {
+        console.log("No portal surfaces found. Create one with: mug portal init <name>");
+        return;
+    }
+    console.log(`Portals in workspace "${workspace}":\n`);
+    for (const p of portals) {
+        console.log(`  ${p.title} (${p.tabs} tab${p.tabs !== 1 ? "s" : ""})`);
+        console.log(`    ID: ${p.id}`);
+        console.log(`    File: ${p.file}`);
+        console.log(`    Local: http://localhost:8787/${p.id}`);
+        console.log(`    Prod:  https://${workspace}.mug.work/${p.id}`);
+        console.log();
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare function pull(target: string, opts: {
+    all?: boolean;
+}): Promise<void>;