@mugwork/mug 0.1.0

package/dist/runtime/app.js

@@ -0,0 +1,399 @@
+import { Hono } from "hono";
+import { WorkspaceContext } from "./context.js";
+import { getSource, allSources } from "./source.js";
+import { getWorkflow, allWorkflows, runWorkflow, queryLogs, queryActions, findTriggeredWorkflows } from "./workflow.js";
+import { chunkText } from "./chunker.js";
+const app = new Hono();
+app.get("/health", (c) => {
+    return c.json({
+        status: "ok",
+        workspace: c.env.WORKSPACE_ID ?? "local",
+        ts: new Date().toISOString(),
+    });
+});
+app.post("/sync/:source", async (c) => {
+    const sourceName = c.req.param("source");
+    const def = getSource(sourceName);
+    if (!def) {
+        return c.json({ error: `Source "${sourceName}" not found` }, 404);
+    }
+    return runSync(c.env, def.name);
+});
+app.post("/sync", async (c) => {
+    const sources = allSources();
+    const results = {};
+    for (const def of sources) {
+        const res = await runSync(c.env, def.name);
+        results[def.name] = await res.json();
+    }
+    return c.json(results);
+});
+app.post("/api/query", async (c) => {
+    const { database, sql, params } = (await c.req.json());
+    const ctx = new WorkspaceContext(c.env);
+    const rows = await ctx.query(database, sql, params);
+    return c.json({ rows });
+});
+app.post("/api/seed", async (c) => {
+    const { database, tables } = (await c.req.json());
+    const ctx = new WorkspaceContext(c.env);
+    const stub = ctx.getDatabaseStub(database);
+    const res = await stub.fetch(new Request("https://do/seed", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ tables }),
+    }));
+    return c.json(await res.json());
+});
+app.post("/api/introspect", async (c) => {
+    const { database } = (await c.req.json());
+    const ctx = new WorkspaceContext(c.env);
+    const stub = ctx.getDatabaseStub(database);
+    const res = await stub.fetch(new Request("https://do/introspect", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({}),
+    }));
+    return c.json(await res.json());
+});
+app.post("/api/export", async (c) => {
+    const { database } = (await c.req.json());
+    const ctx = new WorkspaceContext(c.env);
+    const stub = ctx.getDatabaseStub(database);
+    const res = await stub.fetch(new Request("https://do/export", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({}),
+    }));
+    return c.json(await res.json());
+});
+app.post("/api/ai", async (c) => {
+    const body = (await c.req.json());
+    const ctx = new WorkspaceContext(c.env);
+    const result = await ctx.ai(body.model, body);
+    return c.json(result);
+});
+app.get("/workflows", (c) => {
+    return c.json({ workflows: allWorkflows().map((w) => w.name) });
+});
+app.post("/run/:workflow", async (c) => {
+    const name = c.req.param("workflow");
+    const def = getWorkflow(name);
+    if (!def) {
+        return c.json({ error: `Workflow "${name}" not found` }, 404);
+    }
+    let params;
+    try {
+        const body = await c.req.json();
+        if (body && typeof body === "object")
+            params = body;
+    }
+    catch { /* no body or not JSON — params stays undefined */ }
+    const result = await runWorkflow(name, c.env, params);
+    return c.json(result);
+});
+app.post("/agent/:name", async (c) => {
+    const name = c.req.param("name");
+    let body = {};
+    try {
+        body = (await c.req.json());
+    }
+    catch { /* no body */ }
+    if (!body.goal) {
+        return c.json({ error: "goal is required — POST { \"goal\": \"...\" }" }, 400);
+    }
+    const workspace = c.env.WORKSPACE_ID ?? "local";
+    const res = await c.env.MUG_DISPATCH.fetch(`https://mug-dispatch/agent/${workspace}/invoke`, {
+        method: "POST",
+        body: JSON.stringify({ agent: name, goal: body.goal, context: body.context }),
+        headers: {
+            "Content-Type": "application/json",
+            "X-Mug-Internal": c.env.MUG_INTERNAL_SECRET ?? "",
+        },
+    });
+    if (!res.ok) {
+        const errText = await res.text();
+        return c.json({ error: errText }, 502);
+    }
+    return c.json(await res.json());
+});
+app.get("/logs", async (c) => {
+    const limit = parseInt(c.req.query("limit") ?? "10");
+    const logs = await queryLogs(c.env, undefined, limit);
+    return c.json(logs);
+});
+app.get("/logs/:workflow", async (c) => {
+    const name = c.req.param("workflow");
+    const limit = parseInt(c.req.query("limit") ?? "10");
+    const logs = await queryLogs(c.env, name, limit);
+    return c.json(logs);
+});
+app.get("/actions", async (c) => {
+    const limit = parseInt(c.req.query("limit") ?? "50");
+    const connector = c.req.query("connector") ?? undefined;
+    const operation = c.req.query("operation") ?? undefined;
+    const runId = c.req.query("run") ?? undefined;
+    const actions = await queryActions(c.env, { workflowRunId: runId, connector, operation }, limit);
+    return c.json(actions);
+});
+app.post("/api/notify", async (c) => {
+    const body = (await c.req.json());
+    const ctx = new WorkspaceContext(c.env);
+    await ctx.notify[body.channel]({
+        to: body.to,
+        message: body.message,
+        blocks: body.blocks,
+        thread_ts: body.thread_ts,
+        unfurl_links: body.unfurl_links,
+        unfurl_media: body.unfurl_media,
+    });
+    return c.json({ status: "sent", channel: body.channel, to: body.to });
+});
+app.post("/changesets/:database", async (c) => {
+    const database = c.req.param("database");
+    const ctx = new WorkspaceContext(c.env);
+    const body = await c.req.json().catch(() => ({}));
+    try {
+        const stub = ctx.getDatabaseStub(database);
+        const res = await stub.fetch(new URL("/changesets", "http://do").toString(), {
+            method: "POST",
+            body: JSON.stringify(body),
+            headers: { "Content-Type": "application/json" },
+        });
+        const data = await res.json();
+        return c.json(data);
+    }
+    catch (e) {
+        return c.json({ error: e.message }, 500);
+    }
+});
+app.post("/rollback/:database", async (c) => {
+    const database = c.req.param("database");
+    const ctx = new WorkspaceContext(c.env);
+    const body = await c.req.json();
+    try {
+        const stub = ctx.getDatabaseStub(database);
+        const res = await stub.fetch(new URL("/rollback", "http://do").toString(), {
+            method: "POST",
+            body: JSON.stringify(body),
+            headers: { "Content-Type": "application/json" },
+        });
+        const data = await res.json();
+        return c.json(data);
+    }
+    catch (e) {
+        return c.json({ error: e.message }, 500);
+    }
+});
+async function runSync(env, sourceName) {
+    const def = getSource(sourceName);
+    if (!def) {
+        return Response.json({ error: `Source "${sourceName}" not found` }, { status: 404 });
+    }
+    const sources = JSON.parse(env.MUG_SOURCES || "{}");
+    const src = sources[sourceName];
+    const sourceCtx = {
+        credential: async (name) => {
+            if (name) {
+                const direct = env[name];
+                if (typeof direct === "string")
+                    return direct;
+            }
+            if (src?.auth?.value) {
+                const resolved = env[src.auth.value];
+                if (typeof resolved === "string")
+                    return resolved;
+                return src.auth.value;
+            }
+            if (env.MUG_DISPATCH && env.MUG_INTERNAL_SECRET) {
+                const provider = name ?? sourceName;
+                const res = await env.MUG_DISPATCH.fetch(`https://mug-dispatch/credential/${env.WORKSPACE_ID}/${provider}`, { headers: { "X-Mug-Internal": env.MUG_INTERNAL_SECRET } });
+                if (res.ok) {
+                    const data = (await res.json());
+                    return data.access_token;
+                }
+            }
+            throw new Error(`No credentials for "${sourceName}"`);
+        },
+        fetch: (url, init) => {
+            if (url.includes("api.mug.work") && env.MUG_DISPATCH && env.MUG_INTERNAL_SECRET) {
+                const proxyUrl = url.replace(/https?:\/\/api\.mug\.work/, "https://mug-dispatch");
+                const headers = new Headers(init?.headers);
+                if (!headers.has("X-Mug-Internal"))
+                    headers.set("X-Mug-Internal", env.MUG_INTERNAL_SECRET);
+                return env.MUG_DISPATCH.fetch(proxyUrl, { ...init, headers });
+            }
+            return fetch(url, init);
+        },
+        lastSync: null,
+    };
+    const results = {};
+    const isLocal = !!env.WORKSPACE_DB;
+    for (const table of def.tables) {
+        const rows = await table.fetch(sourceCtx);
+        let syncRes;
+        if (isLocal) {
+            const stub = env.WORKSPACE_DB.get(env.WORKSPACE_DB.idFromName(def.database));
+            syncRes = await stub.fetch(new URL("/sync", "http://do").toString(), {
+                method: "POST",
+                body: JSON.stringify({ table: table.name, primaryKey: table.primaryKey, rows }),
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        else {
+            syncRes = await env.MUG_DATA.fetch(`https://mug-data/workspace/${env.WORKSPACE_ID}/db/${def.database}/sync`, {
+                method: "POST",
+                body: JSON.stringify({ table: table.name, primaryKey: table.primaryKey, rows }),
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Mug-Internal": env.MUG_INTERNAL_SECRET,
+                },
+            });
+        }
+        const syncData = await syncRes.json();
+        results[table.name] = syncData;
+        if (!isLocal && env.MUG_DISPATCH && sourceCtx.lastSync) {
+            const opsCount = (syncData.upserted ?? 0) + (syncData.deleted ?? 0);
+            if (opsCount > 0) {
+                await env.MUG_DISPATCH.fetch(`https://mug-dispatch/meter/${env.WORKSPACE_ID}/increment`, {
+                    method: "POST",
+                    body: JSON.stringify({ dimension: "operations", delta: opsCount, source: `sync:${sourceName}-${table.name}` }),
+                    headers: { "Content-Type": "application/json", "X-Mug-Internal": env.MUG_INTERNAL_SECRET },
+                }).catch(() => { });
+            }
+        }
+        try {
+            const embedResult = await embedSyncBatch(env, def.database, table.name, table.primaryKey, rows, syncData.deletedPks);
+            if (embedResult.vectors > 0 || embedResult.deletedVectors > 0) {
+                results[table.name].vectors = embedResult;
+            }
+        }
+        catch (err) {
+            console.error(`[${env.WORKSPACE_ID ?? "local"}] Embedding failed for ${table.name}:`, err);
+        }
+        const isInitialSync = !sourceCtx.lastSync;
+        const hasInserts = (syncData.upserted ?? 0) > 0;
+        const hasDeletes = (syncData.deleted ?? 0) > 0;
+        if (hasInserts || hasDeletes) {
+            const events = [];
+            if (hasInserts)
+                events.push("insert");
+            if (hasDeletes)
+                events.push("delete");
+            for (const event of events) {
+                const triggered = findTriggeredWorkflows(sourceName, table.name, event, isInitialSync);
+                for (const wf of triggered) {
+                    const triggerParams = {
+                        _trigger: { source: sourceName, table: table.name, event, count: event === "insert" ? syncData.upserted : syncData.deleted },
+                        rows: event === "insert" ? rows : undefined,
+                        deletedPks: event === "delete" ? syncData.deletedPks : undefined,
+                    };
+                    if (isLocal) {
+                        runWorkflow(wf.name, env, triggerParams).catch((err) => {
+                            console.error(`[trigger] ${wf.name} failed: ${err.message}`);
+                        });
+                    }
+                    else if (env.MUG_DISPATCH) {
+                        env.MUG_DISPATCH.fetch(`https://mug-dispatch/trigger/${env.WORKSPACE_ID}/create-workflow`, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json", "X-Mug-Internal": env.MUG_INTERNAL_SECRET },
+                            body: JSON.stringify({ workflow: wf.name, ...triggerParams }),
+                        }).catch(() => { });
+                    }
+                }
+            }
+        }
+    }
+    if (!isLocal && env.MUG_DISPATCH && env.MUG_DATA) {
+        try {
+            const countRes = await env.MUG_DATA.fetch(`https://mug-data/workspace/${env.WORKSPACE_ID}/db/${def.database}/row-count`, { headers: { "X-Mug-Internal": env.MUG_INTERNAL_SECRET } });
+            if (countRes.ok) {
+                const { totalRows } = await countRes.json();
+                await env.MUG_DISPATCH.fetch(`https://mug-dispatch/meter/${env.WORKSPACE_ID}/set`, {
+                    method: "POST",
+                    body: JSON.stringify({ dimension: "records", value: totalRows, source: `sync:${sourceName}` }),
+                    headers: { "Content-Type": "application/json", "X-Mug-Internal": env.MUG_INTERNAL_SECRET },
+                }).catch(() => { });
+            }
+        }
+        catch { }
+    }
+    return Response.json({ source: sourceName, database: def.database, tables: results });
+}
+async function embedSyncBatch(env, database, tableName, primaryKey, rows, deletedPks) {
+    if (env.WORKSPACE_DB) {
+        return { embedded: 0, vectors: 0, deletedVectors: 0 };
+    }
+    const ctx = new WorkspaceContext(env);
+    const skipCols = new Set([primaryKey, "_mug_synced_at", "_mug_deleted_at"]);
+    const rowTexts = [];
+    for (const row of rows) {
+        const pk = String(row[primaryKey]);
+        const parts = [];
+        for (const [key, value] of Object.entries(row)) {
+            if (skipCols.has(key) || typeof value !== "string" || !value.trim())
+                continue;
+            parts.push(value);
+        }
+        if (parts.length > 0) {
+            rowTexts.push({ pk, text: parts.join(" ") });
+        }
+    }
+    let vectorCount = 0;
+    if (rowTexts.length > 0) {
+        const allChunks = [];
+        for (const { pk, text } of rowTexts) {
+            for (const chunk of chunkText(text)) {
+                allChunks.push({ pk, chunkIndex: chunk.index, totalChunks: chunk.total, text: chunk.text });
+            }
+        }
+        const vectors = await ctx.embed(allChunks.map((c) => c.text));
+        const records = allChunks.map((c, i) => ({
+            id: c.totalChunks === 1 ? `${tableName}:${c.pk}` : `${tableName}:${c.pk}:chunk_${c.chunkIndex}`,
+            values: vectors[i],
+            metadata: {
+                database,
+                table: tableName,
+                pk_column: primaryKey,
+                primary_key: c.pk,
+                chunk_index: c.chunkIndex,
+                total_chunks: c.totalChunks,
+                synced_at: new Date().toISOString(),
+            },
+        }));
+        for (let i = 0; i < records.length; i += 1000) {
+            await env.MUG_DISPATCH.fetch(`https://mug-dispatch/vector/${env.WORKSPACE_ID}/upsert`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "X-Mug-Internal": env.MUG_INTERNAL_SECRET },
+                body: JSON.stringify({ vectors: records.slice(i, i + 1000).map(r => ({ id: r.id, values: r.values, metadata: r.metadata })) }),
+            });
+        }
+        vectorCount = records.length;
+    }
+    let deletedVectors = 0;
+    if (deletedPks?.length) {
+        const idsToDelete = deletedPks.map((pk) => `${tableName}:${pk}`);
+        await env.MUG_DISPATCH.fetch(`https://mug-dispatch/vector/${env.WORKSPACE_ID}/delete`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Mug-Internal": env.MUG_INTERNAL_SECRET },
+            body: JSON.stringify({ ids: idsToDelete }),
+        });
+        deletedVectors = idsToDelete.length;
+    }
+    return { embedded: rowTexts.length, vectors: vectorCount, deletedVectors };
+}
+export default {
+    fetch: app.fetch,
+    async scheduled(_event, env) {
+        console.log(`[${env.WORKSPACE_ID ?? "local"}] Cron triggered at ${new Date().toISOString()}`);
+        for (const def of allSources()) {
+            try {
+                await runSync(env, def.name);
+                console.log(`[${env.WORKSPACE_ID ?? "local"}] Synced ${def.name}`);
+            }
+            catch (err) {
+                console.error(`[${env.WORKSPACE_ID ?? "local"}] Sync failed for ${def.name}:`, err);
+            }
+        }
+    },
+};

package/dist/runtime/chunker.d.ts

@@ -0,0 +1,6 @@
+export interface Chunk {
+    text: string;
+    index: number;
+    total: number;
+}
+export declare function chunkText(text: string): Chunk[];

package/dist/runtime/chunker.js

@@ -0,0 +1,30 @@
+const SINGLE_CHUNK_LIMIT = 512;
+const WINDOW_SIZE = 400;
+const OVERLAP = 100;
+function estimateTokens(text) {
+    return Math.ceil(text.split(/\s+/).length * 1.3);
+}
+export function chunkText(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return [];
+    if (estimateTokens(trimmed) <= SINGLE_CHUNK_LIMIT) {
+        return [{ text: trimmed, index: 0, total: 1 }];
+    }
+    const words = trimmed.split(/\s+/);
+    const wordsPerChunk = Math.floor(WINDOW_SIZE / 1.3);
+    const overlapWords = Math.floor(OVERLAP / 1.3);
+    const step = wordsPerChunk - overlapWords;
+    const chunks = [];
+    for (let i = 0; i < words.length; i += step) {
+        const slice = words.slice(i, i + wordsPerChunk);
+        if (slice.length === 0)
+            break;
+        chunks.push({ text: slice.join(" "), index: chunks.length, total: 0 });
+        if (i + wordsPerChunk >= words.length)
+            break;
+    }
+    for (const c of chunks)
+        c.total = chunks.length;
+    return chunks;
+}

package/dist/runtime/context.d.ts

@@ -0,0 +1,115 @@
+import type { Env } from "./types.js";
+import type { CollectOptions } from "./form-types.js";
+import type { Tier, RoutingConfig } from "./ai-router.js";
+export interface SearchOptions {
+    source?: string;
+    limit?: number;
+    filter?: Record<string, string>;
+}
+export interface SearchResult {
+    score: number;
+    table: string;
+    primaryKey: string;
+    row: Record<string, unknown>;
+}
+export interface AskOptions {
+    source?: string;
+    limit?: number;
+    model?: string;
+    system?: string;
+}
+export interface AskResult {
+    answer: string;
+    sources: SearchResult[];
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        search_results: number;
+    };
+}
+interface AiOptions {
+    prompt: string;
+    system?: string;
+    maxTokens?: number;
+    routing?: RoutingConfig;
+    billing?: string;
+}
+interface AiResponse {
+    text: string;
+    model: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+    routing?: {
+        tier: Tier;
+        model: string;
+        provider: string;
+        reason: string;
+    };
+}
+interface NotifyOptions {
+    to: string;
+    message: string;
+    subject?: string;
+    fromName?: string;
+    cta?: {
+        label: string;
+        url: string;
+    };
+    blocks?: unknown[];
+    thread_ts?: string;
+    unfurl_links?: boolean;
+    unfurl_media?: boolean;
+}
+export declare class WorkspaceContext {
+    private env;
+    private isLocal;
+    constructor(env: Env);
+    getDatabaseStub(database: string): DurableObjectStub;
+    query(database: string, sql: string, params?: (string | number | null)[]): Promise<Record<string, unknown>[]>;
+    exec(database: string, sql: string, params?: (string | number | null)[], changeset?: {
+        id: string;
+        source: string;
+    }): Promise<number>;
+    private getWorkspaceRouting;
+    private getWorkspaceBilling;
+    ai(model: string, options: AiOptions): Promise<AiResponse>;
+    embed(texts: string[]): Promise<number[][]>;
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    ask(question: string, options?: AskOptions): Promise<AskResult>;
+    surfaceUrl(surfaceId: string, path?: string): string;
+    get notify(): {
+        email: (options: NotifyOptions) => Promise<string>;
+        sms: (options: NotifyOptions) => Promise<string>;
+        slack: (options: NotifyOptions) => Promise<string>;
+        channel: (name: string, options: NotifyOptions) => Promise<string>;
+    };
+    private getBranding;
+    private sendNotification;
+    slackApiCall(method: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    file(path: string): Promise<ArrayBuffer>;
+    fileText(path: string): Promise<string>;
+    invokeAgent(name: string, options: {
+        goal: string;
+        context?: Record<string, unknown>;
+        sessionKey?: string;
+        caps?: Record<string, number>;
+    }): Promise<{
+        response: string;
+        output?: Record<string, unknown>;
+        usage: {
+            turns: number;
+            credits: number;
+        };
+        capped?: boolean;
+        cappedReason?: string;
+        status?: string;
+        pendingApproval?: {
+            tool: string;
+            args: Record<string, unknown>;
+        };
+    }>;
+    collect(options: CollectOptions): Promise<string>;
+}
+export {};