@mugwork/mug 0.1.0

package/dist/src/commands/pull.js

@@ -0,0 +1,184 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from "node:fs";
+import { join, dirname } from "node:path";
+import Database from "better-sqlite3";
+import { getAccountToken } from "./login.js";
+import { readFilesManifest, writeFilesManifest, readDatabasesManifest, writeDatabasesManifest } from "../manifest.js";
+const API_URL = "https://api.mug.work";
+function loadConfig(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"));
+    return {
+        name: config.name,
+        id: config.id,
+        databases: config.databases ?? {},
+        connectors: config.connectors ?? {},
+    };
+}
+async function pullFile(cwd, filePath) {
+    const config = loadConfig(cwd);
+    if (!config.id) {
+        console.error("Workspace not registered. Run `mug create workspace` first.");
+        return false;
+    }
+    const token = getAccountToken();
+    const res = await fetch(`${API_URL}/workspace/${config.name}/files/read/${filePath}`, {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!res.ok) {
+        console.error(`File not found: ${filePath}`);
+        return false;
+    }
+    const content = Buffer.from(await res.arrayBuffer());
+    const localPath = join(cwd, "files", filePath);
+    mkdirSync(dirname(localPath), { recursive: true });
+    writeFileSync(localPath, content);
+    const sha256 = res.headers.get("X-File-SHA256") ?? "";
+    const manifest = readFilesManifest(cwd);
+    manifest.files[filePath] = {
+        size: content.byteLength,
+        sha256,
+        updated_at: new Date().toISOString(),
+    };
+    manifest.synced_at = new Date().toISOString();
+    writeFilesManifest(cwd, manifest);
+    console.log(`  ${filePath} (${(content.byteLength / 1024).toFixed(1)} KB)`);
+    return true;
+}
+async function pullDatabase(cwd, dbName) {
+    const config = loadConfig(cwd);
+    if (!config.id) {
+        console.error("Workspace not registered. Run `mug create workspace` first.");
+        return false;
+    }
+    const token = getAccountToken();
+    const res = await fetch(`${API_URL}/workspace/${config.name}/db/${dbName}/export`, {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(60000),
+    });
+    if (!res.ok) {
+        console.error(`Database not found or empty: ${dbName}`);
+        return false;
+    }
+    const data = (await res.json());
+    if (Object.keys(data.tables).length === 0) {
+        console.error(`Database is empty: ${dbName}`);
+        return false;
+    }
+    const dbPath = join(cwd, "databases", `${dbName}.db`);
+    if (existsSync(dbPath)) {
+        const backup = `${dbPath}.backup-${Date.now()}`;
+        writeFileSync(backup, readFileSync(dbPath));
+    }
+    const db = new Database(dbPath);
+    try {
+        db.exec("PRAGMA journal_mode=WAL");
+        const existing = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+        for (const { name } of existing) {
+            db.exec(`DROP TABLE IF EXISTS "${name}"`);
+        }
+        for (const [, tableData] of Object.entries(data.tables)) {
+            db.exec(tableData.ddl);
+            if (tableData.rows.length === 0)
+                continue;
+            const columns = Object.keys(tableData.rows[0]);
+            const placeholders = columns.map(() => "?").join(", ");
+            const tableName = tableData.ddl.match(/CREATE TABLE\s+"?([^"\s(]+)"?/i)?.[1] ?? "";
+            const insert = db.prepare(`INSERT INTO "${tableName}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`);
+            const insertMany = db.transaction((rows) => {
+                for (const row of rows) {
+                    insert.run(...columns.map((c) => {
+                        const v = row[c];
+                        if (v === null || v === undefined)
+                            return null;
+                        if (typeof v === "object")
+                            return JSON.stringify(v);
+                        return v;
+                    }));
+                }
+            });
+            insertMany(tableData.rows);
+        }
+    }
+    finally {
+        db.close();
+    }
+    const manifest = readDatabasesManifest(cwd);
+    const tableCount = Object.keys(data.tables).length;
+    const rowCount = Object.values(data.tables).reduce((sum, t) => sum + t.rows.length, 0);
+    const sizeMb = Math.round(statSync(dbPath).size / 1024 / 1024 * 10) / 10;
+    manifest.databases[dbName] = {
+        size_mb: sizeMb,
+        tables: Object.fromEntries(Object.entries(data.tables).map(([tName, tData]) => {
+            const db2 = new Database(dbPath, { readonly: true });
+            const columns = db2.prepare(`PRAGMA table_info("${tName}")`).all().map((c) => ({
+                name: String(c.name),
+                type: String(c.type || "TEXT"),
+            }));
+            db2.close();
+            return [tName, { columns, row_count: tData.rows.length }];
+        })),
+        updated_at: new Date().toISOString(),
+    };
+    manifest.synced_at = new Date().toISOString();
+    writeDatabasesManifest(cwd, manifest);
+    console.log(`  ${dbName}: ${tableCount} table${tableCount !== 1 ? "s" : ""}, ${rowCount} row${rowCount !== 1 ? "s" : ""} (${sizeMb} MB)`);
+    return true;
+}
+export async function pull(target, opts) {
+    const cwd = process.cwd();
+    if (opts.all) {
+        const config = loadConfig(cwd);
+        if (!config.id) {
+            console.error("Workspace not registered. Run `mug create workspace` first.");
+            process.exit(1);
+        }
+        const filesManifest = readFilesManifest(cwd);
+        const dbManifest = readDatabasesManifest(cwd);
+        const fileCount = Object.keys(filesManifest.files).length;
+        const dbCount = Object.keys(dbManifest.databases).length;
+        if (fileCount === 0 && dbCount === 0) {
+            console.log("Nothing to pull. Run `mug sync` first to fetch remote manifests.");
+            return;
+        }
+        let totalSize = 0;
+        for (const f of Object.values(filesManifest.files))
+            totalSize += f.size;
+        for (const d of Object.values(dbManifest.databases))
+            totalSize += d.size_mb * 1024 * 1024;
+        console.log(`Pulling ${fileCount} file${fileCount !== 1 ? "s" : ""} and ${dbCount} database${dbCount !== 1 ? "s" : ""} (~${(totalSize / 1024 / 1024).toFixed(1)} MB)...`);
+        let pulled = 0;
+        for (const filePath of Object.keys(filesManifest.files)) {
+            if (await pullFile(cwd, filePath))
+                pulled++;
+        }
+        for (const dbName of Object.keys(dbManifest.databases)) {
+            if (await pullDatabase(cwd, dbName))
+                pulled++;
+        }
+        console.log(`Pulled ${pulled} item${pulled !== 1 ? "s" : ""}.`);
+        return;
+    }
+    if (!target) {
+        console.error("Usage: mug pull <files/path> or mug pull <databases/name> or mug pull --all");
+        process.exit(1);
+    }
+    if (target.startsWith("files/")) {
+        const filePath = target.slice("files/".length);
+        console.log("Pulling file...");
+        await pullFile(cwd, filePath);
+    }
+    else if (target.startsWith("databases/")) {
+        const dbName = target.slice("databases/".length).replace(/\.db$/, "");
+        console.log("Pulling database...");
+        await pullDatabase(cwd, dbName);
+    }
+    else {
+        console.error(`Unknown target: ${target}. Use files/<path> or databases/<name>.`);
+        process.exit(1);
+    }
+}

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

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

package/dist/src/commands/push.js

@@ -0,0 +1,183 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { getAccountToken } from "./login.js";
+import { readDatabasesManifest, writeDatabasesManifest, readFilesManifest, writeFilesManifest } from "../manifest.js";
+const API_URL = "https://api.mug.work";
+function loadConfig(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"));
+    return { name: config.name, id: config.id };
+}
+async function pushDatabase(cwd, dbName) {
+    const config = loadConfig(cwd);
+    if (!config.id) {
+        console.error("Workspace not registered. Run `mug deploy` first.");
+        return false;
+    }
+    const dbPath = join(cwd, "databases", `${dbName}.db`);
+    if (!existsSync(dbPath)) {
+        console.error(`Database not found: databases/${dbName}.db`);
+        return false;
+    }
+    const db = new Database(dbPath, { readonly: true });
+    try {
+        const tableRows = db.prepare("SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+        if (tableRows.length === 0) {
+            console.error(`Database is empty: ${dbName}`);
+            return false;
+        }
+        const tables = {};
+        let totalRows = 0;
+        for (const { name, sql: ddl } of tableRows) {
+            const rows = db.prepare(`SELECT * FROM "${name}"`).all();
+            tables[name] = { ddl, rows };
+            totalRows += rows.length;
+        }
+        const token = getAccountToken();
+        const res = await fetch(`${API_URL}/workspace/${config.name}/db/${dbName}/upload`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ tables }),
+            signal: AbortSignal.timeout(60000),
+        });
+        if (!res.ok) {
+            console.error(`Push failed: ${res.status} ${await res.text()}`);
+            return false;
+        }
+        const manifest = readDatabasesManifest(cwd);
+        const sizeMb = Math.round(statSync(dbPath).size / 1024 / 1024 * 10) / 10;
+        manifest.databases[dbName] = {
+            size_mb: sizeMb,
+            tables: Object.fromEntries(tableRows.map(({ name }) => {
+                const columns = db.prepare(`PRAGMA table_info("${name}")`).all().map((c) => ({
+                    name: String(c.name),
+                    type: String(c.type || "TEXT"),
+                }));
+                return [name, { columns, row_count: tables[name].rows.length }];
+            })),
+            updated_at: new Date().toISOString(),
+        };
+        manifest.synced_at = new Date().toISOString();
+        writeDatabasesManifest(cwd, manifest);
+        console.log(`  ${dbName}: ${tableRows.length} table${tableRows.length !== 1 ? "s" : ""}, ${totalRows} row${totalRows !== 1 ? "s" : ""} (${sizeMb} MB)`);
+        return true;
+    }
+    finally {
+        db.close();
+    }
+}
+async function pushFile(cwd, filePath) {
+    const config = loadConfig(cwd);
+    if (!config.id) {
+        console.error("Workspace not registered. Run `mug deploy` first.");
+        return false;
+    }
+    const localPath = join(cwd, "files", filePath);
+    if (!existsSync(localPath)) {
+        console.error(`File not found: files/${filePath}`);
+        return false;
+    }
+    const content = readFileSync(localPath);
+    const token = getAccountToken();
+    const res = await fetch(`${API_URL}/workspace/${config.name}/files/upload`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/octet-stream",
+            "X-File-Path": filePath,
+        },
+        body: content,
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!res.ok) {
+        console.error(`Push failed: ${res.status} ${await res.text()}`);
+        return false;
+    }
+    const sha256 = res.headers.get("X-File-SHA256") ?? "";
+    const manifest = readFilesManifest(cwd);
+    manifest.files[filePath] = {
+        size: content.byteLength,
+        sha256,
+        updated_at: new Date().toISOString(),
+    };
+    manifest.synced_at = new Date().toISOString();
+    writeFilesManifest(cwd, manifest);
+    console.log(`  ${filePath} (${(content.byteLength / 1024).toFixed(1)} KB)`);
+    return true;
+}
+export async function push(target, opts) {
+    const cwd = process.cwd();
+    if (opts.all) {
+        const config = loadConfig(cwd);
+        if (!config.id) {
+            console.error("Workspace not registered. Run `mug deploy` first.");
+            process.exit(1);
+        }
+        const dbDir = join(cwd, "databases");
+        const filesDir = join(cwd, "files");
+        const dbFiles = existsSync(dbDir)
+            ? readdirSync(dbDir).filter((f) => f.endsWith(".db"))
+            : [];
+        const fileList = existsSync(filesDir)
+            ? collectFiles(filesDir, "")
+            : [];
+        if (dbFiles.length === 0 && fileList.length === 0) {
+            console.log("Nothing to push. No databases or files found locally.");
+            return;
+        }
+        console.log(`Pushing ${dbFiles.length} database${dbFiles.length !== 1 ? "s" : ""} and ${fileList.length} file${fileList.length !== 1 ? "s" : ""}...`);
+        let pushed = 0;
+        for (const dbFile of dbFiles) {
+            const dbName = dbFile.replace(/\.db$/, "");
+            if (await pushDatabase(cwd, dbName))
+                pushed++;
+        }
+        for (const filePath of fileList) {
+            if (await pushFile(cwd, filePath))
+                pushed++;
+        }
+        console.log(`Pushed ${pushed} item${pushed !== 1 ? "s" : ""}.`);
+        return;
+    }
+    if (!target) {
+        console.error("Usage: mug push <databases/name> or mug push <files/path> or mug push --all");
+        process.exit(1);
+    }
+    if (target.startsWith("databases/")) {
+        const dbName = target.slice("databases/".length).replace(/\.db$/, "");
+        console.log("Pushing database...");
+        await pushDatabase(cwd, dbName);
+    }
+    else if (target.startsWith("files/")) {
+        const filePath = target.slice("files/".length);
+        console.log("Pushing file...");
+        await pushFile(cwd, filePath);
+    }
+    else {
+        console.error(`Unknown target: ${target}. Use databases/<name> or files/<path>.`);
+        process.exit(1);
+    }
+}
+function collectFiles(dir, prefix) {
+    const results = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith("."))
+            continue;
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            results.push(...collectFiles(join(dir, entry.name), rel));
+        }
+        else {
+            results.push(rel);
+        }
+    }
+    return results;
+}

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

@@ -0,0 +1,6 @@
+interface RunOptions {
+    port?: string;
+    production?: boolean;
+}
+export declare function run(workflow: string, opts: RunOptions): Promise<void>;
+export {};

package/dist/src/commands/run.js

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAccountToken } from "./login.js";
+const DISPATCH_URL = "https://api.mug.work";
+const DEV_PORTS = [8787, 8788, 8789, 8790, 8791];
+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;
+}
+async function tryRun(port, workflow) {
+    try {
+        const res = await fetch(`http://localhost:${port}/run/${workflow}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            signal: AbortSignal.timeout(60_000),
+        });
+        if (res.status === 404)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+function formatResult(result) {
+    const lines = [];
+    const icon = result.status === "complete" ? "+" : "x";
+    lines.push(`[${icon}] ${result.workflow} — ${result.status} (${result.durationMs}ms)`);
+    lines.push("");
+    for (const step of result.steps) {
+        const dur = step.durationMs != null ? ` (${step.durationMs}ms)` : "";
+        const err = step.error ? ` — ERROR: ${step.error}` : "";
+        lines.push(`  ${step.name}${dur}${err}`);
+    }
+    if (result.error) {
+        lines.push("");
+        lines.push(`Error: ${result.error}`);
+    }
+    if (result.result != null) {
+        lines.push("");
+        lines.push(JSON.stringify(result.result, null, 2));
+    }
+    return lines.join("\n");
+}
+export async function run(workflow, opts) {
+    if (opts.production) {
+        const workspace = getWorkspaceName();
+        const token = getAccountToken();
+        console.log(`Creating workflow instance: ${workflow} (production)...`);
+        const res = await fetch(`${DISPATCH_URL}/workspace/${workspace}/workflow/${workflow}`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({}),
+        });
+        const data = await res.json();
+        if (!res.ok || data.error) {
+            console.error(`Failed: ${data.error ?? res.statusText}`);
+            process.exit(1);
+        }
+        console.log(`Instance created.`);
+        console.log(`  id: ${data.instanceId}`);
+        console.log(`\nCheck status: mug status ${workflow} ${data.instanceId}`);
+        return;
+    }
+    if (opts.port) {
+        const result = await tryRun(parseInt(opts.port), workflow);
+        if (!result) {
+            console.error(`Workflow "${workflow}" not found or dev server not reachable on port ${opts.port}`);
+            process.exit(1);
+        }
+        console.log(formatResult(result));
+        return;
+    }
+    for (const port of DEV_PORTS) {
+        const result = await tryRun(port, workflow);
+        if (result) {
+            console.log(formatResult(result));
+            return;
+        }
+    }
+    console.error(`No dev server found on ports ${DEV_PORTS.join(", ")}. Is \`mug dev\` running?`);
+    process.exit(1);
+}

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

@@ -0,0 +1,7 @@
+declare function readSecrets(cwd: string): Record<string, string>;
+export declare function secretSet(keyValue: string, opts: {
+    production?: boolean;
+}): Promise<void>;
+export declare function secretList(): void;
+export declare function secretRemove(key: string): void;
+export { readSecrets };

package/dist/src/commands/secret.js

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+const DISPATCH_URL = "https://api.mug.work";
+function getSecretsPath(cwd) {
+    return join(cwd, ".mug", "secrets");
+}
+function readSecrets(cwd) {
+    const path = getSecretsPath(cwd);
+    if (!existsSync(path))
+        return {};
+    const content = readFileSync(path, "utf-8");
+    const secrets = {};
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq === -1)
+            continue;
+        secrets[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
+    }
+    return secrets;
+}
+function writeSecrets(cwd, secrets) {
+    const dir = join(cwd, ".mug");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const lines = ["# Workspace secrets — DO NOT commit this file"];
+    for (const [key, value] of Object.entries(secrets)) {
+        lines.push(`${key}=${value}`);
+    }
+    writeFileSync(getSecretsPath(cwd), lines.join("\n") + "\n");
+}
+import { getAccountToken } from "./login.js";
+export async function secretSet(keyValue, opts) {
+    const cwd = process.cwd();
+    const eq = keyValue.indexOf("=");
+    if (eq === -1) {
+        console.error("Usage: mug secret set KEY=VALUE");
+        process.exit(1);
+    }
+    const key = keyValue.slice(0, eq);
+    const value = keyValue.slice(eq + 1);
+    if (opts.production) {
+        const token = getAccountToken();
+        const mugJsonPath = join(cwd, "mug.json");
+        if (!existsSync(mugJsonPath)) {
+            console.error("No mug.json found. Run `mug init` first.");
+            process.exit(1);
+        }
+        const workspace = JSON.parse(readFileSync(mugJsonPath, "utf-8")).name;
+        const res = await fetch(`${DISPATCH_URL}/secret`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ key, value, workspace }),
+        });
+        const data = (await res.json());
+        if (!res.ok || data.error) {
+            console.error(`Failed: ${data.error ?? res.statusText}`);
+            process.exit(1);
+        }
+        console.log(`Set ${key} on production`);
+        return;
+    }
+    const secrets = readSecrets(cwd);
+    secrets[key] = value;
+    writeSecrets(cwd, secrets);
+    if (key.startsWith("ai.")) {
+        const provider = key.slice(3);
+        console.log(`Set ${key} in .mug/secrets`);
+        console.log(`  BYOK enabled for ${provider} — use "${key}" as the billing value in mug.json or ctx.ai()`);
+        console.log(`  Example: "ai": { "billing": { "powerful": "${key}" } }`);
+    }
+    else {
+        console.log(`Set ${key} in .mug/secrets`);
+    }
+}
+export function secretList() {
+    const cwd = process.cwd();
+    const secrets = readSecrets(cwd);
+    const keys = Object.keys(secrets);
+    if (keys.length === 0) {
+        console.log("No secrets configured. Run `mug secret set KEY=VALUE` to add one.");
+        return;
+    }
+    console.log("Local secrets (.mug/secrets):");
+    for (const key of keys) {
+        console.log(`  ${key}`);
+    }
+}
+export function secretRemove(key) {
+    const cwd = process.cwd();
+    const secrets = readSecrets(cwd);
+    if (!(key in secrets)) {
+        console.error(`Secret "${key}" not found.`);
+        process.exit(1);
+    }
+    delete secrets[key];
+    writeSecrets(cwd, secrets);
+    console.log(`Removed ${key} from .mug/secrets`);
+}
+export { readSecrets };

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

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

package/dist/src/commands/shutdown.js

@@ -0,0 +1,46 @@
+import { readPidFile } from "./dev.js";
+import { unlinkSync } from "node:fs";
+import { join } from "node:path";
+export async function shutdown() {
+    const cwd = process.cwd();
+    const pidData = readPidFile(cwd);
+    if (!pidData) {
+        console.log("No dev server running (no .mug/dev.pid found).");
+        process.exit(0);
+    }
+    const { pid, workspace, userPort } = pidData;
+    try {
+        process.kill(pid, 0);
+    }
+    catch {
+        console.log(`Dev server for "${workspace}" (PID ${pid}) is not running. Cleaning up PID file.`);
+        try {
+            unlinkSync(join(cwd, ".mug", "dev.pid"));
+        }
+        catch { }
+        process.exit(0);
+    }
+    console.log(`Stopping "${workspace}" dev server (PID ${pid}, port ${userPort})...`);
+    process.kill(pid, "SIGTERM");
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        await new Promise(r => setTimeout(r, 200));
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            console.log("Dev server stopped.");
+            process.exit(0);
+        }
+    }
+    console.warn("Dev server did not exit in 5s — sending SIGKILL.");
+    try {
+        process.kill(pid, "SIGKILL");
+    }
+    catch { }
+    try {
+        unlinkSync(join(cwd, ".mug", "dev.pid"));
+    }
+    catch { }
+    process.exit(0);
+}

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

@@ -0,0 +1,8 @@
+interface QueryOptions {
+    json?: boolean;
+    production?: boolean;
+    dev?: boolean;
+    port?: string;
+}
+export declare function query(database: string, sql: string, opts: QueryOptions): Promise<void>;
+export {};