@mugwork/mug 0.1.0

package/dist/src/slack-manifest.d.ts

@@ -0,0 +1,119 @@
+export interface SlackJsonConfig {
+    enabled: boolean;
+    name?: string;
+    description?: string;
+    color?: string;
+    botName?: string;
+    homeTab?: {
+        enabled: boolean;
+        sections?: unknown[];
+    };
+    messagesTab?: boolean;
+    shortcuts?: {
+        name: string;
+        callbackId: string;
+        description: string;
+        type: "global" | "message";
+        workflow?: string;
+    }[];
+    unfurlDomains?: string[];
+    agentView?: {
+        description: string;
+        suggestedPrompts?: {
+            title: string;
+            message: string;
+        }[];
+    };
+    scopes?: string[];
+    commands?: Record<string, {
+        description: string;
+        usage_hint?: string;
+    }>;
+    events?: string[];
+}
+export interface SlackConfigLegacy {
+    enabled: boolean;
+    name?: string;
+    description?: string;
+    color?: string;
+    scopes?: string[];
+    commands?: Record<string, {
+        description: string;
+        usage_hint?: string;
+    }>;
+    events?: string[];
+}
+export interface SlackTrigger {
+    type: "slack_command" | "slack_event" | "slack_shortcut";
+    command?: string;
+    description?: string;
+    usage_hint?: string;
+    event?: string;
+    name?: string;
+    callback_id?: string;
+}
+interface SlackManifest {
+    _metadata: {
+        major_version: number;
+        minor_version: number;
+    };
+    display_information: {
+        name: string;
+        description?: string;
+        background_color?: string;
+    };
+    features: {
+        app_home?: {
+            home_tab_enabled?: boolean;
+            messages_tab_enabled?: boolean;
+            messages_tab_read_only_enabled?: boolean;
+        };
+        bot_user: {
+            display_name: string;
+            always_online: boolean;
+        };
+        slash_commands?: {
+            command: string;
+            description: string;
+            usage_hint?: string;
+            url: string;
+        }[];
+        shortcuts?: {
+            name: string;
+            callback_id: string;
+            description: string;
+            type: "global" | "message";
+        }[];
+        unfurl_domains?: string[];
+        agent_view?: {
+            agent_description: string;
+            suggested_prompts?: {
+                title: string;
+                message: string;
+            }[];
+        };
+    };
+    oauth_config: {
+        scopes: {
+            bot: string[];
+        };
+        redirect_urls: string[];
+    };
+    settings: {
+        event_subscriptions?: {
+            request_url: string;
+            bot_events: string[];
+        };
+        interactivity?: {
+            is_enabled: boolean;
+            request_url: string;
+        };
+        org_deploy_enabled: boolean;
+        socket_mode_enabled: boolean;
+        token_rotation_enabled: boolean;
+    };
+}
+export declare function generateSlackManifest(workspaceName: string, slack: SlackJsonConfig, inbound?: Record<string, string>, workflowTriggers?: Record<string, SlackTrigger>): SlackManifest;
+export declare function legacyToSlackJson(legacy: SlackConfigLegacy): SlackJsonConfig;
+export declare function generateManifestUrl(manifest: SlackManifest): string;
+export {};

package/dist/src/slack-manifest.js

@@ -0,0 +1,163 @@
+export function generateSlackManifest(workspaceName, slack, inbound, workflowTriggers) {
+    const appName = slack.name ?? titleCase(workspaceName);
+    const botName = slack.botName ?? appName;
+    const baseUrl = `https://api.mug.work`;
+    const interactivityUrl = `${baseUrl}/inbound/slack/${workspaceName}`;
+    const eventsUrl = `${baseUrl}/inbound/slack/${workspaceName}`;
+    const scopes = new Set(slack.scopes ?? []);
+    scopes.add("chat:write");
+    // Scope inference from explicit commands
+    if (slack.commands && Object.keys(slack.commands).length > 0) {
+        scopes.add("commands");
+    }
+    if (slack.events?.some((e) => e.startsWith("message"))) {
+        scopes.add("channels:history");
+        scopes.add("groups:history");
+    }
+    if (inbound?.slack) {
+        scopes.add("commands");
+    }
+    // Scope inference from slack.json features
+    if (slack.homeTab?.enabled) {
+        scopes.add("users:read");
+        scopes.add("users:read.email");
+    }
+    if (slack.shortcuts && slack.shortcuts.length > 0) {
+        scopes.add("commands");
+    }
+    if (slack.messagesTab) {
+        scopes.add("im:history");
+    }
+    if (slack.unfurlDomains && slack.unfurlDomains.length > 0) {
+        scopes.add("links:read");
+        scopes.add("links:write");
+    }
+    if (slack.agentView) {
+        scopes.add("assistant:write");
+    }
+    // Merge explicit commands with workflow-derived commands
+    const allCommands = [];
+    if (slack.commands) {
+        for (const [cmd, cfg] of Object.entries(slack.commands)) {
+            allCommands.push({
+                command: cmd.startsWith("/") ? cmd : `/${cmd}`,
+                description: cfg.description,
+                usage_hint: cfg.usage_hint,
+                url: interactivityUrl,
+            });
+        }
+    }
+    const allEvents = new Set(slack.events ?? []);
+    // Auto-add events from features
+    if (slack.homeTab?.enabled) {
+        allEvents.add("app_home_opened");
+    }
+    if (slack.messagesTab) {
+        allEvents.add("message.im");
+    }
+    if (workflowTriggers) {
+        for (const [, trigger] of Object.entries(workflowTriggers)) {
+            if (trigger.type === "slack_command" && trigger.command) {
+                const cmd = trigger.command.startsWith("/") ? trigger.command : `/${trigger.command}`;
+                if (!allCommands.some((c) => c.command === cmd)) {
+                    allCommands.push({
+                        command: cmd,
+                        description: trigger.description ?? "Run workflow",
+                        usage_hint: trigger.usage_hint,
+                        url: interactivityUrl,
+                    });
+                }
+                scopes.add("commands");
+            }
+            else if (trigger.type === "slack_event" && trigger.event) {
+                allEvents.add(trigger.event);
+                if (trigger.event.startsWith("message")) {
+                    scopes.add("channels:history");
+                    scopes.add("groups:history");
+                }
+                if (trigger.event === "app_home_opened") {
+                    scopes.add("users:read");
+                    scopes.add("users:read.email");
+                }
+            }
+            else if (trigger.type === "slack_shortcut") {
+                scopes.add("commands");
+            }
+        }
+    }
+    const slashCommands = allCommands.length > 0 ? allCommands : undefined;
+    // Build features.app_home
+    const appHome = (slack.homeTab?.enabled || slack.messagesTab) ? {
+        ...(slack.homeTab?.enabled ? { home_tab_enabled: true } : {}),
+        ...(slack.messagesTab ? { messages_tab_enabled: true } : {}),
+    } : undefined;
+    // Build features.shortcuts from slack.json
+    const shortcuts = slack.shortcuts && slack.shortcuts.length > 0
+        ? slack.shortcuts.map((s) => ({
+            name: s.name,
+            callback_id: s.callbackId,
+            description: s.description,
+            type: s.type,
+        }))
+        : undefined;
+    // Build features.unfurl_domains
+    const unfurlDomains = slack.unfurlDomains && slack.unfurlDomains.length > 0
+        ? slack.unfurlDomains.slice(0, 5)
+        : undefined;
+    if (unfurlDomains) {
+        allEvents.add("link_shared");
+    }
+    // Build features.agent_view
+    const agentView = slack.agentView ? {
+        agent_description: slack.agentView.description,
+        ...(slack.agentView.suggestedPrompts ? { suggested_prompts: slack.agentView.suggestedPrompts } : {}),
+    } : undefined;
+    const manifest = {
+        _metadata: { major_version: 2, minor_version: 0 },
+        display_information: {
+            name: appName,
+            ...(slack.description ? { description: slack.description } : {}),
+            ...(slack.color ? { background_color: slack.color } : {}),
+        },
+        features: {
+            ...(appHome ? { app_home: appHome } : {}),
+            bot_user: { display_name: botName, always_online: true },
+            ...(slashCommands && slashCommands.length > 0 ? { slash_commands: slashCommands } : {}),
+            ...(shortcuts ? { shortcuts } : {}),
+            ...(unfurlDomains ? { unfurl_domains: unfurlDomains } : {}),
+            ...(agentView ? { agent_view: agentView } : {}),
+        },
+        oauth_config: {
+            scopes: { bot: [...scopes].sort() },
+            redirect_urls: [`${baseUrl}/slack/callback`],
+        },
+        settings: {
+            ...(allEvents.size > 0
+                ? { event_subscriptions: { request_url: eventsUrl, bot_events: [...allEvents].sort() } }
+                : {}),
+            interactivity: { is_enabled: true, request_url: interactivityUrl },
+            org_deploy_enabled: false,
+            socket_mode_enabled: false,
+            token_rotation_enabled: false,
+        },
+    };
+    return manifest;
+}
+export function legacyToSlackJson(legacy) {
+    return {
+        enabled: legacy.enabled,
+        name: legacy.name,
+        description: legacy.description,
+        color: legacy.color,
+        scopes: legacy.scopes,
+        commands: legacy.commands,
+        events: legacy.events,
+    };
+}
+export function generateManifestUrl(manifest) {
+    const encoded = encodeURIComponent(JSON.stringify(manifest));
+    return `https://api.slack.com/apps?new_app=1&manifest_json=${encoded}`;
+}
+function titleCase(slug) {
+    return slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}

package/dist/src/source-migration.d.ts

@@ -0,0 +1,20 @@
+import type { SourcesConfig, SourceAuth } from "../worker/src/source-types.js";
+interface OldConnection {
+    auth?: SourceAuth;
+    baseUrl?: string;
+}
+interface OldConnector {
+    connection?: string;
+    database?: string;
+    schedule?: string;
+    syncSchedule?: string;
+}
+interface MugConfig {
+    sources?: SourcesConfig;
+    connections?: Record<string, OldConnection>;
+    connectors?: Record<string, OldConnector>;
+    [key: string]: unknown;
+}
+export declare function migrateConfig(config: MugConfig): SourcesConfig;
+export declare function configNeedsMigration(config: MugConfig): boolean;
+export {};

package/dist/src/source-migration.js

@@ -0,0 +1,43 @@
+export function migrateConfig(config) {
+    if (config.sources && !config.connections && !config.connectors) {
+        return config.sources;
+    }
+    if (!config.connections && !config.connectors) {
+        return {};
+    }
+    const connections = config.connections ?? {};
+    const connectors = config.connectors ?? {};
+    const sources = {};
+    for (const [name, conn] of Object.entries(connections)) {
+        sources[name] = {
+            ...(conn.auth ? { auth: conn.auth } : {}),
+            ...(conn.baseUrl ? { baseUrl: conn.baseUrl } : {}),
+            syncs: {},
+        };
+    }
+    for (const [connectorName, connector] of Object.entries(connectors)) {
+        const schedule = connector.schedule ?? connector.syncSchedule;
+        const sync = {
+            database: connector.database ?? connectorName,
+            ...(schedule ? { schedule } : {}),
+        };
+        let sourceName;
+        if (connector.connection && sources[connector.connection]) {
+            sourceName = connector.connection;
+        }
+        else if (sources[connectorName]) {
+            sourceName = connectorName;
+        }
+        else {
+            sourceName = connector.connection ?? connectorName;
+            if (!sources[sourceName]) {
+                sources[sourceName] = { syncs: {} };
+            }
+        }
+        sources[sourceName].syncs[connectorName] = sync;
+    }
+    return sources;
+}
+export function configNeedsMigration(config) {
+    return !!(config.connections || config.connectors) && !config.sources;
+}

package/dist/src/surface-renderer.d.ts

@@ -0,0 +1,5 @@
+export { renderForm, esc } from "../packages/surface-renderer/src/form-renderer.js";
+export type { Breadcrumb, BrandingConfig, Condition, FormAccess, SessionData } from "../packages/surface-renderer/src/form-renderer.js";
+export { renderPortal, renderPortalDetail, renderDevBanner, bindUserParam, paginateQuery, detailQuery, collectSectionQueries, findTableSection, renderSection } from "../packages/surface-renderer/src/portal-renderer.js";
+export type { PortalConfig, PortalColumn, PortalField, PortalAction, PortalLink, PortalTab, PortalSection, TableSection, StatsSection, ProgressSection, TextSection, ChartSection, GallerySection, AccordionSection } from "../packages/surface-renderer/src/portal-renderer.js";
+export { renderWorkspaceAuth, renderWorkspaceHome } from "../packages/surface-renderer/src/workspace-home.js";

package/dist/src/surface-renderer.js

@@ -0,0 +1,3 @@
+export { renderForm, esc } from "../packages/surface-renderer/src/form-renderer.js";
+export { renderPortal, renderPortalDetail, renderDevBanner, bindUserParam, paginateQuery, detailQuery, collectSectionQueries, findTableSection, renderSection } from "../packages/surface-renderer/src/portal-renderer.js";
+export { renderWorkspaceAuth, renderWorkspaceHome } from "../packages/surface-renderer/src/workspace-home.js";

package/dist/src/templates.d.ts

@@ -0,0 +1,3 @@
+export declare const templates: Record<string, string>;
+export declare const skillTemplates: Record<string, string>;
+export declare const docTemplates: Record<string, string>;