@mugwork/mug 0.1.0

package/dist/runtime/form-types.d.ts

@@ -0,0 +1,143 @@
+export interface Condition {
+    field: string;
+    op: "eq" | "neq" | "in" | "gt" | "lt" | "filled" | "empty";
+    value?: string | number | string[];
+}
+export type FieldPrefill = {
+    source: "auth";
+    column: string;
+} | {
+    source: "url";
+    param: string;
+} | {
+    source: "db";
+    table: string;
+    column: string;
+    match: {
+        column: string;
+        field?: string;
+        param?: string;
+    };
+};
+export interface ValidationRule {
+    rule: "min" | "max" | "minLength" | "maxLength" | "pattern";
+    value: number | string;
+    message: string;
+}
+export interface BaseField {
+    name: string;
+    label: string;
+    required?: boolean;
+    placeholder?: string;
+    showWhen?: Condition[];
+    default?: string | number | boolean;
+    prefill?: FieldPrefill;
+    locked?: boolean;
+    helpText?: string;
+    validate?: ValidationRule[];
+}
+export interface TextField extends BaseField {
+    type: "text" | "email" | "phone";
+    pattern?: string;
+}
+export interface NumberField extends BaseField {
+    type: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+}
+export interface SelectField extends BaseField {
+    type: "select" | "multiselect";
+    options: {
+        label: string;
+        value: string;
+    }[];
+}
+export interface DateField extends BaseField {
+    type: "date";
+    min?: string;
+    max?: string;
+}
+export interface TextareaField extends BaseField {
+    type: "textarea";
+    rows?: number;
+    maxLength?: number;
+}
+export interface FileField extends BaseField {
+    type: "file";
+    accept?: string;
+    maxSizeMb?: number;
+}
+export interface CalculatedField {
+    name: string;
+    type: "calculated";
+    label: string;
+    expression: string;
+    format?: "number" | "currency" | "percent";
+    showWhen?: Condition[];
+}
+export interface HiddenField {
+    name: string;
+    type: "hidden";
+    default?: string | number | boolean;
+    prefill?: FieldPrefill;
+    locked?: boolean;
+}
+export type FormField = TextField | NumberField | SelectField | DateField | TextareaField | FileField | CalculatedField | HiddenField;
+export interface PageBranch {
+    when: Condition[];
+    goto: string;
+}
+export interface FormPage {
+    id: string;
+    title?: string;
+    description?: string;
+    fields: FormField[];
+    showWhen?: Condition[];
+    nextPage?: string | {
+        conditions: PageBranch[];
+        default: string;
+    };
+}
+export interface EditMode {
+    table: string;
+    recordParam: string;
+    matchColumn: string;
+}
+export interface FormAccessPublic {
+    mode: "public";
+}
+export interface FormAccessIdentify {
+    mode: "identify";
+    method: "email" | "phone";
+    sessionDuration: string;
+}
+export interface FormAccessAuth {
+    mode: "auth";
+    method: "email" | "phone";
+    table: string;
+    matchColumn: string;
+    sessionDuration: string;
+    query?: string;
+}
+export type FormAccess = FormAccessPublic | FormAccessIdentify | FormAccessAuth;
+export interface FormSchema {
+    title: string;
+    description?: string;
+    submitText?: string;
+    pages: FormPage[];
+    access: FormAccess;
+    editMode?: EditMode;
+    workflow: string;
+}
+export interface CollectOptions {
+    id?: string;
+    title: string;
+    description?: string;
+    submitText?: string;
+    fields?: FormField[];
+    pages?: FormPage[];
+    access?: FormAccess;
+    editMode?: EditMode;
+    workflow: string;
+}

package/dist/runtime/form-types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/runtime.d.ts

@@ -0,0 +1,9 @@
+export { workflow } from "./workflow.js";
+export type { WorkflowContext, WorkflowOptions, WorkflowHandler, WorkflowDef, TriggerConfig, AgentInvokeOptions, AgentResult, WaitForOptions, WaitForResult, HttpOptions, HttpResult, HttpError, StepRecord, WorkflowResult, WebhookResponse, ActionResult, } from "./workflow.js";
+export { source, connector } from "./source.js";
+export type { SourceDef, SourceContext, TableDef, PaginationConfig, RateLimitConfig, SyncConfig, ErrorRetryConfig, ConnectorDef, ConnectorTableDef, TableActions, } from "./source.js";
+export type { ActionType } from "./source-types.js";
+export { agent } from "./agent-types.js";
+export type { AgentConfig, AgentModel, AgentTierRouting, AgentMemory, AgentToolGrant, AgentCaps, } from "./agent-types.js";
+export { WorkspaceDatabase } from "./do/workspace-database.js";
+export { default } from "./app.js";

package/dist/runtime/runtime.js

@@ -0,0 +1,7 @@
+// Public API for Mug workspaces — import { workflow, source, agent } from "@mugwork/mug"
+export { workflow } from "./workflow.js";
+export { source, connector } from "./source.js";
+export { agent } from "./agent-types.js";
+// Framework internals — used by deploy-generated entrypoint
+export { WorkspaceDatabase } from "./do/workspace-database.js";
+export { default } from "./app.js";

package/dist/runtime/source-types.d.ts

@@ -0,0 +1,15 @@
+export interface SourceAuth {
+    type: "bearer" | "api-key" | "basic" | "oauth2";
+    value: string;
+}
+export interface SyncEntry {
+    database: string;
+    schedule?: string;
+}
+export interface SourceConfig {
+    auth?: SourceAuth;
+    baseUrl?: string;
+    syncs: Record<string, SyncEntry>;
+}
+export type SourcesConfig = Record<string, SourceConfig>;
+export type ActionType = "read" | "create" | "update" | "delete" | "upsert";

package/dist/runtime/source-types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/source.d.ts

@@ -0,0 +1,70 @@
+export interface SourceContext {
+    credential: (name: string) => Promise<string>;
+    lastSync: string | null;
+    fetch: (url: string, init?: RequestInit) => Promise<Response>;
+}
+export interface PaginationConfig {
+    style: "cursor" | "offset" | "page" | "link-header";
+    cursorParam?: string;
+    cursorPath?: string;
+    offsetParam?: string;
+    pageParam?: string;
+    pageSizeParam?: string;
+    defaultPageSize?: number;
+    maxPageSize?: number;
+}
+export interface RateLimitConfig {
+    requestsPerSecond?: number;
+    requestsPerMinute?: number;
+}
+export interface SyncConfig {
+    filterParam?: string;
+    filterFormat?: "iso8601" | "unix" | "epoch_ms";
+    updatedAtField?: string;
+    deletedAtField?: string;
+    isDeletedField?: string;
+    deletionStrategy?: "soft-delete-field" | "tombstone-endpoint" | "full-sync-only";
+}
+export interface ErrorRetryConfig {
+    maxRetries?: number;
+    retryOn5xx?: boolean;
+    retryOn429?: boolean;
+    backoffMs?: number;
+}
+export interface TableDef {
+    name: string;
+    primaryKey: string;
+    endpoint?: string;
+    fetch: (ctx: SourceContext) => Promise<Record<string, unknown>[]>;
+    extractItems?: (body: unknown) => Record<string, unknown>[];
+    pagination?: PaginationConfig;
+    sync?: SyncConfig;
+}
+export interface SourceDef {
+    name: string;
+    description?: string;
+    database: string;
+    syncSchedule?: string;
+    tables: TableDef[];
+    baseUrl?: string;
+    rateLimits?: RateLimitConfig;
+    errorRetry?: ErrorRetryConfig;
+}
+export interface TableActions {
+    create?: (ctx: SourceContext, fields: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    update?: (ctx: SourceContext, recordId: string, fields: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    delete?: (ctx: SourceContext, recordId: string) => Promise<Record<string, unknown>>;
+    upsert?: (ctx: SourceContext, recordId: string, fields: Record<string, unknown>) => Promise<Record<string, unknown>>;
+}
+export interface ConnectorTableDef extends TableDef {
+    get?: (ctx: SourceContext, recordId: string) => Promise<Record<string, unknown> | null>;
+    actions?: TableActions;
+}
+export interface ConnectorDef extends Omit<SourceDef, "tables"> {
+    tables: ConnectorTableDef[];
+}
+export declare function source(def: SourceDef): SourceDef;
+export declare function connector(def: ConnectorDef): ConnectorDef;
+export declare function getSource(name: string): SourceDef | undefined;
+export declare function getConnector(name: string): ConnectorDef | undefined;
+export declare function allSources(): SourceDef[];

package/dist/runtime/source.js

@@ -0,0 +1,21 @@
+const registry = new Map();
+export function source(def) {
+    registry.set(def.name, def);
+    return def;
+}
+export function connector(def) {
+    registry.set(def.name, def);
+    return def;
+}
+export function getSource(name) {
+    return registry.get(name);
+}
+export function getConnector(name) {
+    const def = registry.get(name);
+    if (!def)
+        return undefined;
+    return def;
+}
+export function allSources() {
+    return [...registry.values()];
+}

package/dist/runtime/sync-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { SourceDef, SourceContext, TableDef } from "./source.js";
+export interface SyncResult {
+    table: string;
+    rows: Record<string, unknown>[];
+    syncedAt: string;
+    incremental: boolean;
+    pages?: number;
+}
+export declare function syncTable(def: SourceDef, table: TableDef, ctx: SourceContext): Promise<SyncResult>;
+export declare function syncAll(def: SourceDef, ctx: SourceContext): Promise<SyncResult[]>;

package/dist/runtime/sync-runtime.js

@@ -0,0 +1,185 @@
+export async function syncTable(def, table, ctx) {
+    const syncedAt = new Date().toISOString();
+    if (table.endpoint && table.pagination) {
+        const rows = await fetchWithPagination(def, table, ctx);
+        return { table: table.name, rows, syncedAt, incremental: !!table.sync?.filterParam && !!ctx.lastSync };
+    }
+    const rows = await fetchWithRetry(def, table, ctx);
+    return { table: table.name, rows, syncedAt, incremental: false };
+}
+export async function syncAll(def, ctx) {
+    const results = [];
+    for (const table of def.tables) {
+        results.push(await syncTable(def, table, ctx));
+        await rateLimitDelay(def.rateLimits);
+    }
+    return results;
+}
+async function fetchWithPagination(def, table, ctx) {
+    const baseUrl = def.baseUrl ?? "";
+    const endpoint = table.endpoint ?? "";
+    const pagination = table.pagination;
+    const extract = table.extractItems ?? defaultExtractItems;
+    let url = buildSyncUrl(baseUrl + endpoint, table, ctx);
+    const all = [];
+    let pages = 0;
+    while (url) {
+        const body = await authedFetchJson(url, ctx, def.errorRetry);
+        all.push(...extract(body));
+        pages++;
+        url = getNextPageUrl(body, url, pagination);
+        if (url)
+            await rateLimitDelay(def.rateLimits);
+    }
+    return all;
+}
+async function fetchWithRetry(def, table, ctx) {
+    const config = def.errorRetry ?? { maxRetries: 3, retryOn5xx: true, retryOn429: true, backoffMs: 1000 };
+    const maxRetries = config.maxRetries ?? 3;
+    let attempt = 0;
+    while (true) {
+        try {
+            return await table.fetch(ctx);
+        }
+        catch (err) {
+            attempt++;
+            if (attempt >= maxRetries)
+                throw err;
+            if (!isRetryable(err, config))
+                throw err;
+            await sleep((config.backoffMs ?? 1000) * Math.pow(2, attempt - 1));
+        }
+    }
+}
+async function authedFetchJson(url, ctx, retryConfig) {
+    const config = retryConfig ?? { maxRetries: 3, retryOn5xx: true, retryOn429: true, backoffMs: 1000 };
+    const maxRetries = config.maxRetries ?? 3;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const token = await ctx.credential("token");
+        const res = await ctx.fetch(url, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (res.ok)
+            return res.json();
+        if (res.status === 429 && config.retryOn429 !== false) {
+            const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
+            await sleep(retryAfter ?? (config.backoffMs ?? 1000) * Math.pow(2, attempt));
+            continue;
+        }
+        if (res.status >= 500 && config.retryOn5xx !== false && attempt < maxRetries) {
+            await sleep((config.backoffMs ?? 1000) * Math.pow(2, attempt));
+            continue;
+        }
+        throw new Error(`${res.status} ${res.statusText}: ${url}`);
+    }
+    throw new Error(`Max retries exceeded: ${url}`);
+}
+function buildSyncUrl(base, table, ctx) {
+    const sync = table.sync;
+    if (!sync?.filterParam || !ctx.lastSync)
+        return base;
+    const sep = base.includes("?") ? "&" : "?";
+    let value = ctx.lastSync;
+    if (sync.filterFormat === "unix") {
+        value = String(Math.floor(new Date(ctx.lastSync).getTime() / 1000));
+    }
+    else if (sync.filterFormat === "epoch_ms") {
+        value = String(new Date(ctx.lastSync).getTime());
+    }
+    return `${base}${sep}${sync.filterParam}=${encodeURIComponent(value)}`;
+}
+function getNextPageUrl(body, currentUrl, pagination) {
+    if (typeof body !== "object" || body === null)
+        return null;
+    const obj = body;
+    switch (pagination.style) {
+        case "cursor": {
+            const path = pagination.cursorPath ?? "next_cursor";
+            const cursor = deepGet(obj, path);
+            if (!cursor)
+                return null;
+            const u = new URL(currentUrl);
+            u.searchParams.set(pagination.cursorParam ?? "cursor", String(cursor));
+            return u.toString();
+        }
+        case "offset": {
+            const items = defaultExtractItems(body);
+            const pageSize = pagination.defaultPageSize ?? 100;
+            if (items.length < pageSize)
+                return null;
+            const u = new URL(currentUrl);
+            const current = parseInt(u.searchParams.get(pagination.offsetParam ?? "offset") ?? "0");
+            u.searchParams.set(pagination.offsetParam ?? "offset", String(current + pageSize));
+            return u.toString();
+        }
+        case "page": {
+            const u = new URL(currentUrl);
+            const current = parseInt(u.searchParams.get(pagination.pageParam ?? "page") ?? "1");
+            const total = (obj.total_pages ?? obj.totalPages);
+            if (total && current >= total)
+                return null;
+            const items = defaultExtractItems(body);
+            if (items.length === 0)
+                return null;
+            u.searchParams.set(pagination.pageParam ?? "page", String(current + 1));
+            return u.toString();
+        }
+        case "link-header":
+            return null;
+    }
+}
+function defaultExtractItems(body) {
+    if (Array.isArray(body))
+        return body;
+    if (typeof body !== "object" || body === null)
+        return [];
+    const obj = body;
+    for (const key of ["data", "results", "records", "items", "entries"]) {
+        if (Array.isArray(obj[key]))
+            return obj[key];
+    }
+    return [];
+}
+function deepGet(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined || typeof current !== "object")
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+async function rateLimitDelay(config) {
+    if (!config)
+        return;
+    const delay = config.requestsPerSecond
+        ? Math.ceil(1000 / config.requestsPerSecond)
+        : config.requestsPerMinute
+            ? Math.ceil(60000 / config.requestsPerMinute)
+            : 0;
+    if (delay > 0)
+        await sleep(delay);
+}
+function parseRetryAfter(header) {
+    if (!header)
+        return null;
+    const num = parseInt(header);
+    if (!isNaN(num)) {
+        return num > 1_000_000_000 ? (num * 1000 - Date.now()) : num * 1000;
+    }
+    const date = new Date(header);
+    if (!isNaN(date.getTime()))
+        return Math.max(0, date.getTime() - Date.now());
+    return null;
+}
+function isRetryable(err, config) {
+    if (err instanceof Error && err.message.includes("429") && config.retryOn429 !== false)
+        return true;
+    if (err instanceof Error && /^5\d\d/.test(err.message) && config.retryOn5xx !== false)
+        return true;
+    return false;
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,21 @@
+export interface Env {
+    WORKSPACE_ID: string;
+    ENVIRONMENT: string;
+    MUG_DATA: Fetcher;
+    MUG_AI: Fetcher;
+    MUG_NOTIFY: Fetcher;
+    MUG_DISPATCH: Fetcher;
+    MUG_INTERNAL_SECRET: string;
+    MUG_AGENT: DurableObjectNamespace;
+    MUG_SOURCES?: string;
+    MUG_BRANDING?: string;
+    MUG_AI_ROUTING?: string;
+    MUG_AI_BILLING?: string;
+    SLACK_BOT_TOKEN?: string;
+    TELNYX_API_KEY?: string;
+    TELNYX_PHONE_NUMBER?: string;
+    TWILIO_ACCOUNT_SID?: string;
+    TWILIO_AUTH_TOKEN?: string;
+    TWILIO_PHONE_NUMBER?: string;
+    WORKSPACE_DB?: DurableObjectNamespace;
+}

package/dist/runtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/workflow-entrypoint.d.ts

@@ -0,0 +1,31 @@
+import { WorkflowEntrypoint, type WorkflowEvent, type WorkflowStep } from "cloudflare:workers";
+interface MugWorkflowEnv {
+    WORKFLOWS: unknown;
+    WORKSPACE_ID: string;
+    MUG_INTERNAL_SECRET: string;
+    MUG_DATA?: Fetcher;
+    MUG_AI?: Fetcher;
+    MUG_NOTIFY?: Fetcher;
+    MUG_DISPATCH?: Fetcher;
+    MUG_AI_ROUTING?: string;
+    MUG_AI_BILLING?: string;
+    MUG_BRANDING?: string;
+    SLACK_BOT_TOKEN?: string;
+    TELNYX_API_KEY?: string;
+    TELNYX_PHONE_NUMBER?: string;
+    TWILIO_ACCOUNT_SID?: string;
+    TWILIO_AUTH_TOKEN?: string;
+    TWILIO_PHONE_NUMBER?: string;
+}
+interface MugWorkflowParams {
+    workspace: string;
+    workflow: string;
+    [key: string]: unknown;
+}
+export declare class MugWorkflow extends WorkflowEntrypoint<MugWorkflowEnv, MugWorkflowParams> {
+    run(event: WorkflowEvent<MugWorkflowParams>, step: WorkflowStep): Promise<unknown>;
+}
+declare const _default: {
+    fetch(request: Request, env: MugWorkflowEnv): Promise<Response>;
+};
+export default _default;