@mugwork/mug 0.1.0

package/dist/runtime/context.js

@@ -0,0 +1,440 @@
+import { scoreComplexity, resolveModel, parseModelSpec, resolveBilling } from "./ai-router.js";
+function internalHeaders(env) {
+    return {
+        "Content-Type": "application/json",
+        "X-Mug-Internal": env.MUG_INTERNAL_SECRET ?? "",
+    };
+}
+function titleCase(slug) {
+    return (slug ?? "Mug").split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+export class WorkspaceContext {
+    env;
+    isLocal;
+    constructor(env) {
+        this.env = env;
+        this.isLocal = !!env.WORKSPACE_DB;
+    }
+    getDatabaseStub(database) {
+        if (!this.env.WORKSPACE_DB)
+            throw new Error("WORKSPACE_DB binding not available");
+        return this.env.WORKSPACE_DB.get(this.env.WORKSPACE_DB.idFromName(database));
+    }
+    async query(database, sql, params) {
+        if (this.isLocal) {
+            const stub = this.env.WORKSPACE_DB.get(this.env.WORKSPACE_DB.idFromName(database));
+            const res = await stub.fetch(new URL("/query", "http://do").toString(), {
+                method: "POST",
+                body: JSON.stringify({ sql, params }),
+                headers: { "Content-Type": "application/json" },
+            });
+            const data = (await res.json());
+            return data.rows;
+        }
+        const res = await this.env.MUG_DATA.fetch(`https://mug-data/workspace/${this.env.WORKSPACE_ID}/db/${database}/query`, {
+            method: "POST",
+            body: JSON.stringify({ sql, params }),
+            headers: internalHeaders(this.env),
+        });
+        const data = (await res.json());
+        return data.rows;
+    }
+    async exec(database, sql, params, changeset) {
+        const csHeaders = {};
+        if (changeset?.id)
+            csHeaders["X-Changeset-Id"] = changeset.id;
+        if (changeset?.source)
+            csHeaders["X-Changeset-Source"] = changeset.source;
+        if (this.isLocal) {
+            const stub = this.env.WORKSPACE_DB.get(this.env.WORKSPACE_DB.idFromName(database));
+            const res = await stub.fetch(new URL("/exec", "http://do").toString(), {
+                method: "POST",
+                body: JSON.stringify({ sql, params }),
+                headers: { "Content-Type": "application/json", ...csHeaders },
+            });
+            const data = (await res.json());
+            return data.changes;
+        }
+        const res = await this.env.MUG_DATA.fetch(`https://mug-data/workspace/${this.env.WORKSPACE_ID}/db/${database}/exec`, {
+            method: "POST",
+            body: JSON.stringify({ sql, params }),
+            headers: { ...internalHeaders(this.env), ...csHeaders },
+        });
+        const data = (await res.json());
+        return data.changes;
+    }
+    getWorkspaceRouting() {
+        if (!this.env.MUG_AI_ROUTING)
+            return undefined;
+        try {
+            return JSON.parse(this.env.MUG_AI_ROUTING);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getWorkspaceBilling() {
+        if (!this.env.MUG_AI_BILLING)
+            return undefined;
+        try {
+            return JSON.parse(this.env.MUG_AI_BILLING);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async ai(model, options) {
+        let provider;
+        let resolvedModel;
+        let tier = null;
+        let routingMeta;
+        const tierNames = ["fast", "balanced", "powerful"];
+        if (model === "auto") {
+            const score = scoreComplexity(options.prompt, options);
+            tier = score.tier;
+            const resolved = resolveModel(tier, options.routing, this.getWorkspaceRouting());
+            provider = resolved.provider;
+            resolvedModel = resolved.model;
+            routingMeta = { tier, model: resolvedModel, provider, reason: score.reason };
+        }
+        else if (tierNames.includes(model)) {
+            tier = model;
+            const resolved = resolveModel(tier, options.routing, this.getWorkspaceRouting());
+            provider = resolved.provider;
+            resolvedModel = resolved.model;
+            routingMeta = { tier, model: resolvedModel, provider, reason: `tier:${tier}` };
+        }
+        else {
+            const parsed = parseModelSpec(model);
+            provider = parsed.provider;
+            resolvedModel = parsed.model;
+        }
+        const billingKey = resolveBilling(tier, options.billing, undefined, this.getWorkspaceBilling());
+        const billing = billingKey !== "mug-metered"
+            ? this.env[billingKey] ?? billingKey
+            : billingKey;
+        const body = JSON.stringify({
+            workspace: this.env.WORKSPACE_ID,
+            provider,
+            model: resolvedModel,
+            prompt: options.prompt,
+            system: options.system,
+            maxTokens: options.maxTokens,
+            routing: routingMeta ? { tier: routingMeta.tier, reason: routingMeta.reason } : undefined,
+            billing,
+        });
+        let res;
+        if (this.isLocal) {
+            res = await fetch("http://localhost:8787/_ai/complete", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body,
+            });
+        }
+        else {
+            res = await this.env.MUG_AI.fetch("https://mug-ai/complete", {
+                method: "POST",
+                body,
+                headers: internalHeaders(this.env),
+            });
+        }
+        if (!res.ok)
+            throw new Error(`AI request failed (${res.status}): ${await res.text()}`);
+        const data = (await res.json());
+        if (routingMeta)
+            data.routing = routingMeta;
+        return data;
+    }
+    async embed(texts) {
+        if (texts.length === 0)
+            return [];
+        const results = [];
+        for (let i = 0; i < texts.length; i += 100) {
+            const batch = texts.slice(i, i + 100);
+            const body = JSON.stringify({ workspace: this.env.WORKSPACE_ID, texts: batch });
+            let res;
+            if (this.isLocal) {
+                res = await fetch("http://localhost:8787/_ai/embed", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body,
+                });
+            }
+            else {
+                res = await this.env.MUG_AI.fetch("https://mug-ai/embed", {
+                    method: "POST",
+                    body,
+                    headers: internalHeaders(this.env),
+                });
+            }
+            if (!res.ok)
+                throw new Error(`Embed request failed (${res.status}): ${await res.text()}`);
+            const data = (await res.json());
+            results.push(...data.vectors);
+        }
+        return results;
+    }
+    async search(query, options) {
+        if (this.isLocal) {
+            throw new Error("Semantic search not available in local dev — requires deployed workspace");
+        }
+        const limit = Math.min(options?.limit ?? 10, 50);
+        const [queryVector] = await this.embed([query]);
+        const filter = { ...options?.filter };
+        if (options?.source)
+            filter.table = options.source;
+        const res = await this.env.MUG_DISPATCH.fetch(`https://mug-dispatch/vector/${this.env.WORKSPACE_ID}/query`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Mug-Internal": this.env.MUG_INTERNAL_SECRET },
+            body: JSON.stringify({
+                vector: queryVector,
+                topK: limit * 2,
+                returnMetadata: true,
+                ...(Object.keys(filter).length > 0 ? { filter } : {}),
+            }),
+        });
+        const data = await res.json();
+        const matchesArr = (data.result?.matches ?? data.matches ?? []);
+        const best = new Map();
+        for (const match of matchesArr) {
+            const meta = match.metadata;
+            if (!meta?.table || !meta?.primary_key)
+                continue;
+            const key = `${meta.table}:${meta.primary_key}`;
+            const existing = best.get(key);
+            if (!existing || match.score > existing.score) {
+                best.set(key, { score: match.score, meta });
+            }
+        }
+        const results = [];
+        for (const [, { score, meta }] of best) {
+            if (results.length >= limit)
+                break;
+            try {
+                const rows = await this.query(meta.database, `SELECT * FROM "${meta.table}" WHERE "${meta.pk_column}" = ? AND _mug_deleted_at IS NULL`, [meta.primary_key]);
+                if (rows.length > 0) {
+                    results.push({ score, table: meta.table, primaryKey: meta.primary_key, row: rows[0] });
+                }
+            }
+            catch {
+                results.push({ score, table: meta.table, primaryKey: meta.primary_key, row: {} });
+            }
+        }
+        return results;
+    }
+    async ask(question, options) {
+        const sources = await this.search(question, {
+            source: options?.source,
+            limit: options?.limit ?? 10,
+        });
+        const contextParts = [];
+        let tokenEstimate = 0;
+        for (const result of sources) {
+            const entry = `[${result.table}:${result.primaryKey} score=${result.score.toFixed(3)}]\n${JSON.stringify(result.row)}`;
+            const entryTokens = Math.ceil(entry.split(/\s+/).length * 1.3);
+            if (tokenEstimate + entryTokens > 3000)
+                break;
+            contextParts.push(entry);
+            tokenEstimate += entryTokens;
+        }
+        const baseSystem = "Answer the question based on the following business data. Cite which records informed your answer. If the data does not contain enough information, say so.";
+        const dataBlock = `\n\n--- Business Data ---\n${contextParts.join("\n\n")}`;
+        const system = (options?.system ? `${options.system}\n\n${baseSystem}` : baseSystem) + dataBlock;
+        const aiResult = await this.ai(options?.model ?? "balanced", {
+            prompt: question,
+            system,
+        });
+        return {
+            answer: aiResult.text,
+            sources,
+            usage: {
+                input_tokens: aiResult.usage.input_tokens,
+                output_tokens: aiResult.usage.output_tokens,
+                search_results: sources.length,
+            },
+        };
+    }
+    surfaceUrl(surfaceId, path) {
+        const suffix = path ?? "";
+        if (this.isLocal) {
+            return `http://localhost:8787/${surfaceId}${suffix}`;
+        }
+        return `https://${this.env.WORKSPACE_ID}.mug.work/${surfaceId}${suffix}`;
+    }
+    get notify() {
+        return {
+            email: (options) => this.sendNotification("email", options),
+            sms: (options) => this.sendNotification("sms", options),
+            slack: (options) => this.sendNotification("slack", options),
+            channel: (name, options) => this.sendNotification(name, options),
+        };
+    }
+    getBranding() {
+        if (!this.env.MUG_BRANDING)
+            return undefined;
+        try {
+            return JSON.parse(this.env.MUG_BRANDING);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async sendNotification(channel, options) {
+        const fromName = options.fromName ?? titleCase(this.env.WORKSPACE_ID);
+        const branding = this.getBranding();
+        if (this.isLocal) {
+            console.log(`[${channel}] to=${options.to}${options.subject ? ` subject=${options.subject}` : ""}`);
+            try {
+                const res = await fetch("http://localhost:8787/_notify/send", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        workspace: this.env.WORKSPACE_ID,
+                        channel,
+                        to: options.to,
+                        message: options.message,
+                        subject: options.subject,
+                        fromName,
+                        cta: options.cta,
+                        branding,
+                        ...(channel === "slack" ? {
+                            blocks: options.blocks,
+                            thread_ts: options.thread_ts,
+                            unfurl_links: options.unfurl_links,
+                            unfurl_media: options.unfurl_media,
+                            slackBotToken: this.env.SLACK_BOT_TOKEN,
+                        } : {}),
+                        ...(channel === "sms" ? {
+                            telnyxApiKey: this.env.TELNYX_API_KEY,
+                            telnyxPhoneNumber: this.env.TELNYX_PHONE_NUMBER,
+                            twilioAccountSid: this.env.TWILIO_ACCOUNT_SID,
+                            twilioAuthToken: this.env.TWILIO_AUTH_TOKEN,
+                            twilioPhoneNumber: this.env.TWILIO_PHONE_NUMBER,
+                        } : {}),
+                    }),
+                });
+                const result = await res.json();
+                if (result.status === "blocked") {
+                    console.log(`[${channel}] BLOCKED: ${result.error}`);
+                }
+                else if (result.status === "delivery_failed") {
+                    console.log(`[${channel}] DELIVERY FAILED: ${result.error ?? "no detail from provider"}`);
+                }
+                else if (result.status === "logged") {
+                    console.log(`[${channel}] logged but not delivered — missing provider credentials`);
+                }
+                return result.status;
+            }
+            catch {
+                console.log(`[${channel}] delivery skipped — dev proxy not reachable`);
+                return "skipped";
+            }
+        }
+        const res = await this.env.MUG_NOTIFY.fetch("https://mug-notify/send", {
+            method: "POST",
+            body: JSON.stringify({
+                workspace: this.env.WORKSPACE_ID,
+                channel,
+                to: options.to,
+                message: options.message,
+                subject: options.subject,
+                fromName,
+                cta: options.cta,
+                branding,
+                ...(channel === "slack" ? {
+                    blocks: options.blocks,
+                    thread_ts: options.thread_ts,
+                    unfurl_links: options.unfurl_links,
+                    unfurl_media: options.unfurl_media,
+                    slackBotToken: this.env.SLACK_BOT_TOKEN,
+                } : {}),
+                ...(channel === "sms" ? {
+                    telnyxApiKey: this.env.TELNYX_API_KEY,
+                    telnyxPhoneNumber: this.env.TELNYX_PHONE_NUMBER,
+                    twilioAccountSid: this.env.TWILIO_ACCOUNT_SID,
+                    twilioAuthToken: this.env.TWILIO_AUTH_TOKEN,
+                    twilioPhoneNumber: this.env.TWILIO_PHONE_NUMBER,
+                } : {}),
+            }),
+            headers: internalHeaders(this.env),
+        });
+        const result = await res.json();
+        return result.status;
+    }
+    async slackApiCall(method, body) {
+        const token = this.env.SLACK_BOT_TOKEN;
+        if (!token)
+            throw new Error("SLACK_BOT_TOKEN not configured");
+        const res = await fetch(`https://slack.com/api/${method}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json; charset=utf-8",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(body),
+        });
+        const data = await res.json();
+        if (!data.ok)
+            throw new Error(`Slack API ${method} failed: ${data.error ?? "unknown error"}`);
+        return data;
+    }
+    async file(path) {
+        if (this.isLocal) {
+            const res = await fetch(`http://localhost:8787/_files/${path}`);
+            if (!res.ok)
+                throw new Error(`File not found: ${path}`);
+            return res.arrayBuffer();
+        }
+        const res = await this.env.MUG_DATA.fetch(`https://mug-data/workspace/${this.env.WORKSPACE_ID}/files/read/${path}`, { headers: { "X-Mug-Internal": this.env.MUG_INTERNAL_SECRET ?? "" } });
+        if (!res.ok)
+            throw new Error(`File not found: ${path}`);
+        return res.arrayBuffer();
+    }
+    async fileText(path) {
+        const buffer = await this.file(path);
+        return new TextDecoder().decode(buffer);
+    }
+    async invokeAgent(name, options) {
+        const workspace = this.env.WORKSPACE_ID;
+        const res = await this.env.MUG_DISPATCH.fetch(`https://mug-dispatch/agent/${workspace}/invoke`, {
+            method: "POST",
+            body: JSON.stringify({ agent: name, ...options }),
+            headers: internalHeaders(this.env),
+        });
+        if (!res.ok) {
+            const errText = await res.text();
+            throw new Error(`Agent "${name}" failed: ${errText}`);
+        }
+        return res.json();
+    }
+    async collect(options) {
+        const surfaceId = options.id ?? crypto.randomUUID().slice(0, 8);
+        const workspace = this.env.WORKSPACE_ID;
+        const pages = options.pages ?? [{
+                id: "main",
+                fields: options.fields ?? [],
+            }];
+        const access = options.access ?? { mode: "public" };
+        const schema = {
+            title: options.title,
+            description: options.description,
+            submitText: options.submitText,
+            pages,
+            access,
+            editMode: options.editMode,
+            workflow: options.workflow,
+        };
+        const surfaceConfig = { workspace, surfaceId, ...schema };
+        const url = this.surfaceUrl(surfaceId);
+        if (this.isLocal) {
+            console.log(`[collect] Surface "${surfaceId}" created: ${url}`);
+            return url;
+        }
+        await this.env.MUG_DISPATCH.fetch("https://mug-dispatch/deploy-surface", {
+            method: "POST",
+            body: JSON.stringify(surfaceConfig),
+            headers: internalHeaders(this.env),
+        });
+        return url;
+    }
+}

package/dist/runtime/do/workspace-database.d.ts

@@ -0,0 +1,10 @@
+import { DurableObject } from "cloudflare:workers";
+import type { Env } from "../types.js";
+export declare class WorkspaceDatabase extends DurableObject<Env> {
+    fetch(request: Request): Promise<Response>;
+    private handleSync;
+    private ensureFTS5;
+    private handleSeed;
+    private handleIntrospect;
+    private handleExport;
+}

package/dist/runtime/do/workspace-database.js

@@ -0,0 +1,199 @@
+import { DurableObject } from "cloudflare:workers";
+function stringify(v) {
+    if (v === null || v === undefined)
+        return null;
+    if (typeof v === "object")
+        return JSON.stringify(v);
+    return String(v);
+}
+export class WorkspaceDatabase extends DurableObject {
+    async fetch(request) {
+        const url = new URL(request.url);
+        const action = url.pathname.split("/").pop();
+        try {
+            if (action === "sync") {
+                const body = (await request.json());
+                const result = this.handleSync(body);
+                return Response.json(result);
+            }
+            if (action === "seed") {
+                const body = (await request.json());
+                const result = this.handleSeed(body.tables);
+                return Response.json(result);
+            }
+            if (action === "export") {
+                return Response.json(this.handleExport());
+            }
+            if (action === "introspect") {
+                return Response.json(this.handleIntrospect());
+            }
+            const body = (await request.json());
+            const sql = this.ctx.storage.sql;
+            if (action === "query") {
+                const cursor = sql.exec(body.sql, ...(body.params ?? []));
+                return Response.json({ rows: cursor.toArray() });
+            }
+            if (action === "exec") {
+                const cursor = sql.exec(body.sql, ...(body.params ?? []));
+                return Response.json({ changes: cursor.rowsWritten });
+            }
+            return Response.json({ error: "Unknown action" }, { status: 400 });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return Response.json({ error: msg }, { status: 500 });
+        }
+    }
+    handleSync(req) {
+        const sql = this.ctx.storage.sql;
+        const { table, primaryKey, rows } = req;
+        if (rows.length === 0) {
+            return { upserted: 0, deleted: 0, deletedPks: [] };
+        }
+        const columns = Object.keys(rows[0]);
+        const allColumns = [...columns, "_mug_synced_at", "_mug_deleted_at"];
+        sql.exec(`
+      CREATE TABLE IF NOT EXISTS "${table}" (
+        ${allColumns.map((c) => `"${c}" TEXT`).join(", ")},
+        PRIMARY KEY ("${primaryKey}")
+      )
+    `);
+        const existing = sql.exec(`PRAGMA table_info("${table}")`).toArray();
+        const existingNames = new Set(existing.map((r) => r.name));
+        for (const col of allColumns) {
+            if (!existingNames.has(col)) {
+                sql.exec(`ALTER TABLE "${table}" ADD COLUMN "${col}" TEXT`);
+            }
+        }
+        const now = new Date().toISOString();
+        const incomingPks = new Set();
+        const placeholders = allColumns.map(() => "?").join(", ");
+        const updateSet = allColumns
+            .filter((c) => c !== primaryKey)
+            .map((c) => `"${c}" = excluded."${c}"`)
+            .join(", ");
+        const upsertSql = `INSERT INTO "${table}" (${allColumns.map((c) => `"${c}"`).join(", ")})
+       VALUES (${placeholders})
+       ON CONFLICT ("${primaryKey}") DO UPDATE SET ${updateSet}`;
+        for (const row of rows) {
+            const pk = String(row[primaryKey]);
+            incomingPks.add(pk);
+            const values = columns.map((c) => stringify(row[c]));
+            values.push(now);
+            values.push(null);
+            sql.exec(upsertSql, ...values);
+        }
+        // Soft-delete rows no longer in source (decision #56)
+        const allPks = sql
+            .exec(`SELECT "${primaryKey}" FROM "${table}" WHERE _mug_deleted_at IS NULL`)
+            .toArray();
+        let deleted = 0;
+        const deletedPks = [];
+        for (const row of allPks) {
+            const pk = String(row[primaryKey]);
+            if (!incomingPks.has(pk)) {
+                sql.exec(`UPDATE "${table}" SET _mug_deleted_at = ? WHERE "${primaryKey}" = ?`, now, pk);
+                deleted++;
+                deletedPks.push(pk);
+            }
+        }
+        this.ensureFTS5(table, primaryKey);
+        return { upserted: rows.length, deleted, deletedPks };
+    }
+    ensureFTS5(table, primaryKey) {
+        const sql = this.ctx.storage.sql;
+        const cols = sql.exec(`PRAGMA table_info("${table}")`).toArray();
+        const skipCols = new Set([primaryKey, "_mug_synced_at", "_mug_deleted_at"]);
+        const textCols = cols.map((c) => c.name).filter((c) => !skipCols.has(c));
+        if (textCols.length === 0)
+            return;
+        const ftsTable = `${table}_fts`;
+        const colList = textCols.map((c) => `"${c}"`).join(", ");
+        const existing = sql
+            .exec("SELECT sql FROM sqlite_master WHERE type='table' AND name=?", ftsTable)
+            .toArray();
+        if (existing.length > 0) {
+            const needsRebuild = textCols.some((c) => !existing[0].sql.includes(`"${c}"`));
+            if (!needsRebuild)
+                return;
+            sql.exec(`DROP TABLE IF EXISTS "${ftsTable}"`);
+            sql.exec(`DROP TRIGGER IF EXISTS "${table}_fts_insert"`);
+            sql.exec(`DROP TRIGGER IF EXISTS "${table}_fts_update"`);
+            sql.exec(`DROP TRIGGER IF EXISTS "${table}_fts_delete"`);
+        }
+        sql.exec(`CREATE VIRTUAL TABLE "${ftsTable}" USING fts5(${colList}, content="${table}", content_rowid=rowid)`);
+        const newColList = textCols.map((c) => `new."${c}"`).join(", ");
+        const oldColList = textCols.map((c) => `old."${c}"`).join(", ");
+        const ftsDelete = `INSERT INTO "${ftsTable}" ("${ftsTable}", rowid, ${colList})`;
+        sql.exec(`
+      CREATE TRIGGER "${table}_fts_insert" AFTER INSERT ON "${table}"
+      WHEN new._mug_deleted_at IS NULL
+      BEGIN
+        INSERT INTO "${ftsTable}" (rowid, ${colList}) VALUES (new.rowid, ${newColList});
+      END
+    `);
+        sql.exec(`
+      CREATE TRIGGER "${table}_fts_delete" AFTER DELETE ON "${table}"
+      BEGIN
+        ${ftsDelete} VALUES ('delete', old.rowid, ${oldColList});
+      END
+    `);
+        sql.exec(`
+      CREATE TRIGGER "${table}_fts_update" AFTER UPDATE ON "${table}"
+      BEGIN
+        ${ftsDelete} VALUES ('delete', old.rowid, ${oldColList});
+        INSERT INTO "${ftsTable}" (rowid, ${colList})
+          SELECT new.rowid, ${newColList} WHERE new._mug_deleted_at IS NULL;
+      END
+    `);
+        sql.exec(`INSERT INTO "${ftsTable}" (rowid, ${colList}) SELECT rowid, ${colList} FROM "${table}" WHERE _mug_deleted_at IS NULL`);
+    }
+    handleSeed(tables) {
+        const sql = this.ctx.storage.sql;
+        let tablesCreated = 0;
+        let rowsInserted = 0;
+        for (const [, tableData] of Object.entries(tables)) {
+            const tableName = tableData.ddl.match(/CREATE TABLE\s+"?([^"\s(]+)"?/i)?.[1];
+            if (!tableName)
+                continue;
+            sql.exec(`DROP TABLE IF EXISTS "${tableName}"`);
+            sql.exec(tableData.ddl);
+            tablesCreated++;
+            if (tableData.rows.length === 0)
+                continue;
+            const columns = Object.keys(tableData.rows[0]);
+            const placeholders = columns.map(() => "?").join(", ");
+            const insertSql = `INSERT INTO "${tableName}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+            for (const row of tableData.rows) {
+                const values = columns.map((c) => stringify(row[c]));
+                sql.exec(insertSql, ...values);
+                rowsInserted++;
+            }
+        }
+        return { tables_created: tablesCreated, rows_inserted: rowsInserted };
+    }
+    handleIntrospect() {
+        const sql = this.ctx.storage.sql;
+        const tableRows = sql.exec("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_cf_%' AND name NOT LIKE '__miniflare%' AND name NOT LIKE '%_fts' AND name NOT LIKE '%_fts_%' ORDER BY name").toArray();
+        const tables = tableRows.map((t) => {
+            const cols = sql.exec(`PRAGMA table_info("${t.name}")`).toArray();
+            const count = sql.exec(`SELECT count(*) as c FROM "${t.name}"`).toArray()[0].c;
+            return {
+                name: t.name,
+                rowCount: count,
+                columns: cols.map((c) => ({ name: c.name, type: c.type, notnull: !!c.notnull, pk: !!c.pk })),
+            };
+        });
+        return { tables };
+    }
+    handleExport() {
+        const sql = this.ctx.storage.sql;
+        const tableRows = sql.exec("SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_cf_%' AND name NOT LIKE '__miniflare%' AND name NOT LIKE '%_fts' AND name NOT LIKE '%_fts_%'").toArray();
+        const tables = {};
+        for (const { name, sql: ddl } of tableRows) {
+            const rows = sql.exec(`SELECT * FROM "${name}"`).toArray();
+            tables[name] = { ddl, rows };
+        }
+        return { tables };
+    }
+}