@mugwork/mug 0.1.0

package/dist/src/commands/sql.js

@@ -0,0 +1,142 @@
+import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { getAccountToken } from "./login.js";
+const DISPATCH_URL = "https://api.mug.work";
+const DEV_PORTS = [8787, 8788, 8789, 8790, 8791];
+async function tryPort(port, database, sql) {
+    try {
+        const res = await fetch(`http://localhost:${port}/db/${database}/query`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ sql }),
+            signal: AbortSignal.timeout(2000),
+        });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+function isReadQuery(sql) {
+    const trimmed = sql.trim().toUpperCase();
+    return trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || trimmed.startsWith("EXPLAIN");
+}
+function formatTable(rows) {
+    if (rows.length === 0)
+        return "(no rows)";
+    const cols = Object.keys(rows[0]);
+    const widths = cols.map((col) => {
+        const values = rows.map((r) => String(r[col] ?? "NULL"));
+        return Math.max(col.length, ...values.map((v) => v.length));
+    });
+    const header = cols.map((c, i) => c.padEnd(widths[i])).join("  ");
+    const separator = widths.map((w) => "-".repeat(w)).join("  ");
+    const body = rows.map((r) => cols.map((c, i) => String(r[c] ?? "NULL").padEnd(widths[i])).join("  ")).join("\n");
+    return `${header}\n${separator}\n${body}\n\n(${rows.length} row${rows.length === 1 ? "" : "s"})`;
+}
+function outputResult(rows, json) {
+    if (json) {
+        console.log(JSON.stringify(rows, null, 2));
+    }
+    else {
+        console.log(formatTable(rows));
+    }
+}
+function queryLocal(database, sql, opts) {
+    const cwd = process.cwd();
+    const dbDir = join(cwd, "databases");
+    const dbPath = join(dbDir, `${database}.db`);
+    if (!isReadQuery(sql)) {
+        mkdirSync(dbDir, { recursive: true });
+    }
+    else if (!existsSync(dbPath)) {
+        console.error(`Database not found: databases/${database}.db`);
+        console.error(`Run a source sync, use \`mug pull databases/${database}\`, or create it with a write query.`);
+        process.exit(1);
+    }
+    const db = new Database(dbPath);
+    try {
+        db.pragma("journal_mode = WAL");
+        if (isReadQuery(sql)) {
+            const rows = db.prepare(sql).all();
+            outputResult(rows, opts.json);
+        }
+        else if (sql.includes(";") && sql.trim().indexOf(";") < sql.trim().length - 1) {
+            db.exec(sql);
+            console.log("Done.");
+        }
+        else {
+            const info = db.prepare(sql).run();
+            console.log(`${info.changes} row${info.changes === 1 ? "" : "s"} changed`);
+        }
+    }
+    catch (err) {
+        console.error(`SQL error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    finally {
+        db.close();
+    }
+}
+export async function query(database, sql, opts) {
+    if (opts.production) {
+        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 token = getAccountToken();
+        try {
+            const res = await fetch(`${DISPATCH_URL}/workspace/${workspace}/query`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify({ database, sql }),
+            });
+            const data = (await res.json());
+            if (data.error) {
+                console.error(`Query failed: ${data.error}`);
+                process.exit(1);
+            }
+            outputResult(data.rows ?? [], opts.json);
+        }
+        catch (err) {
+            console.error(`Could not reach production: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+        }
+        return;
+    }
+    // --dev flag: route through dev server (old behavior)
+    if (opts.dev) {
+        const port = opts.port ? parseInt(opts.port) : undefined;
+        if (port) {
+            const result = await tryPort(port, database, sql);
+            if (!result) {
+                console.error(`Could not reach dev server on port ${port}`);
+                process.exit(1);
+            }
+            outputResult(result.rows, opts.json);
+            return;
+        }
+        for (const p of DEV_PORTS) {
+            const result = await tryPort(p, database, sql);
+            if (result) {
+                outputResult(result.rows, opts.json);
+                return;
+            }
+        }
+        console.error(`No dev server found on ports ${DEV_PORTS.join(", ")}. Is \`mug dev\` running?`);
+        process.exit(1);
+        return;
+    }
+    // Default: direct file access to databases/<db>.db
+    queryLocal(database, sql, opts);
+}

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

@@ -0,0 +1,5 @@
+interface StatusOptions {
+    json?: boolean;
+}
+export declare function status(workflow: string, instanceId: string, opts: StatusOptions): Promise<void>;
+export {};

package/dist/src/commands/status.js

@@ -0,0 +1,39 @@
+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;
+}
+export async function status(workflow, instanceId, opts) {
+    const workspace = getWorkspaceName();
+    const token = getAccountToken();
+    const res = await fetch(`${DISPATCH_URL}/workspace/${workspace}/workflow/${workflow}/${instanceId}`, { 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 statusIcon = {
+        complete: "+", errored: "x", running: "~", queued: ".", paused: "||",
+    };
+    const icon = statusIcon[data.status] ?? "?";
+    console.log(`[${icon}] ${workflow} — ${data.status}`);
+    console.log(`  instance: ${data.instanceId}`);
+    if (data.output) {
+        console.log(`\n${JSON.stringify(data.output, null, 2)}`);
+    }
+    if (data.error) {
+        console.log(`\n  Error: ${data.error}`);
+    }
+}

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

@@ -0,0 +1,7 @@
+export declare function repairScaffolding(cwd: string): void;
+export declare function syncLocalFiles(cwd: string, config: Record<string, unknown>): Promise<void>;
+export declare function syncLocalDatabases(cwd: string, config: Record<string, unknown>): Promise<void>;
+export declare function ensureSettings(mugJsonPath: string): void;
+export declare function migrateMugJsonSources(mugJsonPath: string): void;
+export declare function syncFrameworkFiles(cwd: string): number;
+export declare function sync(dir?: string): Promise<void>;