@mugwork/mug 0.1.0

package/dist/src/connector-service/verify.js

@@ -0,0 +1,575 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { readSpec, writeSpec } from "./spec-storage.js";
+import { lintSpec } from "./gather.js";
+export async function verify(workspaceRoot, slug, sourceName) {
+    const spec = readSpec(workspaceRoot, slug);
+    if (!spec)
+        throw new Error(`No spec found for "${slug}" — run gather first`);
+    const connection = loadSource(workspaceRoot, sourceName);
+    const baseUrl = connection.baseUrl ?? extractBaseUrl(spec);
+    if (!baseUrl)
+        throw new Error("No base URL found in spec or source config");
+    const endpoints = extractEndpoints(spec);
+    const headers = buildAuthHeaders(connection);
+    const probes = [];
+    probes.push(await probe1SpecQuality(spec));
+    probes.push(await probe2Auth(baseUrl, endpoints, headers));
+    if (probes[1].status === "fail") {
+        probes.push({ probe: "3-endpoints", status: "skip", summary: "Skipped — auth failed", details: {} });
+        probes.push({ probe: "4-pagination", status: "skip", summary: "Skipped — auth failed", details: {} });
+        probes.push({ probe: "5-rate-limits", status: "skip", summary: "Skipped — auth failed", details: {} });
+        probes.push({ probe: "6-sync", status: "skip", summary: "Skipped — auth failed", details: {} });
+        probes.push({ probe: "7-errors", status: "skip", summary: "Skipped — auth failed", details: {} });
+    }
+    else {
+        const endpointResults = await probe3Endpoints(baseUrl, endpoints, headers);
+        probes.push(endpointResults.probe);
+        probes.push(await probe4Pagination(baseUrl, endpoints, headers, endpointResults.responses));
+        probes.push(await probe5RateLimits(endpointResults.responses));
+        probes.push(await probe6Sync(baseUrl, endpoints, headers, endpointResults.responses));
+        probes.push(await probe7Errors(baseUrl, endpoints, headers));
+    }
+    const enriched = enrichSpec(spec, probes);
+    writeSpec(workspaceRoot, slug, enriched);
+    const passCount = probes.filter((p) => p.status === "pass").length;
+    const failCount = probes.filter((p) => p.status === "fail").length;
+    const overallStatus = failCount === 0 ? "pass" : passCount === 0 ? "fail" : "partial";
+    return { slug, probes, enrichedSpecSaved: true, overallStatus };
+}
+function loadSource(workspaceRoot, name) {
+    const mugJsonPath = join(workspaceRoot, "mug.json");
+    if (!existsSync(mugJsonPath))
+        throw new Error("No mug.json found — run mug init first");
+    const mugJson = JSON.parse(readFileSync(mugJsonPath, "utf-8"));
+    const src = mugJson.sources?.[name];
+    if (src)
+        return src;
+    const conn = mugJson.connections?.[name];
+    if (conn)
+        return conn;
+    throw new Error(`Source "${name}" not found in mug.json`);
+}
+function extractBaseUrl(spec) {
+    const servers = spec.servers;
+    return servers?.[0]?.url;
+}
+function extractEndpoints(spec) {
+    const paths = spec.paths;
+    if (!paths)
+        return [];
+    const endpoints = [];
+    const methods = ["get", "post", "put", "patch", "delete"];
+    for (const [path, pathItem] of Object.entries(paths)) {
+        if (!pathItem || typeof pathItem !== "object")
+            continue;
+        for (const method of methods) {
+            const op = pathItem[method];
+            if (!op)
+                continue;
+            const rawParams = (op.parameters ?? []);
+            const params = rawParams.filter((p) => typeof p.name === "string");
+            const isList = method === "get" && !path.match(/\{[^}]+\}$/);
+            endpoints.push({
+                path,
+                method,
+                operationId: op.operationId,
+                parameters: params,
+                isList,
+            });
+        }
+    }
+    return endpoints;
+}
+function buildAuthHeaders(connection) {
+    const { auth } = connection;
+    switch (auth.type) {
+        case "api-key":
+            return { [auth.header ?? "Authorization"]: auth.value };
+        case "bearer":
+            return { Authorization: `${auth.prefix ?? "Bearer"} ${auth.value}` };
+        case "basic":
+            return { Authorization: `Basic ${Buffer.from(auth.value).toString("base64")}` };
+        case "oauth2":
+            return { Authorization: `Bearer ${auth.value}` };
+    }
+}
+function simplestEndpoint(endpoints) {
+    return endpoints.find((e) => e.method === "get" && e.isList)
+        ?? endpoints.find((e) => e.method === "get")
+        ?? endpoints[0];
+}
+function buildUrl(baseUrl, path) {
+    const base = baseUrl.replace(/\/$/, "");
+    return `${base}${path}`;
+}
+// --- Probe implementations ---
+async function probe1SpecQuality(spec) {
+    const lint = await lintSpec(spec);
+    return {
+        probe: "1-spec-quality",
+        status: lint.score >= 50 ? "pass" : "partial",
+        summary: `Quality score: ${lint.score}/100, ${lint.errors.length} errors, ${lint.warnings.length} warnings`,
+        details: { score: lint.score, errors: lint.errors, warnings: lint.warnings },
+    };
+}
+async function probe2Auth(baseUrl, endpoints, headers) {
+    const target = simplestEndpoint(endpoints);
+    if (!target)
+        return { probe: "2-auth", status: "fail", summary: "No endpoints in spec to test auth", details: {} };
+    const url = buildUrl(baseUrl, target.path);
+    try {
+        const res = await fetch(url, { headers, signal: AbortSignal.timeout(15000) });
+        if (res.status === 401 || res.status === 403) {
+            return {
+                probe: "2-auth",
+                status: "fail",
+                summary: `Auth failed: ${res.status} on ${target.method.toUpperCase()} ${target.path}`,
+                details: { status: res.status, endpoint: target.path },
+            };
+        }
+        return {
+            probe: "2-auth",
+            status: "pass",
+            summary: `Auth works: ${res.status} on ${target.method.toUpperCase()} ${target.path}`,
+            details: { status: res.status, endpoint: target.path },
+        };
+    }
+    catch (err) {
+        return {
+            probe: "2-auth",
+            status: "fail",
+            summary: `Request failed: ${err instanceof Error ? err.message : err}`,
+            details: { endpoint: target.path, error: String(err) },
+        };
+    }
+}
+async function probe3Endpoints(baseUrl, endpoints, headers) {
+    const responses = [];
+    let tested = 0;
+    let reachable = 0;
+    const paramValues = new Map();
+    // Pass 1 — hit param-free GET endpoints
+    for (const ep of endpoints) {
+        if (ep.method !== "get")
+            continue;
+        if (ep.path.includes("{"))
+            continue;
+        const result = await fetchEndpoint(baseUrl, ep, headers);
+        responses.push(result);
+        tested++;
+        if (result.status >= 200 && result.status < 400) {
+            reachable++;
+            extractParamValues(result.body, paramValues);
+        }
+    }
+    // Pass 2 — use discovered values to fill path params and test those endpoints
+    for (const ep of endpoints) {
+        if (ep.method !== "get")
+            continue;
+        if (!ep.path.includes("{"))
+            continue;
+        const filled = fillPathParams(ep.path, paramValues);
+        if (!filled)
+            continue;
+        const filledEp = { ...ep, path: filled };
+        const result = await fetchEndpoint(baseUrl, filledEp, headers);
+        responses.push({ ...result, endpoint: ep });
+        tested++;
+        if (result.status >= 200 && result.status < 400) {
+            reachable++;
+            extractParamValues(result.body, paramValues);
+        }
+    }
+    const skipped = endpoints.filter((e) => e.method === "get").length - tested;
+    return {
+        probe: {
+            probe: "3-endpoints",
+            status: reachable === tested ? "pass" : reachable > 0 ? "partial" : "fail",
+            summary: `${reachable}/${tested} GET endpoints reachable${skipped > 0 ? ` (${skipped} skipped — couldn't fill path params)` : ""}`,
+            details: {
+                tested,
+                reachable,
+                skipped,
+                paramValues: Object.fromEntries(paramValues),
+                results: responses.map((r) => ({
+                    path: r.endpoint.path,
+                    status: r.status,
+                })),
+            },
+        },
+        responses,
+    };
+}
+async function probe4Pagination(baseUrl, endpoints, headers, responses) {
+    const paginationByPath = {};
+    const listResponses = responses.filter((r) => r.endpoint.isList && r.status >= 200 && r.status < 300);
+    for (const resp of listResponses) {
+        const pagination = detectPagination(resp);
+        if (pagination) {
+            paginationByPath[resp.endpoint.path] = pagination;
+        }
+    }
+    const detected = Object.keys(paginationByPath).length;
+    return {
+        probe: "4-pagination",
+        status: detected > 0 ? "pass" : listResponses.length > 0 ? "partial" : "skip",
+        summary: detected > 0
+            ? `Pagination detected on ${detected}/${listResponses.length} list endpoints`
+            : `No pagination detected on ${listResponses.length} list endpoints`,
+        details: { pagination: paginationByPath },
+    };
+}
+function detectPagination(resp) {
+    // Check Link header
+    const linkHeader = resp.headers["link"];
+    if (linkHeader && linkHeader.includes('rel="next"')) {
+        return { style: "link-header" };
+    }
+    // Check body for cursor/offset patterns
+    if (resp.body && typeof resp.body === "object") {
+        const body = resp.body;
+        const cursorFields = ["next_cursor", "cursor", "next_page_token", "nextPageToken", "next", "offset"];
+        for (const field of cursorFields) {
+            const value = findField(body, field);
+            if (value !== undefined && value !== null) {
+                if (field === "offset" || field === "next") {
+                    if (typeof value === "number") {
+                        return { style: "offset", offsetParam: field };
+                    }
+                }
+                return { style: "cursor", cursorPath: field };
+            }
+        }
+        // Check for page-based patterns
+        if (findField(body, "page") !== undefined || findField(body, "total_pages") !== undefined) {
+            return { style: "page", pageParam: "page" };
+        }
+    }
+    return null;
+}
+async function probe5RateLimits(responses) {
+    const rateLimitHeaders = [];
+    const rateLimit = {};
+    for (const resp of responses) {
+        const h = resp.headers;
+        const found = {};
+        for (const [key, value] of Object.entries(h)) {
+            const lower = key.toLowerCase();
+            if (lower.includes("ratelimit") || lower.includes("rate-limit") || lower === "retry-after") {
+                found[key] = value;
+            }
+        }
+        if (Object.keys(found).length > 0) {
+            rateLimitHeaders.push(found);
+        }
+    }
+    if (rateLimitHeaders.length === 0) {
+        return {
+            probe: "5-rate-limits",
+            status: "partial",
+            summary: "No rate limit headers found in responses",
+            details: {},
+        };
+    }
+    const sample = rateLimitHeaders[0];
+    for (const [key, value] of Object.entries(sample)) {
+        const lower = key.toLowerCase();
+        if (lower.includes("limit") && !lower.includes("remaining") && !lower.includes("reset")) {
+            rateLimit.headerLimit = key;
+            const num = parseInt(value);
+            if (!isNaN(num))
+                rateLimit.requestsPerMinute = num;
+        }
+        if (lower.includes("remaining"))
+            rateLimit.headerRemaining = key;
+        if (lower.includes("reset")) {
+            rateLimit.headerReset = key;
+            const num = parseInt(value);
+            if (!isNaN(num)) {
+                rateLimit.resetFormat = num > 1_000_000_000 ? "unix" : "seconds";
+            }
+        }
+        if (lower === "retry-after")
+            rateLimit.retryAfterHeader = key;
+    }
+    return {
+        probe: "5-rate-limits",
+        status: "pass",
+        summary: `Rate limit headers found: ${Object.keys(sample).join(", ")}`,
+        details: { rateLimits: rateLimit, sampleHeaders: sample },
+    };
+}
+async function probe6Sync(baseUrl, endpoints, headers, responses) {
+    const syncByPath = {};
+    const listEndpoints = endpoints.filter((e) => e.isList && e.method === "get");
+    for (const ep of listEndpoints) {
+        const sync = { supportsIncrementalSync: false };
+        // Check spec params for time-based filters
+        const timeParams = ["updated_since", "modified_after", "since", "updated_after",
+            "min_date_modified", "filter[updated_at]", "startModifiedAt"];
+        const params = ep.parameters ?? [];
+        for (const param of params) {
+            if (!param.name)
+                continue;
+            if (timeParams.some((tp) => param.name.toLowerCase().includes(tp.toLowerCase().replace(/[[\]]/g, "")))) {
+                sync.supportsIncrementalSync = true;
+                sync.filterParam = param.name;
+                break;
+            }
+        }
+        // Check response body for timestamp/deletion fields
+        const resp = responses.find((r) => r.endpoint.path === ep.path);
+        if (resp?.body && typeof resp.body === "object") {
+            const sampleRecord = extractSampleRecord(resp.body);
+            if (sampleRecord) {
+                if (findField(sampleRecord, "updated_at") !== undefined || findField(sampleRecord, "modified_at") !== undefined) {
+                    sync.updatedAtField = findField(sampleRecord, "updated_at") !== undefined ? "updated_at" : "modified_at";
+                }
+                if (findField(sampleRecord, "deleted_at") !== undefined) {
+                    sync.deletedAtField = "deleted_at";
+                    sync.deletionStrategy = "soft-delete-field";
+                }
+                else if (findField(sampleRecord, "is_deleted") !== undefined) {
+                    sync.isDeletedField = "is_deleted";
+                    sync.deletionStrategy = "soft-delete-field";
+                }
+            }
+        }
+        if (sync.supportsIncrementalSync || sync.updatedAtField || sync.deletedAtField) {
+            syncByPath[ep.path] = sync;
+        }
+    }
+    const detected = Object.keys(syncByPath).length;
+    return {
+        probe: "6-sync",
+        status: detected > 0 ? "pass" : "partial",
+        summary: detected > 0
+            ? `Sync capability detected on ${detected}/${listEndpoints.length} list endpoints`
+            : `No sync capability detected on ${listEndpoints.length} list endpoints`,
+        details: { sync: syncByPath },
+    };
+}
+async function probe7Errors(baseUrl, endpoints, headers) {
+    const target = simplestEndpoint(endpoints);
+    if (!target)
+        return { probe: "7-errors", status: "skip", summary: "No endpoints to test", details: {} };
+    const errorPatterns = {};
+    // Try a request with a bogus path to trigger 404
+    try {
+        const res = await fetch(buildUrl(baseUrl, "/___mug_probe_nonexistent___"), {
+            headers,
+            signal: AbortSignal.timeout(15000),
+        });
+        const ct = res.headers.get("content-type") ?? "";
+        let body = null;
+        if (ct.includes("json")) {
+            try {
+                body = await res.json();
+            }
+            catch { /* ignore */ }
+        }
+        errorPatterns["404"] = { status: res.status, contentType: ct, body };
+    }
+    catch { /* ignore */ }
+    // Try an invalid request to a real endpoint
+    if (target.isList) {
+        const url = buildUrl(baseUrl, target.path) + "?limit=-1";
+        try {
+            const res = await fetch(url, { headers, signal: AbortSignal.timeout(15000) });
+            const ct = res.headers.get("content-type") ?? "";
+            let body = null;
+            if (ct.includes("json")) {
+                try {
+                    body = await res.json();
+                }
+                catch { /* ignore */ }
+            }
+            if (res.status >= 400) {
+                errorPatterns["invalid-param"] = { status: res.status, contentType: ct, body };
+            }
+        }
+        catch { /* ignore */ }
+    }
+    const hasJson = Object.values(errorPatterns).some((p) => p.contentType?.toString().includes("json"));
+    return {
+        probe: "7-errors",
+        status: Object.keys(errorPatterns).length > 0 ? "pass" : "partial",
+        summary: hasJson
+            ? "API returns structured JSON errors"
+            : "Error response shape captured",
+        details: { errorPatterns },
+    };
+}
+// --- Spec enrichment ---
+function enrichSpec(spec, probes) {
+    const enriched = { ...spec };
+    const paginationProbe = probes.find((p) => p.probe === "4-pagination");
+    const rateLimitProbe = probes.find((p) => p.probe === "5-rate-limits");
+    const syncProbe = probes.find((p) => p.probe === "6-sync");
+    if (rateLimitProbe?.details.rateLimits) {
+        enriched["x-mug-rate-limits"] = rateLimitProbe.details.rateLimits;
+    }
+    // Enrich individual paths
+    const paths = enriched.paths;
+    if (paths) {
+        const pagination = (paginationProbe?.details.pagination ?? {});
+        const sync = (syncProbe?.details.sync ?? {});
+        for (const [path, pathItem] of Object.entries(paths)) {
+            if (pagination[path]) {
+                pathItem["x-mug-pagination"] = pagination[path];
+            }
+            if (sync[path]) {
+                pathItem["x-mug-sync"] = sync[path];
+            }
+        }
+    }
+    return enriched;
+}
+// --- Endpoint probing helpers ---
+async function fetchEndpoint(baseUrl, ep, headers) {
+    const url = buildUrl(baseUrl, ep.path);
+    try {
+        const res = await fetch(url, { headers, signal: AbortSignal.timeout(15000) });
+        const resHeaders = {};
+        res.headers.forEach((v, k) => { resHeaders[k] = v; });
+        let body = null;
+        const ct = res.headers.get("content-type") ?? "";
+        if (ct.includes("json")) {
+            try {
+                body = await res.json();
+            }
+            catch { /* ignore */ }
+        }
+        return { endpoint: ep, status: res.status, headers: resHeaders, body };
+    }
+    catch {
+        return { endpoint: ep, status: 0, headers: {}, body: null };
+    }
+}
+function extractParamValues(body, params) {
+    if (!body || typeof body !== "object")
+        return;
+    const obj = body;
+    // Find the list wrapper key and items: { bases: [{id: "..."}], tables: [{id: "..."}] }
+    const { key: listKey, items } = findListInResponse(obj);
+    for (const item of items) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const record = item;
+        if (typeof record.id === "string") {
+            // Store generic id
+            if (!params.has("id"))
+                params.set("id", record.id);
+            // Derive resource-specific param from the list wrapper key
+            // { "bases": [{id: "app..."}] } → baseId = "app..."
+            // { "tables": [{id: "tbl..."}] } → tableId = "tbl..."
+            if (listKey) {
+                const singular = listKey.replace(/s$/, "").replace(/ies$/, "y");
+                const resourceParam = `${singular}Id`;
+                if (!params.has(resourceParam))
+                    params.set(resourceParam, record.id);
+                const snakeParam = `${singular}_id`;
+                if (!params.has(snakeParam))
+                    params.set(snakeParam, record.id);
+            }
+        }
+        // Also store name fields — useful for {tableIdOrName} style params
+        if (typeof record.name === "string" && listKey) {
+            const singular = listKey.replace(/s$/, "").replace(/ies$/, "y");
+            const nameParam = `${singular}IdOrName`;
+            if (!params.has(nameParam))
+                params.set(nameParam, record.name);
+            const nameParam2 = `${singular}Name`;
+            if (!params.has(nameParam2))
+                params.set(nameParam2, record.name);
+        }
+        // Store explicit *Id fields from the record itself
+        for (const [key, value] of Object.entries(record)) {
+            if (typeof value !== "string" || !value)
+                continue;
+            if (key.endsWith("Id") || key.endsWith("_id")) {
+                if (!params.has(key))
+                    params.set(key, value);
+            }
+        }
+    }
+    // Top-level fields
+    if (typeof obj.id === "string" && !params.has("id")) {
+        params.set("id", obj.id);
+    }
+}
+function findListInResponse(obj) {
+    const listKeys = ["data", "results", "records", "items", "entries",
+        "bases", "tables", "users", "organizations", "projects", "accounts", "contacts"];
+    for (const key of listKeys) {
+        const val = obj[key];
+        if (Array.isArray(val) && val.length > 0)
+            return { key, items: val };
+    }
+    if (Array.isArray(obj))
+        return { key: null, items: obj };
+    return { key: null, items: [] };
+}
+function fillPathParams(path, params) {
+    const paramPattern = /\{([^}]+)\}/g;
+    let filled = path;
+    let match;
+    while ((match = paramPattern.exec(path)) !== null) {
+        const paramName = match[1];
+        // Try exact match first, then common variations
+        const value = params.get(paramName)
+            ?? params.get(camelCase(paramName))
+            ?? tryFuzzyParam(paramName, params);
+        if (!value)
+            return null;
+        filled = filled.replace(match[0], encodeURIComponent(value));
+    }
+    return filled;
+}
+function camelCase(s) {
+    return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function tryFuzzyParam(name, params) {
+    const lower = name.toLowerCase();
+    // {baseId} or {base_id} → look for "id" from a /bases response
+    if (lower.includes("id")) {
+        // Try stripping "Id"/"_id" suffix to find the resource name, then look for that resource's id
+        const resource = lower.replace(/id$/, "").replace(/_id$/, "").replace(/_$/, "");
+        for (const [key, value] of params) {
+            if (key.toLowerCase() === lower)
+                return value;
+            if (key.toLowerCase() === `${resource}id`)
+                return value;
+            if (key.toLowerCase() === `${resource}_id`)
+                return value;
+        }
+        // Last resort: if we only have one "id" value and param name contains "id", use it
+        if (params.has("id") && params.size <= 3)
+            return params.get("id");
+    }
+    return null;
+}
+// --- Field helpers ---
+function findField(obj, name) {
+    const lower = name.toLowerCase();
+    for (const [key, value] of Object.entries(obj)) {
+        if (key.toLowerCase() === lower)
+            return value;
+    }
+    return undefined;
+}
+function extractSampleRecord(body) {
+    // APIs typically return { data: [...] }, { results: [...] }, { records: [...] }, or bare [...]
+    for (const key of ["data", "results", "records", "items", "entries"]) {
+        const val = body[key];
+        if (Array.isArray(val) && val.length > 0 && typeof val[0] === "object") {
+            return val[0];
+        }
+    }
+    // Check if body itself is an array
+    if (Array.isArray(body) && body.length > 0 && typeof body[0] === "object") {
+        return body[0];
+    }
+    return null;
+}

package/dist/src/email-template.d.ts

@@ -0,0 +1,2 @@
+export { renderEmailHtml, markdownToHtml } from "../packages/email-template/src/email-template.js";
+export type { BrandingConfig } from "../packages/email-template/src/email-template.js";

package/dist/src/email-template.js

@@ -0,0 +1 @@
+export { renderEmailHtml, markdownToHtml } from "../packages/email-template/src/email-template.js";

package/dist/src/manifest.d.ts

@@ -0,0 +1,31 @@
+export interface FileEntry {
+    size: number;
+    sha256: string;
+    updated_at: string;
+}
+export interface FilesManifest {
+    synced_at: string | null;
+    files: Record<string, FileEntry>;
+}
+export interface ColumnInfo {
+    name: string;
+    type: string;
+}
+export interface TableInfo {
+    columns: ColumnInfo[];
+    row_count: number;
+}
+export interface DatabaseEntry {
+    size_mb: number;
+    tables: Record<string, TableInfo>;
+    updated_at: string;
+}
+export interface DatabasesManifest {
+    synced_at: string | null;
+    databases: Record<string, DatabaseEntry>;
+}
+export declare function readFilesManifest(cwd: string): FilesManifest;
+export declare function writeFilesManifest(cwd: string, manifest: FilesManifest): void;
+export declare function readDatabasesManifest(cwd: string): DatabasesManifest;
+export declare function writeDatabasesManifest(cwd: string, manifest: DatabasesManifest): void;
+export declare function computeFileSha256(filePath: string): string;

package/dist/src/manifest.js

@@ -0,0 +1,25 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+export function readFilesManifest(cwd) {
+    const path = join(cwd, "files", ".remote");
+    if (!existsSync(path))
+        return { synced_at: null, files: {} };
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+export function writeFilesManifest(cwd, manifest) {
+    writeFileSync(join(cwd, "files", ".remote"), JSON.stringify(manifest, null, 2) + "\n");
+}
+export function readDatabasesManifest(cwd) {
+    const path = join(cwd, "databases", ".remote");
+    if (!existsSync(path))
+        return { synced_at: null, databases: {} };
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+export function writeDatabasesManifest(cwd, manifest) {
+    writeFileSync(join(cwd, "databases", ".remote"), JSON.stringify(manifest, null, 2) + "\n");
+}
+export function computeFileSha256(filePath) {
+    const content = readFileSync(filePath);
+    return createHash("sha256").update(content).digest("hex");
+}

package/dist/src/mug-icon.d.ts

@@ -0,0 +1 @@
+export declare function generateMugIconSvg(accentColor?: string): string;

package/dist/src/mug-icon.js

@@ -0,0 +1,12 @@
+const MUG_LOGO_SVG = `<svg width="291" height="371" viewBox="0 0 291 371" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M134.129 122.279L140.915 122.8L141.155 124.478L141.394 126.157L151.534 126.674L161.674 127.191L167.245 128.392L172.817 129.593L176.743 130.899L180.668 132.206L179.403 132.915L178.139 133.624L170.306 134.807L162.472 135.99L156.284 135.995L150.097 136V138.406V140.813L103.591 140.606L57.0848 140.4L56.8325 138.2L56.5794 136L51.2438 135.984L45.9073 135.968L40.3186 135.187L34.7299 134.406L30.9376 133.523L27.1452 132.641V131.987V131.334L34.1311 129.714L41.117 128.094L47.362 127.247L53.6078 126.4H59.5374H65.4678V124.438V122.476L70.4577 122.192L75.4477 121.908L101.395 121.834L127.343 121.759L134.129 122.279Z" fill="#71B7FB"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M3.07464 136.078L5.58875 136.957V137.573V138.189L10.5787 139.553L15.5686 140.917L19.6268 142.398L23.6858 143.878L29.8645 144.739L36.0433 145.6H43.9161H51.7891L52.0422 147.8L52.2944 150H103.391H154.488L154.729 147.918L154.97 145.836L167.503 145.398L180.036 144.96L184.827 143.222L189.617 141.485L195.206 139.871L200.795 138.258L201.623 137.208L202.452 136.158L204.418 135.879L206.383 135.6L206.407 231.8L206.431 328H204.315H202.198L201.636 335.2L201.074 342.4H199.138H197.202V344.8V347.2H194.807H192.411V349.6V352H190.016H187.621V354.4V356.8H182.831H178.04V359.2V361.6H173.25H168.46L168.461 363.8L168.461 366H157.084H145.706L145.454 368.2L145.2 370.4H103.391H61.5821L61.329 368.2L61.0767 366L49.3005 365.778L37.5243 365.558V363.578V361.6H33.1331H28.742V359.2V356.8H23.9517H19.1613V354.453V352.106L16.9658 351.853L14.7702 351.6L14.5179 349.4L14.2648 347.2H11.9232H9.58069V342.4V337.6H7.18553H4.79036V332.8V328H2.3952H3.8147e-05V231.6V135.2H0.280282H0.560526L3.07464 136.078ZM19.1613 323.094V243.547V164H23.9517H28.742V239.2V314.4H31.1372H33.5323V321.6V328.8H35.5283H37.5243V330.8V332.8H39.9194H42.3146V335.2V337.6H44.7097H47.1049V342.4V347.2H42.7665H38.4288L38.1757 345L37.9235 342.8L33.4948 342.565L29.0654 342.33L28.1751 339.965L27.2841 337.6H25.649H24.0139L23.7832 330.6L23.5525 323.6L21.3569 323.347L19.1613 323.094Z" fill="#71B7FB"/>
+<path d="M237.972 155.228L239.516 156.056V157.586V159.116L243.708 159.358L247.899 159.6L248.687 161.4L249.475 163.2H251.182H252.889L255.384 163.7L257.879 164.2V166.5V168.8H260.189H262.499L262.961 170.007L263.423 171.214L265.442 172.135L267.46 173.057V175.275V177.494L269.655 177.747L271.851 178L272.101 180.6L272.352 183.2H274.585H276.819L276.438 185.2L276.056 187.2H278.544H281.033V192V196.8H283.428H285.823V204V211.2H288.218H290.613V230V248.8H288.218H285.823V255.547V262.294L283.627 262.547L281.432 262.8L281.192 267.4L280.953 272H278.977H277.001L276.522 274.4L276.043 276.8H274.146H272.25V278.508V280.217L270.454 282.033L268.658 283.85L267.628 285.125L266.598 286.4H264.634H262.67V288.8V291.2H260.274H257.879V293.2V295.2H255.484H253.089V297.6V300H246.303H239.516V302.4V304.8H227.541H215.565V295.622V286.442L227.341 286.222L239.117 286L239.086 283.8L239.054 281.6H243.677H248.299V279.2V276.8H250.694H253.089V274.4V272H255.484H257.879V269.6V267.2H260.274H262.67V264.8V262.4H265.065H267.46V257.492V252.583L269.456 250.73L271.452 248.876V230.038V211.2H269.487H267.522L267.291 204.2L267.061 197.2L264.865 196.947L262.67 196.694V194.347V192H260.274H257.879V190.063V188.127L255.484 187.6L253.089 187.073V185.19V183.306L250.893 183.053L248.698 182.8L248.445 180.6L248.192 178.4H243.907H239.623L239.369 176.2L239.117 174L227.341 173.778L215.565 173.558V163.978V154.4H225.996H236.427L237.972 155.228Z" fill="#71B7FB"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M107.782 6.8V13.6H110.073H112.364L112.858 16.6L113.354 19.6V23.2V26.8L112.866 29.756L112.378 32.7128L110.28 32.956L108.182 33.2L107.929 35.4L107.676 37.6H105.786H103.897L103.644 39.8L103.391 42L101.196 42.2528L99.0001 42.5064V44.0792V45.6512L97.8433 48.4256L96.6864 51.2H95.5527H94.419L93.924 54.2L93.4289 57.2L93.4904 64.4L93.5511 71.6L94.0805 75.6L94.609 79.6L96.8045 79.8528L99.0001 80.1064V82.0528V84H103.391H107.782V79.6V75.2H105.88H103.976L103.495 73.4L103.014 71.6L103.003 65.852L102.992 60.104L103.77 58.052L104.549 56H106.113H107.676L107.929 53.8L108.182 51.6L110.328 51.3512L112.476 51.1032L112.724 48.9512L112.972 46.8L115.167 46.5472L117.363 46.2936V44.4V42.5064L119.559 42.2528L121.754 42L121.992 37.4496L122.23 32.8992L124.387 32.6496L126.544 32.4L126.303 26L126.062 19.6L123.583 12.2392L121.105 4.87841L119.433 4.6392L117.762 4.4L117.51 2.2L117.257 0H112.52H107.782V6.8ZM66.2662 37.548V47.096L65.4878 49.148L64.7093 51.2H63.0926H61.4759V53.6V56H59.0807H56.6856V58.4V60.8H54.2904H51.8952V69.9472V79.0936L54.0908 79.3472L56.2864 79.6L56.5386 81.8L56.7917 84H61.1294H65.4678V79.6V75.2H63.4719H61.4759V70.4V65.6H63.4088H65.3409L65.867 63.2L66.3932 60.8H68.2726H70.152L70.4051 58.6L70.6573 56.4L72.8042 56.1512L74.9519 55.9032L75.1994 53.7512L75.4477 51.6L77.6432 51.3472L79.8388 51.0936V41.9472V32.8H77.4436H75.0485V30.4V28H70.6573H66.2662V37.548ZM146.096 36.6L146.087 45.2L145.592 48.2L145.097 51.2H143.206H141.315V53.6V56H138.919H136.524V58.4V60.8H134.129H131.734V69.9368V79.0728L134.129 79.6L136.524 80.1272V82.0632V84H140.915H145.307V79.6V75.2H143.359H141.413L140.876 71.6096L140.338 68.02L140.801 66.8096L141.264 65.6H143.286H145.307V63.2V60.8H147.649H149.991L150.244 58.6L150.496 56.4L152.692 56.1472L154.887 55.8936V53.5472V51.2H156.883H158.879V42V32.8H156.883H154.887V30.4V28H150.496H146.105L146.096 36.6Z" fill="#71B7FB"/>
+<path d="M145.307 105.2V107.2L147.901 107.222L150.496 107.243L161.274 107.678L172.053 108.113L173.051 108.431L174.049 108.75V110.261V111.772L178.719 112.262L183.39 112.75L189.697 114.747L196.004 116.744L199.797 119.154L203.589 121.565V123.164V124.763L201.78 125.951L199.97 127.139L196.544 128.35L193.118 129.562L190.538 126.981L187.958 124.4L182.8 122.609L177.641 120.818L167.262 118.471L156.883 116.125L149.698 115.261L142.512 114.396L132.217 113.598L121.922 112.8H104.641H87.362L73.0214 113.988L58.6815 115.176L53.0928 116.069L47.5041 116.962L35.7965 119.63L24.0882 122.298L21.0264 123.871L17.9638 125.444L16.0987 127.446L14.2345 129.449L12.0844 128.831L9.93437 128.214L6.51408 126.465L3.09379 124.716L3.3429 122.962L3.59278 121.209L7.73164 118.734L11.8705 116.26L17.2644 114.486L22.6575 112.711L27.637 112.246L32.6158 111.78L33.0892 109.89L33.5627 108H40.2108H46.8598L54.1675 107.48L61.4759 106.961V105.08V103.2H103.391H145.307V105.2Z" fill="#71B7FB"/>
+</svg>`;
+export function generateMugIconSvg(accentColor) {
+    if (!accentColor || accentColor === "#71B7FB")
+        return MUG_LOGO_SVG;
+    return MUG_LOGO_SVG.replace(/#71B7FB/g, accentColor);
+}