tinybeeai 0.0.0-stage → 0.16.1

package/dist/slack/index.js

@@ -0,0 +1,645 @@
+// Slack bot over Socket Mode (no public URL). A mention routes to a dot and the dot answers in the thread.
+// Outage and digest notices post to the dot's slackChannel through gate() as ActionKind 'slack_post'.
+import { config, liveEnv, log, onSettingsChange } from '../config.js';
+import { logRefused, sandboxOn, sandboxSkips } from '../sandbox.js';
+import { get, insert, list } from '../db.js';
+import { getMeta, setMeta } from '../connect/store.js';
+import { publish } from '../events.js';
+import { answerChat } from '../agent/chat.js';
+import { mdText, renderRefs } from '../refs.js';
+import { LinkTrust, serverUrlTrusted } from '../link-trust.js';
+import { approveAction, effectiveLevel, gate, rejectAction, safeReview } from '../agent/rules.js';
+import { redactCode } from '../agent/redact.js';
+import { workLine } from '../agent/reasoning.js';
+import { updatesOwnDelivery } from '../updates/owner.js';
+import { appUrl, decisionText, slackLink } from '../updates/words.js';
+const MAX_TEXT = 39_000;
+const NOTICE_DEDUPE_MS = 10 * 60_000;
+let client;
+let app;
+let status = { state: 'off' };
+/** Thread ts -> dot id, so follow-up mentions in a thread stay with the same dot. */
+const threadDots = new Map();
+const noticeSent = new Map();
+/** True once the server has called startSlack(), so saved tokens (re)start Socket Mode live. */
+let wanted = false;
+let restarting = Promise.resolve();
+onSettingsChange((keys) => {
+    if (!wanted || !keys.some((k) => k === 'SLACK_BOT_TOKEN' || k === 'SLACK_APP_TOKEN'))
+        return;
+    restarting = restarting
+        .then(async () => {
+        await stopSlack();
+        wanted = true;
+        await startSlack();
+    })
+        .catch((err) => log.warn(`slack: restart after a settings change failed: ${String(err)}`));
+});
+function csv(v) {
+    return (v ?? '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+export function slackConfigured() {
+    return Boolean(liveEnv.SLACK_APP_TOKEN && liveEnv.SLACK_BOT_TOKEN);
+}
+/** Team and user allowlists. An unset list allows everyone the app's install already reaches. */
+export function slackAllowed(teamId, userId) {
+    const teams = csv(liveEnv.SLACK_ALLOWED_TEAM);
+    const users = csv(liveEnv.SLACK_ALLOWED_USERS);
+    if (teams.length && (!teamId || !teams.includes(teamId)))
+        return false;
+    if (users.length && (!userId || !users.includes(userId)))
+        return false;
+    return true;
+}
+/** Readiness row for GET /api/setup, plus the live connection flag. */
+export function slackStatus() {
+    const base = { key: 'slack', label: 'Slack', docs: 'docs/SETUP.md#slack' };
+    const allowlist = { teams: csv(liveEnv.SLACK_ALLOWED_TEAM).length, users: csv(liveEnv.SLACK_ALLOWED_USERS).length };
+    if (!slackConfigured()) {
+        return { ...base, state: 'missing', detail: 'Set SLACK_APP_TOKEN and SLACK_BOT_TOKEN for Socket Mode.', connected: false, allowlist };
+    }
+    if (status.state === 'error')
+        return { ...base, state: 'error', detail: status.error ?? 'Slack connection failed.', connected: false, allowlist };
+    const open = !allowlist.teams && !allowlist.users ? ' No allowlist set.' : '';
+    if (status.state === 'connected')
+        return {
+            ...base,
+            state: 'ready',
+            detail: `Socket Mode, connected${status.team ? ` to ${status.team}` : ''}.${open} ${INTERACTIVITY_TIP}`,
+            connected: true,
+            allowlist,
+        };
+    return {
+        ...base,
+        state: 'ready',
+        detail: `Socket Mode, ${status.state === 'connecting' ? 'connecting' : 'not started'}.${open}`,
+        connected: false,
+        allowlist,
+    };
+}
+/** Escapes the three characters Slack treats as markup, so untrusted text shows as typed. */
+export function escapeMrkdwn(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/** Text that shows as typed, inside a code span: Slack makes no link of it, and the characters Slack reads as markup stay escaped. */
+function codeSpan(s) {
+    return `\`${escapeMrkdwn(s.replace(/[`\u0000]/g, ''))}\``;
+}
+/** `<url|label>`, with the text and the address escaped so a `|` or `>` cannot end the link. */
+function liveLink(url, label) {
+    const addr = escapeMrkdwn(url).replace(/\|/g, '%7C');
+    return label === undefined ? `<${addr}>` : `<${addr}|${escapeMrkdwn(label).replace(/\|/g, '\u00a6')}>`;
+}
+const SCHEME = String.raw `(?:https?:\/\/|mailto:)`;
+const URL_LIKE = /https?:\/\/|www\.|mailto:|[\w.+-]+@[\w-]+\.[\w.-]+|\]\(/i;
+const EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+/g;
+// A host name with no scheme and no `www.`, which Slack makes a link by itself: `evil.com`, `login.bank`, `evil.studio`. Slack links a name
+// that ends in any real top-level domain, and there are over a thousand, so the list below is of the endings that are file names and not
+// domains: `app.ts`, `package.json`, `styles.css`, `Node.js` stay as they are. Any other ending of 2 to 24 letters counts as a domain, with or
+// without a path, and a dotted word such as `cart.total` then shows in a code span, which does no harm. A file ending counts only with a path
+// (`evil.js/login`). `md`, `sh`, `py` and `rs` are country domains too, so they are not on the list: `README.md` shows in a code span.
+const FILE_ENDINGS = 'js|jsx|mjs|cjs|ts|tsx|mts|cts|json|jsonc|json5|mdx|txt|log|yml|yaml|toml|ini|cfg|conf|env|lock|css|scss|sass|less|html|htm|xml|svg|png|jpg|jpeg|gif|webp|ico|pdf|csv|tsv|sql|bash|zsh|rb|go|java|kt|swift|php|cs|cpp|hpp|vue|svelte|map|gz|tgz|tar|bak|tmp|spec|test|snap|diff|patch';
+const BARE_HOST = new RegExp(String.raw `(?<![\w@./:+-])(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:(?!(?:${FILE_ENDINGS})(?![\w-]))[a-z]{2,24}(?![\w-])(?!\.[\w-])(?::\d+)?(?:\/[^\s<>"'\u0060\u0000]*)?|[a-z]{2,24}(?::\d+)?\/[^\s<>"'\u0060\u0000]*)`, 'gi');
+/**
+ * Converts the chat's Markdown to Slack mrkdwn: bold, links, headings. Every other character is escaped, so a PR
+ * title like `<!channel>` or `<https://evil|Open details>` stays plain text; only the `[text](https://...)` links
+ * the server builds become `<url|text>`, with their text and address escaped so a `|` or `>` cannot end the link.
+ * With `opts.trusted`, "the server builds" is decided per address (see MrkdwnOptions).
+ */
+export function toMrkdwn(md, opts = {}) {
+    const held = [];
+    const hold = (s) => `\u0000${held.push(s) - 1}\u0000`;
+    const trusted = opts.trusted;
+    let text = md.replace(/\u0000/g, '');
+    if (!trusted) {
+        text = text.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, (_m, label, url) => hold(liveLink(url, label)));
+    }
+    else {
+        const live = (url) => /^https?:\/\//i.test(url) && trusted(url);
+        /** Bare addresses and e-mail addresses of a stretch of text. */
+        const bare = (s) => s
+            .replace(/(?:https?:\/\/|www\.)[^\s<>"'`\u0000]+/gi, (m) => {
+            const trail = /[.,;:!?)\]}]+$/.exec(m)?.[0] ?? '';
+            const url = trail ? m.slice(0, -trail.length) : m;
+            return (live(url) ? hold(liveLink(url)) : hold(codeSpan(url))) + trail;
+        })
+            .replace(EMAIL, (m) => hold(codeSpan(m)))
+            .replace(BARE_HOST, (m) => {
+            const trail = /[.,;:!?)\]}]+$/.exec(m)?.[0] ?? '';
+            return hold(codeSpan(trail ? m.slice(0, -trail.length) : m)) + trail;
+        });
+        /** A link that is not live: the label (its own addresses made inert too), then the address as code. */
+        const inert = (label, url) => {
+            const l = label?.trim();
+            return hold(l && l !== url ? `${escapeMrkdwn(bare(l))} (${hold(codeSpan(url))})` : codeSpan(url));
+        };
+        // The model's own code spans: one with an address in it loses its backticks and is handled as text (its address then gets a span of
+        // ours), one without keeps its form. Any backtick left over becomes a look-alike, so no stray one can pair with a span of ours.
+        // A fence keeps its own three backticks at each end and loses the ones inside it: an odd number of them in the fence would make the count
+        // of backticks in the text odd, and clip would then cut at the end of a span of ours and leave it open.
+        text = text.replace(/```[\s\S]*?```|`[^`\n]+`/g, (m) => URL_LIKE.test(m) ? m.replace(/`/g, '') : hold(escapeMrkdwn(m.startsWith('```') ? `\`\`\`${m.slice(3, -3).replace(/`/g, '\u02cb')}\`\`\`` : m)));
+        text = text.replace(/`/g, '\u02cb');
+        text = text.replace(new RegExp(String.raw `\[([^\]]+)\]\((${SCHEME}[^)\s]*)\)`, 'gi'), (_m, label, url) => live(url) ? hold(liveLink(url, label)) : inert(label, url));
+        text = text.replace(new RegExp(String.raw `<(${SCHEME}[^>|\s]*)(?:\|([^>]*))?>`, 'gi'), (_m, url, label) => live(url) ? hold(liveLink(url, label ?? url)) : inert(label, url));
+        text = bare(text);
+    }
+    let out = escapeMrkdwn(text);
+    if (opts.lookAlike)
+        out = mdText(out);
+    out = out.replace(/^#{1,6}\s+(.+)$/gm, '*$1*').replace(/\*\*(.+?)\*\*/g, '*$1*');
+    // A held piece may hold another (the address in a label).
+    for (let i = 0; i <= held.length && /\u0000\d+\u0000/.test(out); i++)
+        out = out.replace(/\u0000(\d+)\u0000/g, (_m, n) => held[Number(n)] ?? '');
+    return out;
+}
+/** A chat answer as Slack text (KAT-380): only an address server code built in this turn is a live link. */
+export function answerMrkdwn(md, trust) {
+    // An app link the server wrote as a page of the app (`#/cases?...`, the designed test cases) opens in the app, and Slack needs the whole
+    // address: it is joined to the public URL, and that address is then the one that is live. With no public URL there is nothing to link to.
+    const base = config.publicUrl?.replace(/\/$/, '');
+    const text = md.replace(/\[([^\]\n]+)\]\((#\/[^)\s]*)\)/g, (m, label, page) => {
+        if (!trust.has(page))
+            return m;
+        if (!base)
+            return label.trim();
+        const whole = `${base}/${page}`;
+        trust.add(whole);
+        return `[${label}](${whole})`;
+    });
+    return toMrkdwn(text, { trusted: (u) => trust.has(u) });
+}
+function clip(text) {
+    if (text.length <= MAX_TEXT)
+        return text;
+    let cut = text.slice(0, MAX_TEXT);
+    // The cut never lands inside a code span or a link, where a piece of an address could be left outside of its span (KAT-380).
+    if ((cut.match(/`/g)?.length ?? 0) % 2)
+        cut = cut.slice(0, cut.lastIndexOf('`'));
+    const open = cut.lastIndexOf('<');
+    if (open > cut.lastIndexOf('>'))
+        cut = cut.slice(0, open);
+    return `${cut}\n[truncated]`;
+}
+function stripMentions(text) {
+    return text
+        .replace(/<@[A-Z0-9]+(\|[^>]*)?>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Picks the dot for a mention: one named in the text (longest name wins), else the thread's dot, else the channel's dot. */
+export function pickDot(text, channel, threadTs) {
+    const dots = list('watches').filter((w) => !w.archived);
+    const clean = stripMentions(text).toLowerCase();
+    const named = dots
+        .filter((w) => w.name && new RegExp(`(^|[^a-z0-9])@?${escapeRe(w.name.toLowerCase())}($|[^a-z0-9])`).test(clean))
+        .sort((a, b) => b.name.length - a.name.length)[0];
+    if (named)
+        return named;
+    const remembered = threadTs ? threadDots.get(threadTs) : undefined;
+    if (remembered) {
+        const w = dots.find((d) => d.id === remembered);
+        if (w)
+            return w;
+    }
+    const norm = (c) => c.replace(/^#/, '').toLowerCase();
+    // Several dots can share a channel. An unnamed message reaches the lead among them (KAT-405), else the first in table order; a message that
+    // names a member went to that member above.
+    const sharing = dots.filter((w) => w.slackChannel && norm(w.slackChannel) === norm(channel));
+    return sharing.find((w) => w.kind === 'lead') ?? sharing[0];
+}
+/**
+ * Channels where someone mentioned the bot. Slack lists private channels only with the groups:read scope,
+ * which older installs lack, so the channel picker also offers these. Saved once per new channel.
+ */
+export function rememberChannel(id, name) {
+    if (!id)
+        return;
+    const seen = getMeta('slack').seenChannels ?? [];
+    const known = seen.find((c) => c.id === id);
+    if (known && (known.name || !name))
+        return;
+    const next = [...seen.filter((c) => c.id !== id), { id, ...(name ? { name } : {}) }].slice(-100);
+    setMeta('slack', { seenChannels: next });
+}
+/** Handles one app_mention. Returns what happened, for logs and tests. */
+export async function handleMention(event, teamId, deps) {
+    if (event.bot_id)
+        return 'ignored';
+    const team = teamId ?? event.team ?? event.user_team;
+    const thread = event.thread_ts ?? event.ts;
+    if (!slackAllowed(team, event.user)) {
+        log.warn(`slack: mention from ${event.user ?? 'unknown'} in team ${team ?? 'unknown'} is not on the allowlist`);
+        return 'denied';
+    }
+    rememberChannel(event.channel, deps.channelName ? await deps.channelName(event.channel).catch(() => undefined) : undefined);
+    const text = stripMentions(event.text);
+    const dot = pickDot(event.text, event.channel, event.thread_ts);
+    if (dot) {
+        threadDots.set(thread, dot.id);
+        if (threadDots.size > 1000)
+            threadDots.delete(threadDots.keys().next().value);
+    }
+    // The addresses server code builds for this answer. Nothing else the answer carries is a live link (KAT-380).
+    const trust = new LinkTrust();
+    const answer = deps.answer ??
+        ((input) => answerChat({ ...input, channel: 'slack' }, () => { }, () => { }));
+    try {
+        // Work the turn queues (a rerun, a review) reports back in this thread (KAT-143).
+        const origin = {
+            channel: 'slack',
+            slackChannel: event.channel,
+            threadTs: thread,
+            ...(event.user ? { user: event.user } : {}),
+            text: text.slice(0, 200),
+        };
+        let work;
+        const onWork = (w) => {
+            work = w;
+        };
+        const reply = text
+            ? await answer(dot ? { dotId: dot.id, text, origin, onWork, trust } : { text, origin, onWork, trust })
+            : 'Ask me something, for example "is prod up?" or "what broke today?"';
+        const prefix = dot ? `*${dot.name}*: ` : '';
+        // Titled links for every PR, ticket, and run the answer names (KAT-225); a no-op for text answerChat already titled.
+        const titled = await renderRefs(reply, { ...(dot ? { dotId: dot.id } : {}), format: 'markdown', absolute: true, trust });
+        await deps.post({
+            channel: event.channel,
+            thread_ts: thread,
+            text: clip(prefix + answerMrkdwn(titled, trust)) + workedLine(work, dot?.id),
+            unfurl_links: false,
+        });
+        return 'answered';
+    }
+    catch (err) {
+        log.error('slack: answer failed', err);
+        try {
+            await deps.post({
+                channel: event.channel,
+                thread_ts: thread,
+                text: clip(answerMrkdwn('Sorry, I could not answer that. The error is in the localdost server log.', trust)),
+            });
+        }
+        catch {
+            /* nothing more to do */
+        }
+        return 'failed';
+    }
+}
+/** Starts the Socket Mode app when both tokens are set. Returns false when Slack is not configured. */
+export async function startSlack() {
+    // Sandbox mode (KAT-286): no Socket Mode connection, so nothing is read from or posted to Slack.
+    if (sandboxOn()) {
+        sandboxSkips('Slack');
+        status = { state: 'off' };
+        return false;
+    }
+    wanted = true;
+    if (!slackConfigured()) {
+        status = { state: 'off' };
+        return false;
+    }
+    if (app)
+        return true;
+    status = { state: 'connecting', startedAt: new Date().toISOString() };
+    try {
+        const { App, LogLevel } = await import('@slack/bolt');
+        const bolt = new App({
+            token: liveEnv.SLACK_BOT_TOKEN,
+            appToken: liveEnv.SLACK_APP_TOKEN,
+            socketMode: true,
+            logLevel: LogLevel.WARN,
+        });
+        bolt.event('app_mention', async ({ event, body, client: web }) => {
+            const teamId = body.team_id;
+            await handleMention(event, teamId, {
+                post: (args) => web.chat.postMessage(args),
+                channelName: async (id) => (await web.conversations.info({ channel: id })).channel?.name,
+            });
+        });
+        // Approve and Reject on a dot's decision message (KAT-143). Interactivity rides the same socket.
+        bolt.action(/^localdost_(approve|reject)$/, async ({ ack, body, action, respond }) => {
+            await ack();
+            const a = action;
+            const b = body;
+            const text = await handleSlackDecision({
+                approvalId: a.value ?? '',
+                decision: a.action_id === 'localdost_approve' ? 'approve' : 'reject',
+                user: b.user?.id,
+                userName: b.user?.username ?? b.user?.name,
+                team: b.team?.id ?? b.user?.team_id,
+            });
+            await respond({ replace_original: false, response_type: 'in_channel', text }).catch((err) => log.warn(`slack: reply to a button press failed: ${String(err)}`));
+        });
+        // Preview opens the Inbox in the browser; Slack still sends the press, which needs an answer.
+        bolt.action('localdost_preview', async ({ ack }) => {
+            await ack();
+        });
+        bolt.error(async (err) => {
+            log.error('slack: bolt error', err);
+        });
+        await bolt.start();
+        client = bolt.client;
+        app = bolt;
+        try {
+            const who = (await bolt.client.auth.test());
+            status = { ...status, state: 'connected', botUserId: who.user_id, team: who.team };
+        }
+        catch {
+            status = { ...status, state: 'connected' };
+        }
+        if (!csv(liveEnv.SLACK_ALLOWED_TEAM).length && !csv(liveEnv.SLACK_ALLOWED_USERS).length)
+            log.warnOnce('slack-allowlist', 'Slack has no SLACK_ALLOWED_TEAM or SLACK_ALLOWED_USERS; anyone in the installed workspace can ask the dots.');
+        await tipAdminOnFirstConnect();
+        log.info(`Slack connected over Socket Mode${status.team ? ` (${status.team})` : ''}`);
+        return true;
+    }
+    catch (err) {
+        status = { state: 'error', error: err instanceof Error ? err.message : String(err) };
+        log.error('slack: start failed', err);
+        return false;
+    }
+}
+export async function stopSlack() {
+    wanted = false;
+    const a = app;
+    app = undefined;
+    client = undefined;
+    status = { state: 'off' };
+    if (a)
+        await a.stop().catch(() => undefined);
+}
+/** Test seam: use a fake Web API client, or undefined to fall back to the outbox. */
+export function setSlackClient(c) {
+    client = c;
+}
+function channelOf(action) {
+    const meta = action.meta ?? {};
+    const ch = typeof meta.channel === 'string' && meta.channel ? meta.channel : action.target.replace(/^slack:/, '');
+    if (!ch)
+        throw new Error('slack_post needs a channel (meta.channel or target slack:<channel>)');
+    return ch.replace(/^#/, '');
+}
+/**
+ * Executor for ActionKind 'slack_post'. Posts through the Slack client, or writes an outbox row when Slack is not
+ * connected (demo mode), matching how the other integrations behave without credentials.
+ */
+export async function executeSlackPost(action, watch, runId) {
+    if (action.kind !== 'slack_post')
+        throw new Error(`executeSlackPost got ${action.kind}`);
+    const channel = channelOf(action);
+    const dotId = watch?.id ?? (typeof action.meta?.watchId === 'string' ? action.meta.watchId : undefined);
+    const refOpts = { ...(dotId ? { dotId } : {}), absolute: true };
+    // A reviewed or approved draft goes out as written. Titling a reference reads text from the tracker that nobody
+    // reviewed (KAT-256), so only a templated notice built from fixed strings gets titles.
+    const titled = action.meta?.templated === true;
+    const [title, body] = titled
+        ? await Promise.all([renderRefs(action.title, { ...refOpts, format: 'text' }), renderRefs(action.body, { ...refOpts, format: 'markdown' })])
+        : [action.title, action.body];
+    const text = clip(`*${escapeMrkdwn(title)}*\n${toMrkdwn(body)}`);
+    if (client) {
+        const threadTs = typeof action.meta?.threadTs === 'string' ? action.meta.threadTs : undefined;
+        await client.chat.postMessage({ channel, text, ...(threadTs ? { thread_ts: threadTs } : {}), unfurl_links: false });
+        return;
+    }
+    const watchId = watch?.id ?? (typeof action.meta?.watchId === 'string' ? action.meta.watchId : 'slack');
+    const rid = runId ?? (typeof action.meta?.runId === 'string' ? action.meta.runId : undefined);
+    const item = insert('outbox', rid ? { watchId, runId: rid, action } : { watchId, action });
+    publish({ type: 'outbox', item });
+}
+/** "Checked 4 things in 16 s" with the link to the dot's chat (KAT-374); empty when the turn reported nothing. */
+function workedLine(work, dotId) {
+    if (!work)
+        return '';
+    const link = slackLink(dotId ? `/#/chat/${dotId}` : '/#/chat', 'Open in localdost', config.publicUrl);
+    return `\n_${workLine(work)}_${link ? ` · ${link}` : ''}`;
+}
+/** The app link under a notice as Markdown, which toMrkdwn turns into a Slack link. */
+function noticeLink(url) {
+    const abs = appUrl(url, config.publicUrl);
+    return abs ? `\n[Open in localdost](${abs})` : '';
+}
+/**
+ * Posts an outage or digest notice to the dot's slackChannel. With a runId it goes through gate() and is recorded
+ * on the run. Without one there is no run to hold an approval, so it posts only when gate() would act: the
+ * effective level is 'act' (a templated notice under rule act) and auto-review passes; anything else is blocked
+ * (KAT-54). `opts.templated` marks a notice built from fixed strings plus probe fields. Deduped per notice key for
+ * 10 minutes, like push.
+ */
+export async function postNotice(watch, notice, runId, opts = {}) {
+    if (!watch.slackChannel)
+        return 'skipped';
+    // The update router posts outages and digests itself, once, to the dot's channel or DM (KAT-143).
+    if (updatesOwnDelivery())
+        return 'skipped';
+    const now = Date.now();
+    const last = noticeSent.get(notice.key);
+    if (last && now - last < NOTICE_DEDUPE_MS)
+        return 'skipped';
+    noticeSent.set(notice.key, now);
+    for (const [k, t] of noticeSent)
+        if (now - t > NOTICE_DEDUPE_MS)
+            noticeSent.delete(k);
+    const channel = watch.slackChannel.replace(/^#/, '');
+    const action = {
+        kind: 'slack_post',
+        target: `slack:${channel}`,
+        title: notice.title,
+        // A templated notice is built by the server; any other body carries model or tracker text, so no link in it stays live.
+        body: `${opts.templated ? notice.body : mdText(notice.body)}${noticeLink(notice.url)}`,
+        meta: {
+            channel,
+            watchId: watch.id,
+            key: notice.key,
+            urgency: notice.urgency,
+            ...(runId ? { runId } : {}),
+            ...(opts.templated ? { templated: true } : {}),
+        },
+    };
+    if (runId)
+        return gate(action, watch, runId);
+    if (effectiveLevel(watch, action) !== 'act') {
+        log.info(`slack: notice "${notice.key}" not posted: no run to hold an approval, and only templated notices post on their own`);
+        return 'blocked';
+    }
+    const safe = { ...action, title: redactCode(action.title), body: redactCode(action.body) };
+    const review = await safeReview(safe, watch);
+    if (!review.ok || review.escalate) {
+        log.warn(`slack: notice "${notice.key}" not posted: ${review.reason}`);
+        return 'blocked';
+    }
+    try {
+        await executeSlackPost(safe, watch);
+        return 'executed';
+    }
+    catch (err) {
+        log.warn('slack: notice post failed', err);
+        return 'blocked';
+    }
+}
+/** Relative app links (`/#/runs/id`) point at the public URL, or lose the link when there is none. */
+export function absoluteLinks(md) {
+    const base = config.publicUrl?.replace(/\/$/, '');
+    return md.replace(/\[([^\]]+)\]\((\/[^)\s]*)\)/g, (_m, label, path) => (base ? `[${label}](${base}${path})` : label));
+}
+/** The Block Kit message for a decision: the text, then Preview, the button that posts, and the one that drops it. */
+export function updateBlocks(text, approvalId, buttons = { post: 'Post', cancel: "Don't post" }) {
+    if (!approvalId)
+        return undefined;
+    return [
+        { type: 'section', text: { type: 'mrkdwn', text: text.slice(0, 2900) } },
+        {
+            type: 'actions',
+            elements: [
+                ...(buttons.previewUrl
+                    ? [{ type: 'button', text: { type: 'plain_text', text: 'Preview' }, action_id: 'localdost_preview', url: buttons.previewUrl }]
+                    : []),
+                { type: 'button', text: { type: 'plain_text', text: buttons.post.slice(0, 75) }, style: 'primary', action_id: 'localdost_approve', value: approvalId },
+                { type: 'button', text: { type: 'plain_text', text: buttons.cancel.slice(0, 75) }, action_id: 'localdost_reject', value: approvalId },
+            ],
+        },
+    ];
+}
+// A Slack app made before interactivity was in the manifest shows the buttons but Slack refuses the click (KAT-280).
+// A refused click never reaches the server, and the Slack API offers no read of the app's Interactivity switch, so
+// no failure can trigger the tip. The admin gets it once, when the Slack connection is first made, and Setup shows it.
+export const INTERACTIVITY_TIP = 'Turn on Interactivity in the localdost Slack app (docs/SLACK.md) so the Approve and Reject buttons work. Until then, people can decide in the localdost Inbox.';
+/** The admin: the first user on SLACK_ALLOWED_USERS. A delivery user is not the admin. */
+function slackAdmin() {
+    return csv(liveEnv.SLACK_ALLOWED_USERS)[0];
+}
+/** Sends the admin the Interactivity tip the first time Slack connects. Returns whether it sent one. */
+export async function tipAdminOnFirstConnect(c = client) {
+    if (!c || getMeta('slack').interactivityTipSent)
+        return false;
+    const admin = slackAdmin();
+    if (!admin)
+        return false;
+    setMeta('slack', { interactivityTipSent: true });
+    await c.chat
+        .postMessage({ channel: admin, text: INTERACTIVITY_TIP, unfurl_links: false })
+        .catch((err) => log.warn(`slack: tip for the admin failed: ${String(err)}`));
+    return true;
+}
+/**
+ * Posts one dot update. It is a templated slack_post: it goes out under rule act (or act_when_asked when a
+ * person asked) once auto-review passes, like postNotice without a run. Without a Slack connection it lands
+ * in the outbox, as the other integrations do in demo mode.
+ */
+export async function postUpdate(watch, p) {
+    const channel = p.channel.replace(/^#/, '');
+    if (!channel)
+        return { ok: false, reason: 'no Slack channel' };
+    if (sandboxOn()) {
+        logRefused('slack_post', `slack:${channel}`);
+        return { ok: false, reason: `sandbox: refused slack_post to slack:${channel}` };
+    }
+    const action = {
+        kind: 'slack_post',
+        target: `slack:${channel}`,
+        title: p.title,
+        body: p.body,
+        meta: {
+            channel,
+            watchId: watch.id,
+            key: p.key,
+            templated: true,
+            ...(p.threadTs ? { threadTs: p.threadTs } : {}),
+            ...(p.asked ? { askedBy: 'user' } : {}),
+            ...(p.runId ? { runId: p.runId } : {}),
+        },
+    };
+    const level = effectiveLevel(watch, action);
+    if (level !== 'act' && !(level === 'act_when_asked' && p.asked))
+        return { ok: false, reason: `rule for slack_post is ${level}` };
+    const safe = { ...action, title: redactCode(action.title), body: redactCode(action.body) };
+    const review = await safeReview(safe, watch);
+    if (!review.ok || review.escalate)
+        return { ok: false, reason: review.reason };
+    const refOpts = { dotId: watch.id, absolute: true };
+    const [title, body] = await Promise.all([renderRefs(safe.title, { ...refOpts, format: 'text' }), renderRefs(safe.body, { ...refOpts, format: 'markdown' })]);
+    // One absolute link under the message; a decision has its Preview button instead.
+    const link = p.approvalId ? '' : slackLink(p.url, p.linkLabel ?? 'Open details', config.publicUrl);
+    // The update text mixes links the server built with titles and errors from PRs, tickets and tests. A link stays live only when its address is one
+    // the server builds (an app page, a PR or ticket of a repo or tracker the dots hold), and the look-alike brackets go on here and nowhere else (KAT-380).
+    const watches = list('watches');
+    const how = { trusted: (u) => serverUrlTrusted(u, watches), lookAlike: true };
+    const text = `${clip(`*${toMrkdwn(title, how)}*\n${toMrkdwn(absoluteLinks(body), how)}`)}${link ? `\n${link}` : ''}`;
+    if (client) {
+        const blocks = updateBlocks(text, p.approvalId, decisionButtons(watch, p));
+        const res = (await client.chat.postMessage({
+            channel,
+            text,
+            ...(p.threadTs ? { thread_ts: p.threadTs } : {}),
+            ...(blocks ? { blocks } : {}),
+            unfurl_links: false,
+        }));
+        return { ok: true, channel: res?.channel ?? channel, ...(res?.ts ? { ts: res.ts } : {}) };
+    }
+    const item = insert('outbox', p.runId ? { watchId: watch.id, runId: p.runId, action: safe } : { watchId: watch.id, action: safe });
+    publish({ type: 'outbox', item });
+    // Kept in the outbox, not sent: an update must not count Slack as delivered when no Slack is connected.
+    return { ok: false, reason: 'Slack is not connected; the update is in the outbox' };
+}
+function decisionButtons(watch, p) {
+    const a = p.approvalId ? get('approvals', p.approvalId) : undefined;
+    if (!a)
+        return undefined;
+    const run = a.runId ? get('runs', a.runId) : undefined;
+    const d = decisionText(a, run, watch.name);
+    const previewUrl = appUrl(p.url ?? '/#/inbox', config.publicUrl);
+    return { post: d.post, cancel: d.cancel, ...(previewUrl ? { previewUrl } : {}) };
+}
+/** `Slack anh.chu` when Slack sent a name, else `Slack U07ABC123`: the id stays as the fallback and never needs the users:read scope. */
+export function slackApprover(d) {
+    const name = (d.userName ?? '')
+        .replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2066-\u2069<>@]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 40);
+    return `Slack ${name || d.user}`;
+}
+/** Approve or Reject pressed in Slack. Same allowlist as mentions. Returns the reply text in plain words. */
+export async function handleSlackDecision(d, deps = {}) {
+    if (!slackAllowed(d.team, d.user))
+        return 'You are not on the allowlist for this localdost server.';
+    const a = d.approvalId ? get('approvals', d.approvalId) : undefined;
+    if (!a)
+        return 'That draft is gone.';
+    // Approving sends something outside localdost, so it needs a named person: a user on SLACK_ALLOWED_USERS, or
+    // the dot's own Slack user. An empty allowlist lets anyone mention the dot, but not approve its drafts.
+    const owner = a.watchId ? get('watches', a.watchId)?.updates?.slackUser : undefined;
+    const approvers = csv(liveEnv.SLACK_ALLOWED_USERS);
+    if (!d.user || !(approvers.includes(d.user) || (owner && owner === d.user)))
+        return 'Only the dot owner or a user on SLACK_ALLOWED_USERS can approve or reject from Slack. Use the localdost Inbox instead.';
+    if (a.status !== 'pending')
+        return `Already ${a.status}.`;
+    if (a.expiresAt && Date.parse(a.expiresAt) <= Date.now())
+        return 'That draft expired.';
+    const who = d.user ? `<@${d.user}>` : 'Someone';
+    try {
+        // The record keeps who pressed the button (KAT-356).
+        const by = { by: slackApprover(d) };
+        if (d.decision === 'approve')
+            await (deps.approve ?? approveAction)(a.id, undefined, by);
+        else
+            await (deps.reject ?? rejectAction)(a.id, undefined, by);
+    }
+    catch (err) {
+        log.warn(`slack: ${d.decision} of ${a.id} failed: ${String(err)}`);
+        return `Could not ${d.decision} it. The error is in the localdost server log.`;
+    }
+    return `${who} ${d.decision === 'approve' ? 'approved' : 'rejected'}: ${a.action.title}`;
+}
+/** Test helper: forget thread routing and notice dedupe. */
+export function resetSlackState() {
+    setMeta('slack', { interactivityTipSent: false });
+    threadDots.clear();
+    noticeSent.clear();
+}
+//# sourceMappingURL=index.js.map