@wabot-dev/framework 0.9.80 → 2.0.0-beta.0

package/dist/src/addon/chat-controller/hubspot/verifyHubSpotSignatureV3.js

@@ -0,0 +1,28 @@
+import { Signature } from '@hubspot/api-client';
+
+function verifyHubSpotSignatureV3(opts) {
+    const { secret, method, url, rawBody, timestampHeader, signatureHeader } = opts;
+    if (!secret || !signatureHeader || !timestampHeader) {
+        return false;
+    }
+    const timestamp = Number(timestampHeader);
+    if (!Number.isFinite(timestamp)) {
+        return false;
+    }
+    try {
+        return Signature.isValid({
+            method,
+            signatureVersion: 'v3',
+            url,
+            requestBody: rawBody,
+            clientSecret: secret,
+            signature: signatureHeader,
+            timestamp,
+        });
+    }
+    catch {
+        return false;
+    }
+}
+
+export { verifyHubSpotSignatureV3 };

package/dist/src/addon/chat-controller/{telegram/markdownToTelegramHtml.js → markdown/markdownToChatHtml.js}

@@ -1,12 +1,9 @@
-const PH_OPEN = '
';
-const PH_CLOSE = '';
+const PH_OPEN = '\x01';
+const PH_CLOSE = '\x02';
 function escapeHtml(text) {
-    return text
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;');
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
-function markdownToTelegramHtml(input) {
+function markdownToChatHtml(input) {
     if (!input)
         return input;
     const reserved = [];
@@ -42,4 +39,4 @@ function markdownToTelegramHtml(input) {
     return text;
 }
 
-export { markdownToTelegramHtml };
+export { markdownToChatHtml };

package/dist/src/addon/chat-controller/slack/@slack.js

@@ -0,0 +1,22 @@
+import { container } from '../../../core/injection/index.js';
+import { resolveConfigReferences } from '../../../core/config/resolver.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../feature/chat-controller/runChatControllers.js';
+import { SlackChannel } from './SlackChannel.js';
+import { SlackChannelConfig } from './SlackChannelConfig.js';
+
+function slack(config) {
+    return function (target, propertyKey) {
+        const resolved = resolveConfigReferences(config);
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: SlackChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new SlackChannelConfig(resolved.appToken, resolved.botToken, resolved.signingSecret),
+        });
+    };
+}
+
+export { slack };

package/dist/src/addon/chat-controller/slack/SlackChannel.js

@@ -0,0 +1,187 @@
+import { __decorate, __metadata } from 'tslib';
+import Bolt from '@slack/bolt';
+import { injectable } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { SlackChannelConfig } from './SlackChannelConfig.js';
+import { markdownToSlackMrkdwn } from './markdownToSlackMrkdwn.js';
+import { slackChannelName } from './slackChannelName.js';
+
+var SlackChannel_1;
+const { App } = Bolt;
+const GROUP_CHANNEL_TYPES = new Set(['channel', 'group', 'mpim']);
+const PRIVATE_CHANNEL_TYPES = new Set(['im']);
+const MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024;
+const USER_NAME_CACHE_TTL_MS = 60 * 60 * 1000;
+let SlackChannel = class SlackChannel {
+    static { SlackChannel_1 = this; }
+    config;
+    static channelName = slackChannelName;
+    app;
+    callback = null;
+    logger = new Logger('wabot:slack-channel');
+    userNameCache = new Map();
+    constructor(config) {
+        this.config = config;
+        this.app = new App({
+            token: config.botToken,
+            appToken: config.appToken,
+            socketMode: true,
+            signingSecret: config.signingSecret,
+            deferInitialization: true,
+        });
+    }
+    listen(callback) {
+        this.callback = callback;
+        this.app.message(async (args) => {
+            await this.handleMessage(args);
+        });
+    }
+    async handleMessage(args) {
+        if (!this.callback)
+            return;
+        const { message, say } = args;
+        if (message.subtype && message.subtype !== 'file_share') {
+            return;
+        }
+        const chatConnection = this.buildChatConnection(message);
+        const threadTs = message.thread_ts ?? message.ts;
+        const { images, documents } = await this.extractMedia(message.files);
+        const senderName = await this.resolveUserName(message.user);
+        const text = message.text ?? '';
+        const reply = this.buildReply(say, threadTs);
+        try {
+            await this.callback({
+                channel: slackChannelName,
+                chatConnection,
+                message: {
+                    senderId: message.user,
+                    senderName,
+                    text,
+                    images: images.length > 0 ? images : undefined,
+                    documents: documents.length > 0 ? documents : undefined,
+                    metadata: {
+                        ts: message.ts ?? '',
+                        thread_ts: message.thread_ts ?? '',
+                        channel: message.channel,
+                        channel_type: message.channel_type ?? '',
+                    },
+                },
+                reply,
+            });
+        }
+        catch (err) {
+            this.logger.error('Failed to handle Slack message', err instanceof Error ? { message: err.message } : { err });
+        }
+    }
+    buildChatConnection(message) {
+        const channelType = message.channel_type;
+        const chatType = GROUP_CHANNEL_TYPES.has(channelType ?? '')
+            ? 'GROUP'
+            : PRIVATE_CHANNEL_TYPES.has(channelType ?? '')
+                ? 'PRIVATE'
+                : 'GROUP';
+        return {
+            id: message.channel,
+            chatType,
+            channelName: SlackChannel_1.channelName,
+        };
+    }
+    buildReply(say, threadTs) {
+        return async (replyMessage) => {
+            if (!replyMessage.text)
+                return;
+            await say({
+                text: markdownToSlackMrkdwn(replyMessage.text),
+                mrkdwn: true,
+                ...(threadTs ? { thread_ts: threadTs } : {}),
+            });
+        };
+    }
+    async extractMedia(files) {
+        const images = [];
+        const documents = [];
+        if (!files || files.length === 0)
+            return { images, documents };
+        const results = await Promise.all(files.map((file) => this.downloadFile(file)));
+        for (const result of results) {
+            if (!result)
+                continue;
+            if (result.file.mimeType.startsWith('image/')) {
+                images.push(result.file);
+            }
+            else {
+                documents.push(result.file);
+            }
+        }
+        return { images, documents };
+    }
+    async downloadFile(file) {
+        const mimeType = file.mimetype ?? 'application/octet-stream';
+        if (!file.url_private) {
+            this.logger.warn(`slack file '${file.id}' has no url_private, skipping`);
+            return null;
+        }
+        if (file.size !== undefined && file.size > MAX_FILE_SIZE_BYTES) {
+            this.logger.warn(`slack file '${file.id}' exceeds 20 MB (${file.size} bytes), skipping`);
+            return null;
+        }
+        try {
+            const res = await fetch(file.url_private, {
+                headers: { Authorization: `Bearer ${this.config.botToken}` },
+            });
+            if (!res.ok) {
+                throw new Error(`${res.status} ${res.statusText}`);
+            }
+            const base64 = Buffer.from(await res.arrayBuffer()).toString('base64');
+            return {
+                file: {
+                    id: file.id,
+                    name: file.name,
+                    mimeType,
+                    base64Url: `data:${mimeType};base64,${base64}`,
+                },
+            };
+        }
+        catch (err) {
+            this.logger.warn(`failed to download slack file '${file.id}'`, err instanceof Error ? { message: err.message } : { err });
+            return null;
+        }
+    }
+    async resolveUserName(userId) {
+        if (!userId)
+            return undefined;
+        const now = Date.now();
+        const cached = this.userNameCache.get(userId);
+        if (cached && cached.expiresAt > now) {
+            return cached.name;
+        }
+        try {
+            const res = await this.app.client.users.info({ user: userId });
+            const user = res.user;
+            if (user) {
+                const name = user.real_name || user.name || userId;
+                this.userNameCache.set(userId, { name, expiresAt: now + USER_NAME_CACHE_TTL_MS });
+                return name;
+            }
+        }
+        catch (err) {
+            this.logger.warn(`failed to resolve slack user '${userId}'`, err instanceof Error ? { message: err.message } : { err });
+        }
+        return userId;
+    }
+    connect() {
+        void (async () => {
+            await this.app.init();
+            await this.app.start();
+        })();
+    }
+    disconnect() {
+        void this.app.stop();
+    }
+};
+SlackChannel = SlackChannel_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [SlackChannelConfig])
+], SlackChannel);
+
+export { SlackChannel };

package/dist/src/addon/chat-controller/slack/SlackChannelConfig.js

@@ -0,0 +1,12 @@
+class SlackChannelConfig {
+    appToken;
+    botToken;
+    signingSecret;
+    constructor(appToken, botToken, signingSecret) {
+        this.appToken = appToken;
+        this.botToken = botToken;
+        this.signingSecret = signingSecret;
+    }
+}
+
+export { SlackChannelConfig };

package/dist/src/addon/chat-controller/slack/markdownToSlackMrkdwn.js

@@ -0,0 +1,38 @@
+const PH_OPEN = '
';
+const PH_CLOSE = '';
+function escapeMrkdwn(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function markdownToSlackMrkdwn(input) {
+    if (!input)
+        return input;
+    const reserved = [];
+    const reserve = (snippet) => {
+        const token = `${PH_OPEN}${reserved.length}${PH_CLOSE}`;
+        reserved.push(snippet);
+        return token;
+    };
+    let text = input.replace(/\r\n/g, '\n');
+    text = text.replace(/```[\s\S]*?```/g, (block) => {
+        return reserve(block);
+    });
+    text = text.replace(/`([^`\n]+)`/g, (_, code) => {
+        return reserve('`' + code + '`');
+    });
+    text = text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, label, url) => {
+        return reserve(`<${url}|${label}>`);
+    });
+    text = escapeMrkdwn(text);
+    text = text.replace(/^(#{1,6})\s+(.+)$/gm, (_, _hashes, content) => `*${content.trim()}*`);
+    text = text.replace(/^&gt;\s?(.*)$/gm, '> $1');
+    text = text.replace(/^>\s*$\n/gm, '');
+    text = text.replace(/\*\*([^\n*]+?)\*\*/g, '*$1*');
+    text = text.replace(/(^|[\s(>])__([^\n*][^_\n]*?)__(?=[\s).,!?:;]|$)/g, '$1*$2*');
+    text = text.replace(/(^|[\s(>])_([^\s_][^_\n]*?)_(?=[\s).,!?:;]|$)/g, '$1_$2_');
+    text = text.replace(/~~([^\n~]+?)~~/g, '~$1~');
+    text = text.replace(/^[ \t]*[-*+]\s+(.+)$/gm, '• $1');
+    text = text.replace(new RegExp(`${PH_OPEN}(\\d+)${PH_CLOSE}`, 'g'), (_, idx) => reserved[Number(idx)]);
+    return text;
+}
+
+export { markdownToSlackMrkdwn };

package/dist/src/addon/chat-controller/slack/slackChannelName.js

@@ -0,0 +1,3 @@
+const slackChannelName = 'SlackChannel';
+
+export { slackChannelName };

package/dist/src/addon/chat-controller/telegram/TelegramChannel.js

@@ -3,7 +3,7 @@ import { Bot } from 'grammy';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 import { injectable } from '../../../core/injection/index.js';
 import { Logger } from '../../../core/logger/Logger.js';
-import { markdownToTelegramHtml } from './markdownToTelegramHtml.js';
+import { markdownToChatHtml } from '../markdown/markdownToChatHtml.js';
 import { telegramChannelName } from './telegramChannelName.js';
 
 var TelegramChannel_1;
@@ -41,7 +41,7 @@ let TelegramChannel = class TelegramChannel {
                 reply: async (replyMessage) => {
                     if (!replyMessage.text)
                         return;
-                    await ctx.reply(markdownToTelegramHtml(replyMessage.text), {
+                    await ctx.reply(markdownToChatHtml(replyMessage.text), {
                         parse_mode: 'HTML',
                     });
                 },

package/dist/src/addon/ui/preact/PreactRenderer.js

@@ -0,0 +1,86 @@
+import { fileURLToPath } from 'node:url';
+import { options, h } from 'preact';
+import { renderToString } from 'preact-render-to-string';
+import '../../../core/injection/index.js';
+import '../../../feature/ui-controller/metadata/UiControllerMetadataStore.js';
+import '../../../feature/ui-controller/renderer/UiRendererRegistry.js';
+import { getIslandMeta } from '../../../feature/ui-controller/island/island.js';
+import { serializeProps } from '../../../feature/ui-controller/island/serialize.js';
+import '../../../feature/ui-controller/island/IslandRegistry.js';
+import '../../../core/error/setupErrorHandlers.js';
+import 'debug';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import '../../../feature/express/ExpressProvider.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import 'express';
+import 'node:path';
+import 'node:http';
+import 'node:crypto';
+import { OutletContext } from './outlet.js';
+
+/** Absolute path (no extension) to the browser hydration runtime, resolved by esbuild. */
+const PREACT_CLIENT_RUNTIME = fileURLToPath(new URL('./preactClientRuntime', import.meta.url));
+let currentCollector = null;
+const WRAPPED = '__wabotIslandWrapped';
+// Global Preact diff hook (`__b`), invoked per vnode *during* rendering by
+// preact-render-to-string. While an SSR collector is active, replace each
+// island vnode with a <wabot-island> host element that wraps the island's
+// server HTML and carries its serialized props, and record the island so the
+// page can ship its client bundle. Installed once on import (server only).
+const preactOptions = options;
+const previousDiffHook = preactOptions.__b;
+preactOptions.__b = (vnode) => {
+    if (currentCollector && vnode && typeof vnode.type === 'function' && !vnode[WRAPPED]) {
+        const meta = getIslandMeta(vnode.type);
+        if (meta) {
+            const props = vnode.props ?? {};
+            const id = meta.id ?? meta.name;
+            if (!currentCollector.seen.has(id)) {
+                currentCollector.seen.add(id);
+                currentCollector.islands.push({ id, props });
+            }
+            vnode.type = 'wabot-island';
+            vnode.props = {
+                'data-island': id,
+                'data-props': serializeProps(props),
+                children: h(meta.component, props),
+            };
+            vnode[WRAPPED] = true;
+        }
+    }
+    previousDiffHook?.(vnode);
+};
+/**
+ * Default UI renderer backed by Preact + @preact/signals. Renders views to HTML
+ * and emits hydration hosts for any component wrapped with `island()`.
+ */
+class PreactRenderer {
+    id = 'preact';
+    client = {
+        runtimeModule: PREACT_CLIENT_RUNTIME,
+        esbuildJsx: { jsx: 'automatic', jsxImportSource: 'preact' },
+        islandEntrySource: ({ id, importPath }) => `import { registerIsland } from ${JSON.stringify(PREACT_CLIENT_RUNTIME)}\n` +
+            `import Island from ${JSON.stringify(importPath)}\n` +
+            `registerIsland(${JSON.stringify(id)}, Island)\n`,
+    };
+    renderToString(node, context) {
+        // With a layout, render the view inside the shell where <Outlet/> sits.
+        // Without one (or for boosted-nav fragments), render the view directly.
+        const Layout = context?.layout;
+        const tree = Layout
+            ? h(OutletContext.Provider, { value: node }, h(Layout, {}))
+            : node;
+        const collector = { islands: [], seen: new Set() };
+        const previous = currentCollector;
+        currentCollector = collector;
+        try {
+            const html = renderToString(tree);
+            return { html, islands: collector.islands, styles: [] };
+        }
+        finally {
+            currentCollector = previous;
+        }
+    }
+}
+
+export { PreactRenderer };

package/dist/src/addon/ui/preact/outlet.js

@@ -0,0 +1,22 @@
+import { createContext, h } from 'preact';
+import { useContext } from 'preact/hooks';
+
+/** SSR context carrying the current view node so `<Outlet/>` can render it. */
+const OutletContext = createContext(null);
+/**
+ * Placeholder a controller `layout` renders where the current view goes. Emits a
+ * `<wabot-outlet>` host wrapping the view's server HTML; during boosted
+ * navigation only this element's content is swapped, so the surrounding shell
+ * (and its islands) keep their state.
+ *
+ *   function Layout() {
+ *     return <div class="app"><Nav /><main><Outlet /></main></div>
+ *   }
+ *   @uiController({ path: '/panel', app: true, layout: Layout })
+ */
+function Outlet() {
+    const node = useContext(OutletContext);
+    return h('wabot-outlet', { 'data-wabot-outlet': '' }, node);
+}
+
+export { Outlet, OutletContext };

package/dist/src/addon/ui/preact/preactClientRuntime.js

@@ -0,0 +1,67 @@
+import { render, hydrate, h } from 'preact';
+
+// Browser hydration runtime for the Preact adapter. Bundled into the client by
+// UiBundler and shared across islands (and the boosted-nav runtime). Each
+// island's client bundle calls registerIsland(); this finds the matching
+// <wabot-island> hosts and hydrates them with their serialized props.
+//
+// The boosted-navigation runtime imports hydrateAll()/unmountRemoved() from
+// this same module. Because every island entry and the nav entry import this
+// module, esbuild hoists it into a single shared chunk, so they all share the
+// registry and mounted-hosts state below (one module instance per page).
+const registry = new Map();
+// Hosts we have hydrated. Kept as an iterable Set (not a WeakSet) so the nav
+// runtime can walk it to unmount hosts that have left the DOM after a swap.
+const mounted = new Set();
+function registerIsland(id, Component) {
+    registry.set(id, Component);
+    hydrateIsland(id);
+}
+function hydrateIsland(id) {
+    const Component = registry.get(id);
+    if (!Component || typeof document === 'undefined')
+        return;
+    const selector = `wabot-island[data-island="${id.replace(/["\\]/g, '\\$&')}"]`;
+    document.querySelectorAll(selector).forEach((el) => {
+        if (mounted.has(el))
+            return;
+        let props = {};
+        const raw = el.dataset.props;
+        if (raw) {
+            try {
+                props = JSON.parse(raw);
+            }
+            catch {
+                props = {};
+            }
+        }
+        hydrate(h(Component, props), el);
+        mounted.add(el);
+    });
+}
+/**
+ * Hydrate any not-yet-mounted hosts for every registered island. Called by the
+ * nav runtime after swapping in a new view: islands whose bundle already loaded
+ * earlier in the session won't re-run their entry, so this picks up their new
+ * hosts. Hosts of islands not yet loaded hydrate when their bundle imports.
+ */
+function hydrateAll() {
+    for (const id of registry.keys())
+        hydrateIsland(id);
+}
+/**
+ * Unmount islands whose host is no longer in the document (removed by a view
+ * swap), running Preact's teardown so effects/subscriptions don't leak.
+ */
+function unmountRemoved() {
+    if (typeof document === 'undefined')
+        return;
+    for (const el of mounted) {
+        if (!document.contains(el)) {
+            render(null, el);
+            mounted.delete(el);
+        }
+    }
+}
+
+export { hydrateAll, registerIsland, unmountRemoved };

package/dist/src/core/repository/CrudRepository.js

@@ -1,24 +1,24 @@
 class CrudRepository {
     find(id) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     findOrThrow(id) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     findByIds(ids) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     findAll(id) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     create(item) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     update(item) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     delete(item) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 }
 

package/dist/src/feature/async/computeDedupKey.js

@@ -12,7 +12,7 @@ function canonicalize(value) {
     const keys = Object.keys(value)
         .filter((k) => value[k] !== undefined)
         .sort();
-    return ('{' + keys.map((k) => JSON.stringify(k) + ':' + canonicalize(value[k])).join(',') + '}');
+    return '{' + keys.map((k) => JSON.stringify(k) + ':' + canonicalize(value[k])).join(',') + '}';
 }
 function computeDedupKey(commandData) {
     return createHash('sha256').update(canonicalize(commandData)).digest('hex');

package/dist/src/feature/pg/@pgExtension.js

@@ -16,13 +16,11 @@ function inheritsFrom(ctor, base) {
 }
 function pgExtension(repositoryClass) {
     if (typeof repositoryClass !== 'function') {
-        throw new Error(`@pgExtension: repository argument must be a class, ` +
-            `got ${typeof repositoryClass}`);
+        throw new Error(`@pgExtension: repository argument must be a class, ` + `got ${typeof repositoryClass}`);
     }
     return function (target) {
         if (!inheritsFrom(target, PgRepositoryBase)) {
-            throw new Error(`@pgExtension on ${target.name}: extension class must extend ` +
-                `PgRepositoryExtension.`);
+            throw new Error(`@pgExtension on ${target.name}: extension class must extend ` + `PgRepositoryExtension.`);
         }
         const store = container.resolve(RepositoryMetadataStore);
         store.saveExtension(repositoryClass, PG_ADAPTER_ID, target);