@probelabs/visor 0.1.154-ee → 0.1.155-ee

package/dist/cli-main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"","sourceRoot":"","sources":["file:///home/runner/work/visor/visor/src/cli-main.ts"],"names":[],"mappings":"AA6zBA;;GAEG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAg8C1C"}
+{"version":3,"file":"","sourceRoot":"","sources":["file:///home/runner/work/visor/visor/src/cli-main.ts"],"names":[],"mappings":"AA6zBA;;GAEG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA08C1C"}

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-process.env.VISOR_VERSION = '0.1.154';
+process.env.VISOR_VERSION = '0.1.155';
 process.env.PROBE_VERSION = '0.6.0-rc271';
-process.env.VISOR_COMMIT_SHA = '1ceb9f8073c3ec36e82c277d3e4bfcbf3320ba3b';
-process.env.VISOR_COMMIT_SHORT = '1ceb9f8';
+process.env.VISOR_COMMIT_SHA = '37220799c91e64df29a72348ad88a26bd94f6214';
+process.env.VISOR_COMMIT_SHORT = '3722079';
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -162275,6 +162275,8 @@ async function main() {
             await runner.start();
             console.log('✅ Slack Socket Mode is running. Press Ctrl+C to exit.');
             // Start config file watcher if --watch is enabled
+            let configWatcher;
+            let configWatchStore;
             if (options.watch) {
                 if (!options.configPath) {
                     console.error('❌ --watch requires --config <path>');
@@ -162298,23 +162300,34 @@ async function main() {
                     });
                     const watcher = new ConfigWatcher(options.configPath, reloader);
                     watcher.start();
+                    configWatcher = watcher;
+                    configWatchStore = watchStore;
                     logger_1.logger.info('Config watching enabled');
-                    // Clean up watcher resources on process shutdown, then re-raise
-                    // the signal so the default handler (or other listeners) can terminate.
-                    const onSignal = (sig) => {
-                        watcher.stop();
-                        watchStore.shutdown().catch(() => { });
-                        process.removeListener('SIGINT', onSignal);
-                        process.removeListener('SIGTERM', onSignal);
-                        process.kill(process.pid, sig);
-                    };
-                    process.on('SIGINT', onSignal);
-                    process.on('SIGTERM', onSignal);
                 }
                 catch (watchErr) {
                     logger_1.logger.warn(`Config watch setup failed (Slack mode continues without it): ${watchErr}`);
                 }
             }
+            // Graceful shutdown: notify active threads before exiting
+            let shuttingDown = false;
+            const onShutdown = async (sig) => {
+                if (shuttingDown)
+                    return;
+                shuttingDown = true;
+                logger_1.logger.info(`[Slack] Received ${sig}, shutting down gracefully…`);
+                if (configWatcher)
+                    configWatcher.stop();
+                if (configWatchStore)
+                    configWatchStore.shutdown().catch(() => { });
+                await runner.stop();
+                process.exit(0);
+            };
+            process.on('SIGINT', sig => {
+                onShutdown(sig);
+            });
+            process.on('SIGTERM', sig => {
+                onShutdown(sig);
+            });
             process.stdin.resume();
             return;
         }
@@ -199087,6 +199100,23 @@ class SlackClient {
             }
         },
     };
+    views = {
+        publish: async ({ user_id, view, }) => {
+            try {
+                const resp = await this.api('views.publish', { user_id, view });
+                if (!resp || resp.ok !== true) {
+                    const err = (resp && resp.error) || 'unknown_error';
+                    console.warn(`Slack views.publish failed (non-fatal): ${err}`);
+                    return { ok: false, error: err };
+                }
+                return { ok: true };
+            }
+            catch (e) {
+                console.warn(`Slack views.publish threw (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
+                return { ok: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        },
+    };
     getWebClient() {
         return {
             conversations: {
@@ -200214,6 +200244,7 @@ class SlackSocketRunner {
     retryCount = 0;
     genericScheduler;
     messageTriggerEvaluator;
+    activeThreads = new Set();
     constructor(engine, cfg, opts) {
         const app = opts.appToken || process.env.SLACK_APP_TOKEN || '';
         if (!app)
@@ -200521,6 +200552,11 @@ class SlackSocketRunner {
             await this.ensureClient();
         }
         catch { }
+        // Handle app_home_opened — publish Home tab view and return early
+        if (type === 'app_home_opened') {
+            await this.publishAppHome(String(ev.user || ''));
+            return;
+        }
         // Ignore edited/changed events to prevent loops (allow file_share — users can share attachments)
         if (subtype &&
             subtype !== 'thread_broadcast' &&
@@ -200751,6 +200787,9 @@ class SlackSocketRunner {
         }
         catch { }
         logger_1.logger.info('[SlackSocket] Dispatching engine run for Slack event');
+        const trackChannel = String(ev.channel || '');
+        const trackThreadTs = String(ev.thread_ts || ev.ts || ev.event_ts || '');
+        const threadKey = trackChannel && trackThreadTs ? this.trackThread(trackChannel, trackThreadTs) : '';
         try {
             // Rate limiting (optional)
             const userId = String(ev.user || 'unknown');
@@ -200837,6 +200876,10 @@ class SlackSocketRunner {
         catch (e) {
             logger_1.logger.error(`[SlackSocket] Engine execution failed: ${e instanceof Error ? e.message : String(e)}`);
         }
+        finally {
+            if (threadKey)
+                this.untrackThread(threadKey);
+        }
     }
     /**
      * Dispatch a matched message trigger as an asynchronous workflow execution.
@@ -200848,121 +200891,334 @@ class SlackSocketRunner {
         const ts = String(ev.ts || ev.event_ts || '');
         const threadTs = ev.thread_ts ? String(ev.thread_ts) : undefined;
         const user = String(ev.user || 'unknown');
+        const replyTs = threadTs || ts;
+        const threadKey = channel && replyTs ? this.trackThread(channel, replyTs) : '';
         logger_1.logger.info(`[SlackSocket] Message trigger '${id}' matched → workflow="${trigger.workflow}" channel=${channel} ts=${ts}`);
-        // Verify workflow exists
-        const allChecks = Object.keys(this.cfg.checks || {});
-        if (!allChecks.includes(trigger.workflow)) {
-            logger_1.logger.error(`[SlackSocket] Message trigger '${id}': workflow "${trigger.workflow}" not found in configuration`);
-            return;
-        }
-        // Build conversation context (for thread replies, fetch full thread)
-        let conversationContext = undefined;
         try {
-            const isThreadReply = !!threadTs && threadTs !== ts;
-            if (isThreadReply) {
-                const adapter = this.getSlackAdapter();
-                if (adapter && channel && threadTs) {
-                    const cleanedText = String(ev.text || '')
-                        .replace(/<@[A-Z0-9]+>/g, '')
-                        .trim();
-                    conversationContext = await adapter.fetchConversation(channel, threadTs, {
-                        ts,
-                        user,
-                        text: cleanedText || String(ev.text || ''),
-                        timestamp: Date.now(),
-                        files: Array.isArray(ev.files) ? ev.files : undefined,
-                    });
+            // Verify workflow exists
+            const allChecks = Object.keys(this.cfg.checks || {});
+            if (!allChecks.includes(trigger.workflow)) {
+                logger_1.logger.error(`[SlackSocket] Message trigger '${id}': workflow "${trigger.workflow}" not found in configuration`);
+                return;
+            }
+            // Build conversation context (for thread replies, fetch full thread)
+            let conversationContext = undefined;
+            try {
+                const isThreadReply = !!threadTs && threadTs !== ts;
+                if (isThreadReply) {
+                    const adapter = this.getSlackAdapter();
+                    if (adapter && channel && threadTs) {
+                        const cleanedText = String(ev.text || '')
+                            .replace(/<@[A-Z0-9]+>/g, '')
+                            .trim();
+                        conversationContext = await adapter.fetchConversation(channel, threadTs, {
+                            ts,
+                            user,
+                            text: cleanedText || String(ev.text || ''),
+                            timestamp: Date.now(),
+                            files: Array.isArray(ev.files) ? ev.files : undefined,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                logger_1.logger.warn(`[SlackSocket] Message trigger '${id}': conversation context fetch failed: ${err instanceof Error ? err.message : err}`);
+            }
+            // Build synthetic webhook payload
+            const triggerPayload = {
+                ...payload,
+                trigger: {
+                    id,
+                    type: 'on_message',
+                    workflow: trigger.workflow,
+                },
+                ...(conversationContext ? { slack_conversation: conversationContext } : {}),
+            };
+            const webhookData = new Map();
+            webhookData.set(this.endpoint, triggerPayload);
+            // Clone config for this run with Slack frontend
+            const cfgForRun = (() => {
+                try {
+                    const cfg = JSON.parse(JSON.stringify(this.cfg));
+                    const fronts = Array.isArray(cfg.frontends) ? cfg.frontends : [];
+                    if (!fronts.some((f) => f && f.name === 'slack'))
+                        fronts.push({ name: 'slack' });
+                    cfg.frontends = fronts;
+                    return cfg;
+                }
+                catch {
+                    return this.cfg;
                 }
+            })();
+            // Derive stable workspace name from thread identity
+            const wsThreadTs = threadTs || ts;
+            if (channel && wsThreadTs) {
+                const hash = (0, crypto_1.createHash)('sha256')
+                    .update(`${channel}:${wsThreadTs}`)
+                    .digest('hex')
+                    .slice(0, 8);
+                const workspaceName = `slack-trigger-${hash}`;
+                if (!cfgForRun.workspace) {
+                    cfgForRun.workspace = {};
+                }
+                cfgForRun.workspace.name = workspaceName;
+                cfgForRun.workspace.cleanup_on_exit = false;
+            }
+            // Create a dedicated engine instance for this trigger
+            const runEngine = new state_machine_execution_engine_1.StateMachineExecutionEngine();
+            await this.ensureClient();
+            try {
+                const parentCtx = this.engine.getExecutionContext?.() || {};
+                const prevCtx = runEngine.getExecutionContext?.() || {};
+                runEngine.setExecutionContext?.({
+                    ...parentCtx,
+                    ...prevCtx,
+                    slack: this.client || parentCtx.slack,
+                    slackClient: this.client || parentCtx.slackClient,
+                });
             }
+            catch { }
+            // Refresh GitHub credentials
+            try {
+                const { refreshGitHubCredentials } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(11347)));
+                await refreshGitHubCredentials();
+            }
+            catch { }
+            await (0, trace_helpers_1.withActiveSpan)('visor.run', {
+                ...(0, trace_helpers_1.getVisorRunAttributes)(),
+                'visor.run.source': 'slack_message_trigger',
+                'visor.trigger.id': id,
+                'visor.trigger.workflow': trigger.workflow,
+                'slack.channel_id': channel,
+                'slack.thread_ts': threadTs || ts,
+                'slack.user_id': user,
+            }, async () => {
+                await runEngine.executeChecks({
+                    checks: [trigger.workflow],
+                    showDetails: true,
+                    outputFormat: 'json',
+                    config: cfgForRun,
+                    webhookContext: { webhookData, eventType: 'slack_message' },
+                    debug: process.env.VISOR_DEBUG === 'true',
+                    inputs: trigger.inputs,
+                });
+            });
+            logger_1.logger.info(`[SlackSocket] Message trigger '${id}' workflow completed`);
         }
-        catch (err) {
-            logger_1.logger.warn(`[SlackSocket] Message trigger '${id}': conversation context fetch failed: ${err instanceof Error ? err.message : err}`);
+        finally {
+            if (threadKey)
+                this.untrackThread(threadKey);
         }
-        // Build synthetic webhook payload
-        const triggerPayload = {
-            ...payload,
-            trigger: {
-                id,
-                type: 'on_message',
-                workflow: trigger.workflow,
-            },
-            ...(conversationContext ? { slack_conversation: conversationContext } : {}),
-        };
-        const webhookData = new Map();
-        webhookData.set(this.endpoint, triggerPayload);
-        // Clone config for this run with Slack frontend
-        const cfgForRun = (() => {
+    }
+    trackThread(channel, threadTs) {
+        const key = `${channel}:${threadTs}`;
+        this.activeThreads.add(key);
+        return key;
+    }
+    untrackThread(key) {
+        this.activeThreads.delete(key);
+    }
+    /**
+     * Send a best-effort shutdown notice to all active Slack threads.
+     * Bounded by timeoutMs so we never block process exit indefinitely.
+     */
+    async notifyActiveThreadsOfShutdown(timeoutMs = 5000) {
+        if (this.activeThreads.size === 0 || !this.client)
+            return;
+        const msg = ':warning: The bot was restarted. Your request was interrupted and could not be completed. Please retry by sending your message again.';
+        const promises = [...this.activeThreads].map(key => {
+            const [channel, threadTs] = key.split(':');
+            return this.client.chat.postMessage({ channel, thread_ts: threadTs, text: msg }).catch(err => {
+                logger_1.logger.warn(`[SlackSocket] Failed to notify thread ${key} of shutdown: ${err instanceof Error ? err.message : err}`);
+            });
+        });
+        try {
+            let timer;
+            await Promise.race([
+                Promise.allSettled(promises),
+                new Promise(resolve => {
+                    timer = setTimeout(resolve, timeoutMs);
+                }),
+            ]);
+            if (timer)
+                clearTimeout(timer);
+        }
+        catch {
+            // best effort
+        }
+    }
+    /**
+     * Publish the App Home tab for the given user.
+     * Shows the user's schedules, message triggers, and available workflows.
+     */
+    async publishAppHome(userId) {
+        if (!userId || !this.client)
+            return;
+        try {
+            const userInfo = await this.fetchUserInfo(userId);
+            // Fetch user's schedules and triggers from the store (best-effort)
+            let schedules = [];
+            let triggers = [];
             try {
-                const cfg = JSON.parse(JSON.stringify(this.cfg));
-                const fronts = Array.isArray(cfg.frontends) ? cfg.frontends : [];
-                if (!fronts.some((f) => f && f.name === 'slack'))
-                    fronts.push({ name: 'slack' });
-                cfg.frontends = fronts;
-                return cfg;
+                const store = schedule_store_1.ScheduleStore.getInstance();
+                if (store.isInitialized()) {
+                    schedules = await store.getByCreatorAsync(userId);
+                    triggers = await store.getTriggersByCreatorAsync(userId);
+                }
             }
-            catch {
-                return this.cfg;
+            catch (err) {
+                logger_1.logger.warn(`[SlackSocket] Failed to fetch schedules/triggers for Home tab: ${err instanceof Error ? err.message : err}`);
             }
-        })();
-        // Derive stable workspace name from thread identity
-        const wsThreadTs = threadTs || ts;
-        if (channel && wsThreadTs) {
-            const hash = (0, crypto_1.createHash)('sha256')
-                .update(`${channel}:${wsThreadTs}`)
-                .digest('hex')
-                .slice(0, 8);
-            const workspaceName = `slack-trigger-${hash}`;
-            if (!cfgForRun.workspace) {
-                cfgForRun.workspace = {};
+            // Get available workflows
+            let workflows = [];
+            try {
+                const { WorkflowRegistry } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(82824)));
+                const registry = WorkflowRegistry.getInstance();
+                workflows = registry
+                    .list()
+                    .map(w => ({ id: w.id, name: w.name, description: w.description }));
             }
-            cfgForRun.workspace.name = workspaceName;
-            cfgForRun.workspace.cleanup_on_exit = false;
+            catch (err) {
+                logger_1.logger.warn(`[SlackSocket] Failed to fetch workflows for Home tab: ${err instanceof Error ? err.message : err}`);
+            }
+            const blocks = this.buildHomeBlocks(userInfo, schedules, triggers, workflows);
+            await this.client.views.publish({
+                user_id: userId,
+                view: { type: 'home', blocks },
+            });
         }
-        // Create a dedicated engine instance for this trigger
-        const runEngine = new state_machine_execution_engine_1.StateMachineExecutionEngine();
-        await this.ensureClient();
-        try {
-            const parentCtx = this.engine.getExecutionContext?.() || {};
-            const prevCtx = runEngine.getExecutionContext?.() || {};
-            runEngine.setExecutionContext?.({
-                ...parentCtx,
-                ...prevCtx,
-                slack: this.client || parentCtx.slack,
-                slackClient: this.client || parentCtx.slackClient,
+        catch (err) {
+            logger_1.logger.error(`[SlackSocket] app_home_opened failed: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    /**
+     * Build Slack Block Kit blocks for the App Home tab.
+     * Exposed as a separate method for testability.
+     */
+    buildHomeBlocks(userInfo, schedules, triggers, workflows) {
+        const blocks = [];
+        // Header
+        const greeting = userInfo?.realName || userInfo?.name || 'there';
+        blocks.push({
+            type: 'header',
+            text: { type: 'plain_text', text: `Hi, ${greeting}!` },
+        });
+        blocks.push({
+            type: 'section',
+            text: { type: 'mrkdwn', text: "Here's an overview of your Visor activity." },
+        });
+        blocks.push({ type: 'divider' });
+        // --- Schedules section ---
+        blocks.push({
+            type: 'header',
+            text: { type: 'plain_text', text: 'Your Schedules' },
+        });
+        const activeSchedules = schedules.filter(s => s.status === 'active' || s.status === 'paused');
+        if (activeSchedules.length === 0) {
+            blocks.push({
+                type: 'section',
+                text: { type: 'mrkdwn', text: '_No active schedules. Message the bot to create one._' },
             });
         }
-        catch { }
-        // Refresh GitHub credentials
-        try {
-            const { refreshGitHubCredentials } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(11347)));
-            await refreshGitHubCredentials();
+        else {
+            for (const s of activeSchedules.slice(0, 15)) {
+                const statusIcon = s.status === 'paused' ? ':double_vertical_bar:' : ':clock1:';
+                const desc = s.originalExpression || s.workflow || s.id;
+                const nextRun = s.nextRunAt
+                    ? `<!date^${Math.floor(s.nextRunAt / 1000)}^{date_short_pretty} at {time}|${new Date(s.nextRunAt).toISOString()}>`
+                    : 'N/A';
+                const recurring = s.isRecurring ? `\`${s.schedule}\`` : 'one-time';
+                blocks.push({
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `${statusIcon} *${desc}*\n${recurring} · Next: ${nextRun} · Status: \`${s.status}\``,
+                    },
+                });
+            }
+            if (activeSchedules.length > 15) {
+                blocks.push({
+                    type: 'context',
+                    elements: [{ type: 'mrkdwn', text: `_…and ${activeSchedules.length - 15} more_` }],
+                });
+            }
         }
-        catch { }
-        await (0, trace_helpers_1.withActiveSpan)('visor.run', {
-            ...(0, trace_helpers_1.getVisorRunAttributes)(),
-            'visor.run.source': 'slack_message_trigger',
-            'visor.trigger.id': id,
-            'visor.trigger.workflow': trigger.workflow,
-            'slack.channel_id': channel,
-            'slack.thread_ts': threadTs || ts,
-            'slack.user_id': user,
-        }, async () => {
-            await runEngine.executeChecks({
-                checks: [trigger.workflow],
-                showDetails: true,
-                outputFormat: 'json',
-                config: cfgForRun,
-                webhookContext: { webhookData, eventType: 'slack_message' },
-                debug: process.env.VISOR_DEBUG === 'true',
-                inputs: trigger.inputs,
+        blocks.push({ type: 'divider' });
+        // --- Triggers section ---
+        blocks.push({
+            type: 'header',
+            text: { type: 'plain_text', text: 'Your Message Triggers' },
+        });
+        const activeTriggers = triggers.filter(t => t.status === 'active');
+        if (activeTriggers.length === 0) {
+            blocks.push({
+                type: 'section',
+                text: { type: 'mrkdwn', text: '_No active message triggers._' },
             });
+        }
+        else {
+            for (const t of activeTriggers.slice(0, 10)) {
+                const enabledIcon = t.enabled ? ':large_green_circle:' : ':white_circle:';
+                const desc = t.description || t.workflow;
+                const filters = [];
+                if (t.channels?.length)
+                    filters.push(`channels: ${t.channels.join(', ')}`);
+                if (t.contains?.length)
+                    filters.push(`contains: ${t.contains.join(', ')}`);
+                if (t.matchPattern)
+                    filters.push(`pattern: \`${t.matchPattern}\``);
+                blocks.push({
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `${enabledIcon} *${desc}*\n${filters.join(' · ') || 'no filters'} → \`${t.workflow}\``,
+                    },
+                });
+            }
+            if (activeTriggers.length > 10) {
+                blocks.push({
+                    type: 'context',
+                    elements: [{ type: 'mrkdwn', text: `_…and ${activeTriggers.length - 10} more_` }],
+                });
+            }
+        }
+        blocks.push({ type: 'divider' });
+        // --- Workflows section ---
+        blocks.push({
+            type: 'header',
+            text: { type: 'plain_text', text: 'Available Workflows' },
         });
-        logger_1.logger.info(`[SlackSocket] Message trigger '${id}' workflow completed`);
+        if (workflows.length === 0) {
+            blocks.push({
+                type: 'section',
+                text: { type: 'mrkdwn', text: '_No workflows registered._' },
+            });
+        }
+        else {
+            for (const w of workflows.slice(0, 15)) {
+                blocks.push({
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `*${w.name || w.id}*${w.description ? `\n${w.description}` : ''}`,
+                    },
+                });
+            }
+            if (workflows.length > 15) {
+                blocks.push({
+                    type: 'context',
+                    elements: [{ type: 'mrkdwn', text: `_…and ${workflows.length - 15} more_` }],
+                });
+            }
+        }
+        return blocks;
     }
     /**
      * Stop the socket runner and clean up resources
      */
     async stop() {
+        // Notify active threads before tearing down
+        await this.notifyActiveThreadsOfShutdown();
         // Stop background GitHub App token refresh
         try {
             const { stopTokenRefreshTimer } = await Promise.resolve().then(() => __importStar(__nccwpck_require__(11347)));

package/dist/sdk/{check-provider-registry-PZ6K7G4G.mjs → check-provider-registry-OBUYAPPC.mjs}

@@ -1,7 +1,7 @@
 import {
   CheckProviderRegistry,
   init_check_provider_registry
-} from "./chunk-LIRIQICI.mjs";
+} from "./chunk-2XSKH755.mjs";
 import "./chunk-KFKHU6CM.mjs";
 import "./chunk-M3BYMES6.mjs";
 import "./chunk-LG4AUKHB.mjs";
@@ -26,4 +26,4 @@ init_check_provider_registry();
 export {
   CheckProviderRegistry
 };
-//# sourceMappingURL=check-provider-registry-PZ6K7G4G.mjs.map
+//# sourceMappingURL=check-provider-registry-OBUYAPPC.mjs.map

package/dist/sdk/{chunk-LIRIQICI.mjs → chunk-2XSKH755.mjs}

@@ -3959,7 +3959,7 @@ async function executeWorkflowAsTool(workflowId, args, context2, argsOverrides)
     ...args,
     ...argsOverrides
   };
-  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-TXAEY7OU.mjs");
+  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-7RLM3T2I.mjs");
   const provider = new WorkflowCheckProvider2();
   const checkConfig = {
     type: "workflow",
@@ -13027,7 +13027,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const map = options?.webhookContext?.webhookData;
             if (map) {
-              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-PZ6K7G4G.mjs");
+              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-OBUYAPPC.mjs");
               const reg = CheckProviderRegistry2.getInstance();
               const p = reg.getProvider("http_input");
               if (p && typeof p.setWebhookContext === "function") p.setWebhookContext(map);
@@ -13150,7 +13150,7 @@ var init_state_machine_execution_engine = __esm({
           tag_filter: tagFilter
         } : config;
         try {
-          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-PZ6K7G4G.mjs");
+          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-OBUYAPPC.mjs");
           const registry = CheckProviderRegistry2.getInstance();
           registry.setCustomTools(configWithTagFilter.tools || {});
         } catch (error) {
@@ -13214,7 +13214,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const webhookData = this.executionContext?.webhookContext?.webhookData;
             if (webhookData instanceof Map) {
-              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-2V4EJEQT.mjs");
+              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-J3CJWB6A.mjs");
               const slackCtx = extractSlackContext2(webhookData);
               if (slackCtx) {
                 const payload = Array.from(webhookData.values())[0];
@@ -13243,7 +13243,7 @@ var init_state_machine_execution_engine = __esm({
         if (Array.isArray(configWithTagFilter.frontends) && configWithTagFilter.frontends.length > 0) {
           try {
             const { EventBus } = await import("./event-bus-5K3Y2FCS.mjs");
-            const { FrontendsHost } = await import("./host-7Y25DDOR.mjs");
+            const { FrontendsHost } = await import("./host-MIHKJ63G.mjs");
             const bus = new EventBus();
             context2.eventBus = bus;
             frontendsHost = new FrontendsHost(bus, logger);
@@ -40722,8 +40722,8 @@ function buildBuiltinGlobals(opts) {
   const asyncFunctionNames = /* @__PURE__ */ new Set();
   const scheduleFn = async (args = {}) => {
     try {
-      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-KZ36XTW4.mjs");
-      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-2V4EJEQT.mjs");
+      const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-M2H7O5WL.mjs");
+      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-J3CJWB6A.mjs");
       const parentCtx = opts.sessionInfo?._parentContext;
       const webhookData = parentCtx?.prInfo?.eventContext?.webhookData;
       const visorCfg = parentCtx?.config;
@@ -43771,4 +43771,4 @@ undici/lib/fetch/body.js:
 undici/lib/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
-//# sourceMappingURL=chunk-LIRIQICI.mjs.map
+//# sourceMappingURL=chunk-2XSKH755.mjs.map

package/dist/sdk/{host-7Y25DDOR.mjs → host-MIHKJ63G.mjs}

@@ -24,7 +24,7 @@ var init_host = __esm({
             const { GitHubFrontend } = await import("./github-frontend-XKPAYXOT.mjs");
             this.frontends.push(new GitHubFrontend());
           } else if (spec.name === "slack") {
-            const { SlackFrontend } = await import("./slack-frontend-TZU2HIK7.mjs");
+            const { SlackFrontend } = await import("./slack-frontend-6KDUMDDI.mjs");
             this.frontends.push(new SlackFrontend(spec.config));
           } else if (spec.name === "tui") {
             const { TuiFrontend } = await import("./tui-frontend-T56PZB67.mjs");
@@ -60,4 +60,4 @@ init_host();
 export {
   FrontendsHost
 };
-//# sourceMappingURL=host-7Y25DDOR.mjs.map
+//# sourceMappingURL=host-MIHKJ63G.mjs.map