wheems 0.0.1 → 0.0.3

package/dist/doctor/doctor.d.ts

@@ -2,7 +2,6 @@ export { trustedIn } from '../util/trust.js';
 import type { HealthCheck } from '../contracts/driver.js';
 import type { DriverRegistry } from '../contracts/registry.js';
 export { defaultHome } from '../home.js';
-export declare const NODE_MINIMUM_VERSION = "22.13.0";
 export interface DoctorOptions {
     /** The install folder. */
     home: string;
@@ -15,6 +14,8 @@ export interface DoctorOptions {
     platform?: NodeJS.Platform;
     /** Whether an engine trusts a folder: true, false, or null when it can't tell. */
     trust?: (engine: string, dir: string) => Promise<boolean | null>;
+    /** Why SQLite can't do full-text search, or null when it can. */
+    fullTextSearch?: () => Promise<string | null>;
     /** Whether the service is installed and answering. */
     service?: (home: string) => Promise<{
         installed: boolean;

package/dist/doctor/doctor.js

@@ -13,13 +13,14 @@ import { HERDR_MINIMUM_VERSION } from '../drivers/runtime/herdr/herdr-runtime.js
 import { KnowledgeSearch } from '../knowledge/search.js';
 import { listAboutYou } from '../review/review.js';
 import { listProposals } from '../skills/proposals.js';
-import { compareVersions, isAtLeast } from '../util/version.js';
+import { compareVersions } from '../util/version.js';
+import { NODE_SUPPORTED, nodeVersionProblem } from '../util/node-support.js';
+import { fullTextSearchProblem } from '../util/sqlite.js';
 export { defaultHome } from '../home.js';
-export const NODE_MINIMUM_VERSION = '22.13.0';
 /** Runs every health check: the system, the runtime, and the install's config. */
 export async function runDoctor(options) {
     const sections = [];
-    sections.push({ title: 'System', checks: systemChecks(options) });
+    sections.push({ title: 'System', checks: await systemChecks(options) });
     const installFile = join(options.home, 'install.yaml');
     const hasInstall = await exists(installFile);
     const install = hasInstall ? await loadInstall(options.home) : null;
@@ -164,7 +165,11 @@ async function channelChecks(install, options) {
         }
         try {
             const driver = options.registry.create('channel', settings.driver, { ...secret });
-            checks.push(...(await driver.check()).map((c) => ({ ...c, name: `${connection}: ${c.name}` })));
+            const health = await driver.check();
+            checks.push(...health.map((c) => ({ ...c, name: `${connection}: ${c.name}` })));
+            if (health.every((c) => c.status !== 'fail')) {
+                checks.push(...(await channelMembership(install, connection, driver)));
+            }
         }
         catch (error) {
             checks.push({
@@ -177,6 +182,46 @@ async function channelChecks(install, options) {
     }
     return checks;
 }
+/**
+ * For each workspace that chats in a channel on this connection: can the app see the channel,
+ * and is it a member? Slack lists public channels the app isn't in, and sends no messages from
+ * them, so a workspace can look bound and never hear anything.
+ */
+async function channelMembership(install, connection, driver) {
+    const checks = [];
+    for (const workspace of install.workspaces) {
+        const chat = workspace.config?.channels.chat;
+        if (!chat || chat.connection !== connection || !('channel' in chat))
+            continue;
+        const name = `${workspace.id} chat channel`;
+        const id = driver.resolveChannel ? await driver.resolveChannel(chat.channel) : chat.channel;
+        if (id === null) {
+            checks.push({
+                name,
+                status: 'fail',
+                message: `The app can't see ${chat.channel}`,
+                hint: 'Check the name in workspace.yaml, invite the app to the channel, then run wheems service restart.',
+            });
+            continue;
+        }
+        const member = driver.isMember ? await driver.isMember(id) : null;
+        checks.push(member === true
+            ? { name, status: 'pass', message: `The app is in ${chat.channel}` }
+            : member === false
+                ? {
+                    name,
+                    status: 'warn',
+                    message: `The app isn't in ${chat.channel}, so messages there never reach the chief of staff`,
+                    hint: `In ${chat.channel}, type /invite and choose the app.`,
+                }
+                : {
+                    name,
+                    status: 'skip',
+                    message: `Couldn't tell whether the app is in ${chat.channel}`,
+                });
+    }
+    return checks;
+}
 /** What waits for the person in `wheems review`. Never a failure: it's for their attention. */
 async function reviewCheck(options) {
     const state = paths(options.home, options.env).state;
@@ -313,29 +358,36 @@ async function probeService(home) {
     const answering = await request(paths(home).socket, { op: 'ping' }, 2000).then((answer) => answer.ok, () => false);
     return { installed: status.loaded, answering };
 }
-function systemChecks(options) {
+async function systemChecks(options) {
     const nodeVersion = options.nodeVersion ?? process.versions.node;
     const platform = options.platform ?? process.platform;
     const checks = [];
-    checks.push(isAtLeast(nodeVersion, NODE_MINIMUM_VERSION)
-        ? {
-            name: 'Node.js',
-            status: 'pass',
-            message: `${nodeVersion} meets the minimum ${NODE_MINIMUM_VERSION}`,
-        }
+    const problem = nodeVersionProblem(nodeVersion);
+    checks.push(problem === null
+        ? { name: 'Node.js', status: 'pass', message: `${nodeVersion} is supported` }
+        : { name: 'Node.js', status: 'fail', message: problem, hint: `Install ${NODE_SUPPORTED}.` });
+    const search = await (options.fullTextSearch ?? (() => fullTextSearchProblem()))();
+    checks.push(search === null
+        ? { name: 'SQLite search', status: 'pass', message: "Node's SQLite has full-text search" }
         : {
-            name: 'Node.js',
+            name: 'SQLite search',
             status: 'fail',
-            message: `${nodeVersion} is older than the minimum ${NODE_MINIMUM_VERSION}`,
-            hint: `Install Node.js ${NODE_MINIMUM_VERSION} or later.`,
-        });
-    checks.push(platform === 'darwin' || platform === 'linux'
-        ? { name: 'platform', status: 'pass', message: platform === 'darwin' ? 'macOS' : 'Linux' }
-        : {
-            name: 'platform',
-            status: 'warn',
-            message: `${platform} is not supported yet; Wheems runs on macOS and Linux`,
+            message: search,
+            hint: `Install ${NODE_SUPPORTED}.`,
         });
+    checks.push(platform === 'darwin'
+        ? { name: 'platform', status: 'pass', message: 'macOS' }
+        : platform === 'linux'
+            ? {
+                name: 'platform',
+                status: 'warn',
+                message: 'Linux: the commands work, but the service runs under launchd on macOS only; systemd comes with the always-on milestone',
+            }
+            : {
+                name: 'platform',
+                status: 'warn',
+                message: `${platform} is not supported yet; Wheems runs on macOS (and Linux, apart from the service)`,
+            });
     return checks;
 }
 /** Starts a tiny session, sends it a line, waits, reads it back and removes it. */

package/dist/drivers/channel/slack/connect.d.ts

@@ -11,3 +11,8 @@ export interface SlackConnectOptions {
  * its two tokens (checked with Slack), and say who may talk to agents.
  */
 export declare function slackConnectFlow(options?: SlackConnectOptions): ConnectFlow;
+/**
+ * What's wrong with a pasted token, said so the person can fix it, or undefined if it looks
+ * right. It names a token only by its standard prefix, never by any other part of it.
+ */
+export declare function tokenProblem(kind: 'bot' | 'app', value: string): string | undefined;

package/dist/drivers/channel/slack/connect.js

@@ -93,7 +93,8 @@ async function newTokens(ui, context, verify) {
         copied
             ? '2. Paste the manifest: it is on your clipboard.'
             : `2. Paste the manifest from ${manifestFile}`,
-        '3. Install the app to the workspace, then copy the Bot User OAuth Token (xoxb-…).',
+        '3. Install the app to the workspace. Under OAuth & Permissions, copy the',
+        '   Bot User OAuth Token (xoxb-…).',
         '4. Under Basic Information → App-Level Tokens, generate a token with the',
         '   connections:write scope (xapp-…).',
         '',
@@ -106,11 +107,11 @@ async function newTokens(ui, context, verify) {
     for (;;) {
         const botToken = await ui.secret({
             message: 'Bot User OAuth Token',
-            validate: (value) => value.trim().startsWith('xoxb-') ? undefined : 'The bot token starts with xoxb-',
+            validate: (value) => tokenProblem('bot', value),
         });
         const appToken = await ui.secret({
             message: 'App-Level Token',
-            validate: (value) => value.trim().startsWith('xapp-') ? undefined : 'The app-level token starts with xapp-',
+            validate: (value) => tokenProblem('app', value),
         });
         try {
             await ui.task('Checking the tokens with Slack', () => verify(botToken.trim(), appToken.trim()), (id) => `Connected as ${id.botUser} in ${id.team}`);
@@ -123,4 +124,53 @@ async function newTokens(ui, context, verify) {
         }
     }
 }
+/** What each token is called in Slack, where to find it, and how it starts. */
+const TOKENS = {
+    bot: {
+        name: 'bot token',
+        prefix: 'xoxb-',
+        where: 'Under OAuth & Permissions, copy the Bot User OAuth Token',
+    },
+    app: {
+        name: 'app-level token',
+        prefix: 'xapp-',
+        where: 'Under Basic Information → App-Level Tokens, copy the token',
+    },
+};
+/** Other Slack tokens people paste by mistake, by their standard prefix. */
+const OTHER_TOKENS = {
+    'xoxp-': 'a user token',
+    'xoxe-': 'a refresh token',
+    'xoxa-': 'a workspace token',
+};
+const CLEAR = 'Clear the field with Backspace, then paste it once.';
+/**
+ * What's wrong with a pasted token, said so the person can fix it, or undefined if it looks
+ * right. It names a token only by its standard prefix, never by any other part of it.
+ */
+export function tokenProblem(kind, value) {
+    const want = TOKENS[kind];
+    const other = TOKENS[kind === 'bot' ? 'app' : 'bot'];
+    const token = value.trim();
+    const fix = `${want.where} (${want.prefix}…).`;
+    if (token === '')
+        return `Paste the ${want.name}. ${fix}`;
+    if (token.split(want.prefix).length > 2) {
+        return `That looks like more than one paste. ${CLEAR}`;
+    }
+    if (token.startsWith(want.prefix)) {
+        return /\s/.test(token) ? `There's a space or line break in it. ${CLEAR}` : undefined;
+    }
+    if (token.includes(want.prefix)) {
+        return `There's something before the ${want.prefix} at the start. ${CLEAR}`;
+    }
+    if (token.startsWith(other.prefix)) {
+        return `That starts with ${other.prefix}, so it's the ${other.name}. ${fix}`;
+    }
+    const known = Object.entries(OTHER_TOKENS).find(([prefix]) => token.startsWith(prefix));
+    if (known !== undefined) {
+        return `That starts with ${known[0]}, so it's ${known[1]}, not the ${want.name}. ${fix}`;
+    }
+    return `That isn't the ${want.name}: it starts with ${want.prefix}. ${fix}`;
+}
 //# sourceMappingURL=connect.js.map

package/dist/drivers/channel/slack/slack-channel.d.ts

@@ -24,6 +24,7 @@ export declare class SlackChannel implements ChannelDriver {
      * Returns null when the bot cannot see a channel by that name.
      */
     resolveChannel(nameOrId: string): Promise<string | null>;
+    isMember(channelId: string): Promise<boolean | null>;
     stop(): Promise<void>;
     private onEvent;
     private toDriverError;

package/dist/drivers/channel/slack/slack-channel.js

@@ -139,6 +139,16 @@ export class SlackChannel {
         } while (cursor !== undefined && !this.channelIds.has(name));
         return this.channelIds.get(name) ?? null;
     }
+    async isMember(channelId) {
+        try {
+            const info = await this.transport.call('conversations.info', { channel: channelId });
+            const member = info.channel?.is_member;
+            return typeof member === 'boolean' ? member : null;
+        }
+        catch {
+            return null;
+        }
+    }
     async stop() {
         this.handler = undefined;
         if (!this.started)
@@ -150,8 +160,9 @@ export class SlackChannel {
         const handler = this.handler;
         if (!handler || event.type !== 'message')
             return;
-        // Edits, deletions, joins and bot posts arrive as subtypes; only plain messages count.
-        if (typeof event.subtype === 'string')
+        // Edits, deletions, joins and bot posts arrive as subtypes; only plain messages, and
+        // messages with files attached, count.
+        if (typeof event.subtype === 'string' && event.subtype !== 'file_share')
             return;
         if (typeof event.bot_id === 'string' || event.user === this.botUserId)
             return;
@@ -170,6 +181,8 @@ export class SlackChannel {
             text: typeof event.text === 'string' ? event.text : '',
             direct: event.channel_type === 'im',
             receivedAt: new Date(Number.parseFloat(event.ts) * 1000),
+            ...(Array.isArray(event.files) &&
+                event.files.length > 0 && { files: fileNames(event.files) }),
         });
     }
     toDriverError(error, what) {
@@ -209,4 +222,12 @@ function chunks(text, size) {
         parts.push(rest);
     return parts;
 }
+/** The names of the files on a Slack message. */
+function fileNames(files) {
+    return files.map((file) => {
+        const f = (file ?? {});
+        const name = typeof f.name === 'string' ? f.name : typeof f.title === 'string' ? f.title : 'a file';
+        return { name };
+    });
+}
 //# sourceMappingURL=slack-channel.js.map

package/dist/drivers/engine/claude-code.d.ts

@@ -28,6 +28,8 @@ export declare class ClaudeCodeEngine implements EngineDriver {
     }, after: string | null): Promise<FinalMessage[]>;
     private transcript;
     check(): Promise<HealthCheck[]>;
+    /** Whether Claude Code is signed in, from `claude auth status`. Never shows the account. */
+    private signInCheck;
     prepare(agent: AgentDefinition, context: EngineContext): Promise<LaunchPlan>;
 }
 /**

package/dist/drivers/engine/claude-code.js

@@ -82,7 +82,49 @@ export class ClaudeCodeEngine {
             ];
         }
         const version = extractVersion(result.stdout) ?? result.stdout.trim();
-        return [{ name: 'Claude Code', status: 'pass', message: `claude ${version}` }];
+        return [
+            { name: 'Claude Code', status: 'pass', message: `claude ${version}` },
+            await this.signInCheck(),
+        ];
+    }
+    /** Whether Claude Code is signed in, from `claude auth status`. Never shows the account. */
+    async signInCheck() {
+        const status = await runCommand(this.binary, ['auth', 'status', '--json'], {
+            timeoutMs: 15_000,
+        });
+        let loggedIn = null;
+        let method = null;
+        try {
+            const parsed = JSON.parse(status.stdout);
+            if (typeof parsed.loggedIn === 'boolean')
+                loggedIn = parsed.loggedIn;
+            if (typeof parsed.authMethod === 'string')
+                method = parsed.authMethod;
+        }
+        catch {
+            // An older Claude Code without `auth status`, or output it doesn't recognise.
+        }
+        if (loggedIn === true) {
+            return {
+                name: 'Claude Code sign-in',
+                status: 'pass',
+                message: method !== null ? `Signed in (${method})` : 'Signed in',
+            };
+        }
+        if (loggedIn === false) {
+            return {
+                name: 'Claude Code sign-in',
+                status: 'fail',
+                message: 'Claude Code is not signed in, so agents on it cannot answer',
+                hint: 'Run claude auth login, or wheems setup and choose Engines.',
+            };
+        }
+        return {
+            name: 'Claude Code sign-in',
+            status: 'warn',
+            message: "Couldn't tell whether Claude Code is signed in (claude auth status didn't say)",
+            hint: 'Update Claude Code, or check by running claude yourself.',
+        };
     }
     prepare(agent, context) {
         const { session } = context;

package/dist/drivers/runtime/herdr/hc.js

@@ -205,7 +205,7 @@ export class Hc {
 }
 function toHcError(error, stderr, binary) {
     if (error.code === 'ENOENT') {
-        return new HcError('missing', `Herdr core's hc command was not found (${binary})`, 'Install Herdr core, or make sure hc is on PATH.', null, { cause: error });
+        return new HcError('missing', `Herdr core's hc command was not found (${binary})`, 'Install Herdr core (https://herdr.dev/core/), or make sure hc is on PATH.', null, { cause: error });
     }
     const exitCode = typeof error.code === 'number' ? error.code : null;
     if (error.killed === true) {

package/dist/drivers/runtime/herdr/herdr-runtime.js

@@ -33,7 +33,7 @@ export class HerdrRuntime {
                 name: 'hc installed',
                 status: 'fail',
                 message: describe(error),
-                hint: 'Install Herdr core and make sure hc is on PATH.',
+                hint: 'Install Herdr core (https://herdr.dev/core/) and make sure hc is on PATH.',
             });
             return checks;
         }

package/dist/drivers/vector-store/sqlite.js

@@ -2,6 +2,7 @@ import { mkdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { DriverError } from '../../contracts/driver.js';
 import { COLLECTION_NAME, } from '../../contracts/vector-store.js';
+import { NODE_SUPPORTED } from '../../util/node-support.js';
 import { openDatabase, sqlite } from '../../util/sqlite.js';
 /**
  * Vectors in SQLite files, one per collection, compared in code. Every search reads every
@@ -37,7 +38,7 @@ export class SqliteVectorStore {
                     name: 'vector store',
                     status: 'fail',
                     message: `Node's SQLite isn't available: ${error instanceof Error ? error.message : String(error)}`,
-                    hint: 'Use Node.js 22.13 or later.',
+                    hint: `Use ${NODE_SUPPORTED}.`,
                 },
             ];
         }

package/dist/knowledge/search.d.ts

@@ -73,6 +73,11 @@ export interface SearchIndexOptions {
     /** Where vectors go; needed only with embeddings. */
     vectors: VectorStoreDriver | null;
     log?: (message: string) => void;
+    /**
+     * Throws when SQLite can't do full-text search, which the index needs. Defaults to checking
+     * this Node's `node:sqlite`; tests pass their own.
+     */
+    requireFullTextSearch?: () => Promise<void>;
 }
 /** One workspace's search index. Writes run one at a time; searches can run alongside. */
 export declare class SearchIndex {

package/dist/knowledge/search.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { lstat, mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { basename, join, relative, sep } from 'node:path';
 import { parseDocument } from 'yaml';
-import { openDatabase } from '../util/sqlite.js';
+import { openDatabase, requireFullTextSearch } from '../util/sqlite.js';
 import { knowledgePaths, looksLikeSecret, noteTitle } from './notes.js';
 /**
  * Searching a workspace's knowledge base: its pages and notes, by keyword with SQLite's
@@ -328,6 +328,7 @@ export class SearchIndex {
         if (!(await exists(this.dbFile(current.generation)))) {
             throw new Error(`The ${this.workspace} workspace's search index is missing. The service rebuilds it, or run: wheems kb reindex`);
         }
+        await (this.options.requireFullTextSearch ?? requireFullTextSearch)();
         const db = await openDatabase(this.dbFile(current.generation));
         createSchema(db);
         const collection = current.embeddings !== null && this.options.vectors
@@ -351,6 +352,7 @@ export class SearchIndex {
         const vectors = embeddings !== null ? this.options.vectors : null;
         if (vectors)
             await vectors.drop(this.collectionName(generation));
+        await (this.options.requireFullTextSearch ?? requireFullTextSearch)();
         const db = await openDatabase(file);
         createSchema(db);
         const connection = {

package/dist/secrets.d.ts

@@ -1,7 +1,7 @@
 /**
  * Credentials, by name: `secrets.slack.bot_token`. They live in a private file on
  * this machine (mode 600), outside the install folder, and never pass through an
- * agent. The encrypted secret store comes in milestone 8.
+ * agent. The vault (the Keychain, or an encrypted file on servers) comes in milestone 9.
  */
 export type Secrets = Record<string, Record<string, string>>;
 export declare function readSecrets(file: string): Promise<Secrets>;

package/dist/service/conversations.js

@@ -58,7 +58,21 @@ export class ConversationManager {
         if (!binding)
             return Promise.resolve();
         const key = conversationKey(binding.workspace.id, connection, event.channel, replyThread(event));
-        return this.enqueue(key, () => this.deliver(key, binding, event).catch((error) => {
+        let message = event;
+        // Files can't reach the agent yet. Say so, rather than leave them unanswered.
+        if (event.files !== undefined && event.files.length > 0) {
+            const names = event.files.map((f) => f.name).join(', ');
+            if (event.text.trim() === '') {
+                return this.enqueue(key, () => this.notice(key, binding, replyThread(event), `I can't open files yet (${names}). Paste the text, or say in words what you need.`).catch((error) => {
+                    this.options.log(`Conversation ${key}: ${describe(error)}`);
+                }));
+            }
+            message = {
+                ...event,
+                text: `${event.text}\n\n(The person attached ${event.files.length === 1 ? 'a file' : `${String(event.files.length)} files`}: ${names}. Wheems can't pass files to you yet, so if you need what's in them, ask the person to paste it.)`,
+            };
+        }
+        return this.enqueue(key, () => this.deliver(key, binding, message).catch((error) => {
             this.options.log(`Conversation ${key}: ${describe(error)}`);
             return this.notice(key, binding, replyThread(event), `Something went wrong: ${describe(error)}`);
         }));
@@ -230,10 +244,12 @@ export class ConversationManager {
                     if (wait > 0)
                         await sleep(wait);
                 }
+                // Taken before sending: a quick agent can reply before the turn is being followed.
+                const sentAt = Date.now();
                 const sent = await this.options.runtime.send(session.id, event.text);
                 await this.options.store.touch(key, now);
                 await this.options.store.addPending(key);
-                this.watchTurn(key, binding, sessionName, sent.turn, seen, this.conversationFor(key, binding));
+                this.watchTurn(key, binding, sessionName, sent.turn, seen, this.conversationFor(key, binding), false, sentAt);
             }
             catch (error) {
                 if (!isDriverError(error, 'blocked'))
@@ -277,7 +293,8 @@ export class ConversationManager {
             pending: 1,
         });
         // A new session's turns count from 0; its first turn is the message it was started with.
-        this.watchTurn(key, binding, sessionName, 0, seen, this.conversationFor(key, binding));
+        // `now` was taken before the session started, so a reply to its first message counts.
+        this.watchTurn(key, binding, sessionName, 0, seen, this.conversationFor(key, binding), false, now.getTime());
         this.options.log(`Started ${started.id} (${sessionName}) for ${key}`);
         this.trimLater(binding.workspace.id, sessionName);
     }
@@ -379,7 +396,9 @@ export class ConversationManager {
         }
     }
     /** Follows the turn a message started, and tells the person if it ends badly or silently. */
-    watchTurn(key, binding, sessionName, fromTurn, seen, target, recovered = false) {
+    watchTurn(key, binding, sessionName, fromTurn, seen, target, recovered = false, 
+    /** When the message was handed to the agent; replies from then on count as its answer. */
+    sentAt = Date.now()) {
         const active = this.watches.get(key);
         if (active && active.sessionName === sessionName && !active.closed) {
             // A turn is already being followed. The agent takes this message during that turn or
@@ -391,7 +410,7 @@ export class ConversationManager {
         const watch = {
             sessionName,
             fromTurn,
-            sentAt: Date.now(),
+            sentAt,
             seen: seen ? [seen] : [],
             queued: [],
             closed: false,

package/dist/service/launchd.js

@@ -1,6 +1,6 @@
 /**
  * Runs the service under launchd on macOS, as a user agent that starts at login
- * and restarts if it stops. Linux (systemd) arrives with milestone 9.
+ * and restarts if it stops. Linux (systemd) arrives with the always-on milestone (10).
  */
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { homedir, userInfo } from 'node:os';
@@ -99,7 +99,7 @@ export function parseLaunchctlPrint(text) {
 }
 function ensureMac() {
     if (process.platform !== 'darwin') {
-        throw new Error('The service runs under launchd on macOS for now; systemd on Linux comes in milestone 9.');
+        throw new Error('The service runs under launchd on macOS for now; systemd on Linux comes with the always-on milestone (10).');
     }
 }
 function xml(value) {

package/dist/service/service.js

@@ -65,12 +65,17 @@ export async function runService(options) {
         const channel = channelFor(chat.connection);
         let channelId = null;
         if ('channel' in chat) {
-            const resolver = channel.resolveChannel;
-            channelId = resolver ? await resolver.call(channel, chat.channel) : chat.channel;
+            channelId = channel.resolveChannel
+                ? await channel.resolveChannel(chat.channel)
+                : chat.channel;
             if (channelId === null) {
-                log(`Workspace ${workspace.id}: the bot cannot see channel ${chat.channel}; invite it to the channel`);
+                log(`Workspace ${workspace.id}: the app can't see channel ${chat.channel}; check the name, invite the app to it, then run wheems service restart`);
                 continue;
             }
+            // Slack lists public channels the app isn't in, and sends no messages from them.
+            if ((await channel.isMember?.(channelId)) === false) {
+                log(`Workspace ${workspace.id}: the app isn't in channel ${chat.channel}, so messages there won't reach the chief of staff. Invite it: in that channel, /invite @ the app's name`);
+            }
         }
         bindings.push({ workspace, connection: chat.connection, channel: channelId });
         log(`Workspace ${workspace.id}: chat on ${chat.connection} ${channelId === null ? '(direct messages)' : channelId}`);

package/dist/testing/memory-channel.d.ts

@@ -29,6 +29,9 @@ export declare class MemoryChannel implements ChannelDriver {
         threadId?: string;
         userId?: string;
         direct?: boolean;
+        files?: {
+            name: string;
+        }[];
     }): Promise<string>;
     /** Delivers a press of a button on a message the driver sent. */
     press(press: {

package/dist/testing/memory-channel.js

@@ -77,6 +77,7 @@ export class MemoryChannel {
             text: message.text,
             direct: message.direct ?? false,
             receivedAt: new Date(),
+            ...(message.files !== undefined && { files: message.files }),
         });
         return messageId;
     }

package/dist/util/node-support.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Which Node.js versions Wheems runs on. Search needs SQLite's full-text search (FTS5) in
+ * Node's built-in `node:sqlite`. Node bundles SQLite with FTS5 from 22.16.0 and 24.0.0 (nodejs
+ * PR 57621); no Node 23 release has it, and below 22.13 `node:sqlite` needs a flag. Builds that
+ * use the system's SQLite can still lack it, so doctor and search also check at run time.
+ *
+ * Kept free of imports: the CLI checks this before loading anything else.
+ */
+export declare const NODE_SUPPORTED = "Node.js 22.16 or later in the 22 line, or 24 or later";
+/** Why this Node.js version can't run Wheems, or null when it can. */
+export declare function nodeVersionProblem(version: string): string | null;

package/dist/util/node-support.js

@@ -0,0 +1,21 @@
+/**
+ * Which Node.js versions Wheems runs on. Search needs SQLite's full-text search (FTS5) in
+ * Node's built-in `node:sqlite`. Node bundles SQLite with FTS5 from 22.16.0 and 24.0.0 (nodejs
+ * PR 57621); no Node 23 release has it, and below 22.13 `node:sqlite` needs a flag. Builds that
+ * use the system's SQLite can still lack it, so doctor and search also check at run time.
+ *
+ * Kept free of imports: the CLI checks this before loading anything else.
+ */
+export const NODE_SUPPORTED = 'Node.js 22.16 or later in the 22 line, or 24 or later';
+/** Why this Node.js version can't run Wheems, or null when it can. */
+export function nodeVersionProblem(version) {
+    const [major = 0, minor = 0] = version.replace(/^v/, '').split('.').map(Number);
+    if (major === 23) {
+        return `Node.js ${version} can't run Wheems: no Node 23 release has SQLite full-text search, which Wheems's search needs. Use ${NODE_SUPPORTED}.`;
+    }
+    if (major < 22 || (major === 22 && minor < 16)) {
+        return `Node.js ${version} is too old for Wheems. Use ${NODE_SUPPORTED}.`;
+    }
+    return null;
+}
+//# sourceMappingURL=node-support.js.map

package/dist/util/sqlite.d.ts

@@ -10,4 +10,16 @@ export declare function sqlite(): Promise<Sqlite>;
 export declare function openDatabase(file: string, options?: {
     readOnly?: boolean;
 }): Promise<DatabaseSync>;
+/** Something that runs SQL, as `DatabaseSync` does; tests pass a stand-in. */
+export interface SqlRunner {
+    exec(sql: string): void;
+    close(): void;
+}
+/**
+ * Why this SQLite can't do full-text search (FTS5), which search needs, or null when it can.
+ * `open` makes a scratch database; by default an in-memory one from `node:sqlite`.
+ */
+export declare function fullTextSearchProblem(open?: () => Promise<SqlRunner>): Promise<string | null>;
+/** Throws a plain explanation when this Node's SQLite has no full-text search. Checks once. */
+export declare function requireFullTextSearch(): Promise<void>;
 export {};