allaboard 0.4.0 → 0.6.0

package/dist/chat/slack/delete-thread.js

@@ -0,0 +1,37 @@
+import { named } from "../../core/port.js";
+import * as slackTexts from "./texts.js";
+/** `!delete-thread`'s question as Slack blocks. */
+export const DELETE_THREAD_CONFIRM = "delete_thread_confirm";
+export const DELETE_THREAD_CANCEL = "delete_thread_cancel";
+/**
+ * The question under the owner's word: the Home tab's own title and warning in a `mrkdwn`
+ * section, then its two buttons. The click carries no `message` and is read by its container
+ * (`clickThread`), so the buttons hold no value. Delete is `danger`, as on the Home tab.
+ */
+export function deleteThreadBlocks(names) {
+    return [
+        {
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: `*${slackTexts.HOME_DELETE_TITLE}*\n${named(slackTexts.HOME_DELETE_TEXT, names)}`,
+            },
+        },
+        {
+            type: "actions",
+            elements: [
+                {
+                    type: "button",
+                    action_id: DELETE_THREAD_CONFIRM,
+                    style: "danger",
+                    text: { type: "plain_text", text: slackTexts.HOME_DELETE_CONFIRM },
+                },
+                {
+                    type: "button",
+                    action_id: DELETE_THREAD_CANCEL,
+                    text: { type: "plain_text", text: slackTexts.HOME_DELETE_DENY },
+                },
+            ],
+        },
+    ];
+}

package/dist/chat/slack/delete.js

@@ -85,8 +85,8 @@ export class ThreadDeleter {
     }
     /**
      * Delete every message of a thread that holds a session and forget the thread. Returns null
-     * once the thread is gone (or was not one of the daemon's), else the line that says why it is
-     * still there. Never throws.
+     * once the thread is gone (or was not one of the daemon's), else why it is still there. Never
+     * throws.
      */
     async delete(channelId, threadTs) {
         if (this.#state.thread(channelId, threadTs) === null) {
@@ -98,25 +98,31 @@ export class ThreadDeleter {
         if (this.#state.thread(channelId, threadTs) === null) {
             return null; // deleted while this call waited its turn
         }
+        // A refused release took no hold, and the hold on the thread is then another's (a deletion of
+        // its first message being forgotten): it is not this call's to free.
+        let notHeld = false;
         try {
             // From here until `free`, the thread is held: a message sent in it while its messages go
             // finds no session, and none is rebuilt from the entry `state.json` still has
             // (`SessionManager.release`).
-            if (!(await this.#release(channelId, threadTs)))
-                return slackTexts.HOME_DELETE_BUSY;
+            if (!(await this.#release(channelId, threadTs))) {
+                notHeld = true;
+                return { reason: "busy" };
+            }
             const refused = await this.#empty(channelId, threadTs);
             if (refused > 0) {
                 // The root stays while a reply does, so the thread can still be opened.
-                return fill(named(slackTexts.HOME_DELETE_REFUSED, this.#names()), { count: refused });
+                return { reason: "refused", count: refused };
             }
             this.#state.removeThread(channelId, threadTs);
         }
         catch (error) {
             logger.warning(`could not delete ${channelId}/${threadTs}: ${describe(error)}`);
-            return fill(slackTexts.HOME_DELETE_FAILED, { error: describe(error) });
+            return { reason: "failed", error: describe(error) };
         }
         finally {
-            this.#free(channelId, threadTs);
+            if (!notHeld)
+                this.#free(channelId, threadTs);
         }
         logger.info(`deleted thread ${channelId}/${threadTs}`);
         return null;

package/dist/chat/slack/home.js

@@ -46,9 +46,10 @@
  */
 import { createHash } from "node:crypto";
 import { systemClock } from "../../clock.js";
-import { Cancelled, Mutex, named, oneLine, Semaphore, TITLE_LIMIT, texts, } from "../../core/port.js";
+import { Cancelled, Mutex, named, oneLine, Semaphore, TAG_NAME, TITLE_LIMIT, texts, } from "../../core/port.js";
 import { getLogger } from "../../log.js";
 import { setupGuide } from "../../version.js";
+import { isTombstone } from "./channels.js";
 import { contextBlock, noticeText, plainTextObject } from "./reply/blocks.js";
 import { take } from "./reply/chars.js";
 import { describe, gone } from "./reply/errors.js";
@@ -56,6 +57,7 @@ import { mrkdwnEscape, shownAsWritten } from "./reply/escape.js";
 import { REACTIONS, Status } from "./reply/status.js";
 import { Task } from "./reply/tasks.js";
 import { ID_SHOWN } from "./resume.js";
+import { rootMarks } from "./tag.js";
 import * as slackTexts from "./texts.js";
 import { updateButton, withChangelog } from "./update.js";
 export const logger = getLogger("allaboard.chat.slack.home");
@@ -79,10 +81,13 @@ export const SEARCH_BLOCK = "home_search";
 export const CHANNEL_ACTION = "home_channel";
 export const STATUS_ACTION = "home_status";
 export const DATE_ACTION = "home_date";
+export const TAG_ACTION = "home_tag";
 export const SEARCH_ACTION = "home_search_text";
 export const SHOW_ALL_ACTION = "home_show_all";
 export const NEW_THREAD_ACTION = "home_new_thread";
 export const EDIT_ACTION = "home_edit";
+export const REFRESH_ACTION = "home_refresh";
+export const CONTROLS_BLOCK = "home_controls";
 export const DELETE_ACTION = "home_delete";
 export const CLEAN_ACTION = "home_clean";
 export const HOME_UPDATE_ACTION = "home_update";
@@ -91,9 +96,17 @@ export const NOTICES_SHOWN = 5;
 // What the Edit button carries: the mode a click asks for, so a click sent twice asks the same.
 export const EDIT_ON = "edit";
 export const EDIT_OFF = "done";
+// What the Refresh button carries: it has one meaning, so there is nothing to choose between.
+export const REFRESH_VALUE = "refresh";
 // A confirmation dialog's text holds 300 characters (confirmation dialog object reference).
 export const CONFIRM_TEXT = 300;
-export const FILTER_ACTIONS = [CHANNEL_ACTION, STATUS_ACTION, DATE_ACTION, SEARCH_ACTION];
+export const FILTER_ACTIONS = [
+    CHANNEL_ACTION,
+    STATUS_ACTION,
+    DATE_ACTION,
+    TAG_ACTION,
+    SEARCH_ACTION,
+];
 // A blank row between two sessions: a context line that holds a zero-width space, since Slack
 // sets the distance between blocks itself and takes no empty text.
 export const SPACER = "​";
@@ -162,23 +175,26 @@ export function threadFacts(root) {
     const names = reactions
         .filter((r) => typeof r === "object" && r !== null && !Array.isArray(r))
         .map((r) => String(r.name));
+    const { tag, pinned } = rootMarks(root);
     return {
         replies: root.reply_count ? pyInt(root.reply_count) : 0,
         latestReply: latest ? Math.trunc(pyFloat(latest)) : null,
         latestTs: latest ? String(latest) : null,
         reaction: names.find((name) => WORDS.has(name)) ?? null,
+        tag,
+        pinned,
     };
 }
 /** A `HomeFilter` with every field not given at its default. */
 export function homeFilter(fields = {}) {
-    return { channel: null, status: null, date: LAST_48, search: "", ...fields };
+    return { channel: null, status: null, date: LAST_48, tag: null, search: "", ...fields };
 }
 /**
- * Whether a channel, a status or a search is chosen: the page then shows every session that
- * matches. The period alone keeps the page's shape, each channel cut to its newest.
+ * Whether a channel, a status, a tag or a search is chosen: the page then shows every session
+ * that matches. The period alone keeps the page's shape, each channel cut to its newest.
  */
 export function narrowed(filter) {
-    return Boolean(filter.channel || filter.status || filter.search);
+    return Boolean(filter.channel || filter.status || filter.tag || filter.search);
 }
 /** The day of the machine's own calendar an instant falls on, as a day number. */
 function localDay(epochSeconds) {
@@ -197,15 +213,20 @@ function casefold(text) {
  * Whether `row` passes every chosen filter. The date is the thread's last reply: `today` and
  * `yesterday` are calendar days of the machine's own time zone, each instant read with the
  * offset in force at that instant (a day a clock change makes 23 or 25 hours long stays one day);
- * the others reach back from now.
+ * the others reach back from now. A pinned session passes the period whatever its last reply;
+ * the channel, the status, the tag and the search still apply to it.
  */
 export function matches(filter, row, now) {
     if (filter.channel && row.channelId !== filter.channel)
         return false;
     if (filter.status && row.status !== filter.status)
         return false;
+    if (filter.tag && row.tag !== filter.tag)
+        return false;
     if (filter.search && !casefold(row.title).includes(casefold(filter.search)))
         return false;
+    if (row.pinned)
+        return true;
     if (filter.date === TODAY || filter.date === YESTERDAY) {
         const days = localDay(now.getTime() / 1000) - localDay(row.lastActivity);
         return days === (filter.date === TODAY ? 0 : 1);
@@ -253,10 +274,13 @@ export function readFilter(values, current) {
         const typed = box.value;
         search = typeof typed === "string" ? oneLine(typed, SEARCH_LIMIT) : "";
     }
+    // A tag is any name `!tag` accepts; anything else Slack sends keeps the current one.
+    const tag = picked(TAG_ACTION, current.tag, null);
     return {
         channel: picked(CHANNEL_ACTION, current.channel, null),
         status: picked(STATUS_ACTION, current.status, WORDS),
         date: picked(DATE_ACTION, current.date, DATES),
+        tag: tag === null || TAG_NAME.test(tag) ? tag : current.tag,
         search,
     };
 }
@@ -280,12 +304,35 @@ function select(actionId, options, chosen) {
     const initial = byValue.get(chosen || ALL) ?? byValue.get(ALL);
     return { type: "static_select", action_id: actionId, options: built, initial_option: initial };
 }
-function controlsOf(channels, chosen) {
+/**
+ * The tags the Tag menu offers: those the rows carry, sorted and cut to what a menu holds beside
+ * "All tags", and the one chosen, which stays on the menu when no row carries it (a page built
+ * without an answer from Slack) or when the cut leaves it out.
+ */
+function tagsOf(rows, chosen) {
+    const found = new Set(rows.flatMap((row) => (row.tag === null ? [] : [row.tag])));
+    const listed = [...found].sort().slice(0, CHANNEL_OPTIONS);
+    // The chosen tag always stands on the menu: past the cut it takes the last place, so that the
+    // menu never reads "All tags" while a tag filters.
+    if (chosen && !listed.includes(chosen)) {
+        if (listed.length === CHANNEL_OPTIONS)
+            listed.pop();
+        listed.push(chosen);
+    }
+    return listed;
+}
+function controlsOf(channels, chosen, tags) {
     // Slack keeps what a control shows for as long as its block keeps its id, whatever
     // `initial_option` a later page carries (seen 2026-10-01: after a restart the menus still
     // showed the choices of the run before). An id that follows the choice makes the controls
     // show what the page was built with: a restart, Show all and a dropped channel included.
-    const choice = JSON.stringify([chosen.channel, chosen.status, chosen.date, chosen.search]);
+    const choice = JSON.stringify([
+        chosen.channel,
+        chosen.status,
+        chosen.date,
+        chosen.tag,
+        chosen.search,
+    ]);
     const mark = createHash("sha256").update(choice).digest("hex").slice(0, 8);
     const search = {
         type: "plain_text_input",
@@ -314,6 +361,15 @@ function controlsOf(channels, chosen) {
                     ...[...DATES].map(([key, text]) => [text, key]),
                     [slackTexts.HOME_ANY_TIME, ALL],
                 ], chosen.date),
+                // Offered only once a root carries a tag, or a tag is chosen.
+                ...(tags.length === 0
+                    ? []
+                    : [
+                        select(TAG_ACTION, [
+                            [slackTexts.HOME_ALL_TAGS, ALL],
+                            ...tags.map((tag) => [tag, tag]),
+                        ], chosen.tag),
+                    ]),
             ],
         },
         {
@@ -347,22 +403,40 @@ function cleaningLine(count, names) {
         : texts.fill(named(slackTexts.HOME_CLEANING_MANY, names), { count });
 }
 /**
- * The line above the sessions. It carries the Edit button when threads can be deleted: a context
- * block holds no button (context block reference), so the line is a section then.
+ * The line above the sessions. With a control to offer it is a section of full size and the
+ * buttons sit in a row under it (`controlsRow`); with none it stays a small context line.
  */
-function header(time, editing, canEdit) {
+function header(time, hasControls) {
     const text = texts.fill(slackTexts.HOME_HEADER, { time });
-    if (!canEdit)
-        return context(text);
-    const button = {
-        type: "button",
-        action_id: EDIT_ACTION,
-        text: plainTextObject(editing ? slackTexts.HOME_DONE : slackTexts.HOME_EDIT),
-        value: editing ? EDIT_OFF : EDIT_ON,
-    };
-    if (editing)
-        button.style = "primary";
-    return { type: "section", text: { type: "mrkdwn", text }, accessory: button };
+    return hasControls ? section(text) : context(text);
+}
+/**
+ * The buttons under the header, Edit first: Edit (Done while editing) when threads can be
+ * deleted, Refresh when the daemon can clean up on request. An actions block holds up to 25
+ * elements (actions block reference).
+ */
+function controlsRow(editing, canEdit, canRefresh) {
+    const elements = [];
+    if (canEdit) {
+        const edit = {
+            type: "button",
+            action_id: EDIT_ACTION,
+            text: plainTextObject(editing ? slackTexts.HOME_DONE : slackTexts.HOME_EDIT),
+            value: editing ? EDIT_OFF : EDIT_ON,
+        };
+        if (editing)
+            edit.style = "primary";
+        elements.push(edit);
+    }
+    if (canRefresh) {
+        elements.push({
+            type: "button",
+            action_id: REFRESH_ACTION,
+            text: plainTextObject(slackTexts.HOME_REFRESH),
+            value: REFRESH_VALUE,
+        });
+    }
+    return elements.length === 0 ? [] : [{ type: "actions", block_id: CONTROLS_BLOCK, elements }];
 }
 /**
  * The update line under the header, in the phase of the update: the offer with its link and an
@@ -437,6 +511,17 @@ function channelHeader(teamId, channelId, options) {
     }
     return head;
 }
+/** The page's line for a delete that left the thread, which the page goes on listing. */
+function deleteLine(refusal, names) {
+    switch (refusal.reason) {
+        case "busy":
+            return slackTexts.HOME_DELETE_BUSY;
+        case "refused":
+            return texts.fill(named(slackTexts.HOME_DELETE_REFUSED, names), { count: refusal.count });
+        case "failed":
+            return texts.fill(slackTexts.HOME_DELETE_FAILED, { error: refusal.error });
+    }
+}
 function repliesOf(row) {
     return row.replies === 1
         ? slackTexts.HOME_REPLY
@@ -477,7 +562,12 @@ function card(row, channelName, editing, names) {
         word = slackTexts.HOME_DELETING;
     else if (row.status)
         word = WORDS.get(row.status) ?? null;
+    // A tag satisfies `TAG_NAME`, so it holds no character that mrkdwn reads as markup.
+    const marks = [row.pinned ? ":pushpin:" : null, row.tag === null ? null : `\`[${row.tag}]\``]
+        .filter((mark) => mark !== null)
+        .join(" ");
     const details = [
+        marks,
         word,
         row.replies ? repliesOf(row) : null,
         texts.fill(when, { when: dateToken(row.lastActivity, "ago") }),
@@ -498,7 +588,8 @@ function card(row, channelName, editing, names) {
  * search chosen, every channel is a group, the ones with sessions first by their newest, each
  * showing its `PER_CHANNEL` newest and a button to see them all (which chooses that channel);
  * otherwise only what matches, with no such cut. Never past Slack's 100 blocks: the page says
- * when it stops short. With `canEdit` the header line carries Edit; in `editing` each session
+ * when it stops short. With `canEdit` the row under the header carries Edit, and with
+ * `canRefresh` Refresh beside it; in `editing` each session
  * that is not in use carries Delete and no channel carries New thread. `notices` are the lines
  * the deletes and clean-ups that did not end left, under the header; `deleting` is how many
  * threads are being deleted or wait for it, said in a line of full size under the header, since a
@@ -506,12 +597,13 @@ function card(row, channelName, editing, names) {
  */
 export function homeView(rows, channels, options, names) {
     const { teamId, chosen, now } = options;
-    const { canEdit = false, deleting = 0, canClean = false } = options;
+    const { canEdit = false, canRefresh = false, deleting = 0, canClean = false } = options;
     const cleaning = options.cleaning ?? new Set();
     const editing = (options.editing ?? false) && canEdit;
     const blocks = [
-        ...controlsOf(channels, chosen),
-        header(dateToken(Math.trunc(now.getTime() / 1000), "time"), editing, canEdit),
+        ...controlsOf(channels, chosen, tagsOf(rows, chosen.tag)),
+        header(dateToken(Math.trunc(now.getTime() / 1000), "time"), canEdit || canRefresh),
+        ...controlsRow(editing, canEdit, canRefresh),
         ...(options.update ? [updateLine(options.update)] : []),
         ...(deleting ? [section(deletingLine(deleting, names))] : []),
         ...(cleaning.size > 0 ? [section(cleaningLine(cleaning.size, names))] : []),
@@ -547,7 +639,15 @@ export function homeView(rows, channels, options, names) {
         if (row.deleting)
             going.set(row.channelId, (going.get(row.channelId) ?? 0) + 1);
     }
-    const wanted = new Map([...groups].map(([id, found]) => [id, narrowed(chosen) ? found : found.slice(0, PER_CHANNEL)]));
+    // Pinned sessions first, each kind newest first (the rows are): a channel with no filter but the
+    // period shows every pinned session and the newest `PER_CHANNEL` of the others.
+    const wanted = new Map();
+    for (const [id, found] of groups) {
+        const pinned = found.filter((row) => row.pinned);
+        const others = found.filter((row) => !row.pinned);
+        groups.set(id, [...pinned, ...others]);
+        wanted.set(id, [...pinned, ...(narrowed(chosen) ? others : others.slice(0, PER_CHANNEL))]);
+    }
     let shown = 0;
     for (const [channelId, found] of groups) {
         const cards = wanted.get(channelId) ?? [];
@@ -625,6 +725,7 @@ export class Home {
     deleteThread;
     cleanChannel;
     updateOf;
+    cleanupOf;
     debounce;
     clock;
     // Kept in memory like the filters: a restart starts out of edit mode.
@@ -651,6 +752,8 @@ export class Home {
     off = false;
     // Whether the page being built lacks something Slack gave no answer about.
     incomplete = false;
+    // Set by Refresh: the next publish asks again about every name and root it holds.
+    reread = false;
     current = homeFilter();
     // One publish at a time, each built inside the lock: the one that lands last was built last,
     // so a filter just chosen is never overwritten by an older page.
@@ -668,6 +771,9 @@ export class Home {
     // The threads a state write changed since their root was read: read again at the next
     // publish, which every turn causes at its start and at its end.
     stale = new Set();
+    // The channels whose name is asked again at the next publish, the old name standing until Slack
+    // answers (a Refresh).
+    renew = new Set();
     constructor(slack, options) {
         this.slack = slack;
         this.owner = options.ownerUserId;
@@ -678,6 +784,7 @@ export class Home {
         this.deleteThread = options.delete;
         this.cleanChannel = options.clean;
         this.updateOf = options.update;
+        this.cleanupOf = options.cleanup;
         this.debounce = options.debounce ?? DEBOUNCE_SECONDS;
         this.clock = options.clock ?? systemClock;
     }
@@ -752,14 +859,15 @@ export class Home {
         this.deleting.add(key);
         this.notices.delete(key);
         await this.publish();
-        let notice;
+        let refusal;
         try {
-            notice = await this.deleteThread(channelId, threadTs);
+            refusal = await this.deleteThread(channelId, threadTs);
         }
         finally {
             this.deleting.delete(key);
         }
-        if (notice) {
+        if (refusal !== null) {
+            const notice = deleteLine(refusal, this.textNames());
             const label = this.labels.get(key);
             this.say(key, label ? `“${label}”: ${notice}` : notice);
         }
@@ -799,6 +907,24 @@ export class Home {
         }
         await this.publish();
     }
+    /**
+     * The owner's Refresh: the daemon's cleanup runs now (the same pass as at start and every six
+     * hours, so a channel Slack no longer has is forgotten), then the page is written again from
+     * fresh lookups. A cleanup that fails is logged and the page is written anyway.
+     */
+    async refresh() {
+        const cleanup = this.cleanupOf?.();
+        if (cleanup === null || cleanup === undefined)
+            return;
+        try {
+            await cleanup.request();
+        }
+        catch (error) {
+            logger.warning(`could not clean up for Refresh: ${describe(error)}`);
+        }
+        this.reread = true;
+        await this.publish();
+    }
     /**
      * Publish what a pending request still owed, then stop: the page a stop leaves behind shows the
      * sessions as the stop left them. Gives up after `CLOSE_SECONDS`.
@@ -858,6 +984,16 @@ export class Home {
         }
     }
     async publishPage(signal) {
+        if (this.reread) {
+            // Marked, not forgotten: a read that gets no answer then falls back on what was read before
+            // (`root`, `channelsOf`), so a rate limit during a Refresh does not empty the page. A
+            // permalink depends on its message's `ts` alone and is asked again only when that changed.
+            this.reread = false;
+            for (const channelId of this.names.keys())
+                this.renew.add(channelId);
+            for (const key of this.facts.keys())
+                this.stale.add(key);
+        }
         const bound = this.state.channels();
         const channels = await this.channelsOf(bound, signal);
         if (bound.length > 0 && channels.size === 0 && this.incomplete) {
@@ -870,11 +1006,18 @@ export class Home {
         if (chosen && (!bound.includes(chosen) || this.names.get(chosen) === null)) {
             this.current = { ...this.current, channel: null };
         }
+        // A tag no root carries any more (an `!untag`) is no filter, unless a root Slack did not
+        // answer about may still carry it.
+        const tag = this.current.tag;
+        if (tag && !this.incomplete && !rows.some((row) => row.tag === tag)) {
+            this.current = { ...this.current, tag: null };
+        }
         const view = homeView(rows, channels, {
             teamId: this.team,
             chosen: this.current,
             now: new Date(this.clock.time() * 1000),
             canEdit: this.deleteThread !== undefined,
+            canRefresh: (this.cleanupOf?.() ?? null) !== null,
             editing: this.editing,
             notices: [...this.notices.values()],
             deleting: this.deleting.size,
@@ -894,12 +1037,15 @@ export class Home {
         const found = new Map();
         // A channel forgotten and bound again later is asked about again.
         for (const unbound of [...this.names.keys()]) {
-            if (!bound.includes(unbound))
+            if (!bound.includes(unbound)) {
                 this.names.delete(unbound);
+                this.renew.delete(unbound);
+            }
         }
         for (const channelId of bound) {
             signal?.throwIfAborted();
-            if (!this.names.has(channelId)) {
+            if (!this.names.has(channelId) || this.renew.has(channelId)) {
+                this.renew.delete(channelId);
                 try {
                     const info = await this.slack.conversations.info({ channel: channelId });
                     const name = info.channel?.name;
@@ -911,9 +1057,13 @@ export class Home {
                     logger.warning(`could not read channel ${channelId}: ${describe(error)}`);
                     if (!gone(error)) {
                         this.incomplete = true;
-                        continue;
+                        // The name read before stands; with none the channel is left out for now.
+                        if (!this.names.has(channelId))
+                            continue;
+                    }
+                    else {
+                        this.names.set(channelId, null);
                     }
-                    this.names.set(channelId, null);
                 }
             }
             const name = this.names.get(channelId);
@@ -958,6 +1108,8 @@ export class Home {
                 replies: facts.replies,
                 lastActivity: facts.latestReply || Math.trunc(pyFloat(threadTs)),
                 permalink: link,
+                tag: facts.tag,
+                pinned: facts.pinned,
                 deleting: this.deleting.has(keyOf(channelId, threadTs)),
             });
         });
@@ -1019,6 +1171,13 @@ export class Home {
             const root = messages.find((m) => isObject(m) && String(m.ts) === threadTs);
             if (!isObject(root))
                 throw new RootNotReturned();
+            // A root deleted while replies remain is returned as a tombstone: the thread is gone, as
+            // when Slack answers `thread_not_found` (`channels.isTombstone`).
+            if (isTombstone(root)) {
+                this.stale.delete(key);
+                this.facts.set(key, null);
+                return null;
+            }
             facts = threadFacts(root);
         }
         catch (error) {