cronfish 0.14.0 → 0.15.0

package/README.md

@@ -260,6 +260,7 @@ as a single job instead of many fast fires.
     "on_failure": { "notify": "slack" },
     "default": "slack",
     "slack": { "webhook_url_env": "CRONFISH_SLACK_WEBHOOK" },
+    "slack_bot": { "bot_token_env": "CRONFISH_SLACK_BOT_TOKEN", "channel": "C0123456789" },
     "shell": { "command": "/Users/you/bin/cronfish-pushover.sh" }
   }
 }
@@ -305,6 +306,7 @@ Every failed (`fail` / `timeout` / `crashed`) scheduled run pings the configured
 Adapters ship with cronfish:
 
 - **`slack`** — POSTs Block Kit to an incoming webhook. Reads the URL from the env var named in `alerts.slack.webhook_url_env` (default `CRONFISH_SLACK_WEBHOOK`).
+- **`slack_bot`** — posts the same Block Kit via `chat.postMessage` with a bot token instead of a webhook. One token reaches any channel (with `chat:write.public`, no invite needed), so you skip the per-channel browser-OAuth webhook mint. Reads the token from `alerts.slack_bot.bot_token_env` (default `CRONFISH_SLACK_BOT_TOKEN`) and the target channel from `alerts.slack_bot.channel` (a `C…` id or `#name`) or `alerts.slack_bot.channel_env`. Unlike a webhook, `chat.postMessage` returns HTTP 200 on logical errors, so the adapter inspects the JSON `ok` field and fails on `ok:false` (e.g. `channel_not_found`, `not_in_channel`).
 - **`shell`** — runs an arbitrary command from `alerts.shell.command` with the payload as env vars (`CRONFISH_ALERT_SLUG`, `…_STATUS`, `…_EXIT_CODE`, `…_DURATION_MS`, `…_STARTED_AT`, `…_UI_URL`, `…_LOG_TAIL`) plus the JSON payload on stdin. Use this for Pushover/ntfy/osascript.
 
 Two knobs in `.cronfish.json`, two distinct jobs:
@@ -335,6 +337,10 @@ Sanity check:
 ```
 export CRONFISH_SLACK_WEBHOOK=https://hooks.slack.com/services/...
 cronfish alerts test slack
+
+# or, bot-token path (no webhook to mint):
+export CRONFISH_SLACK_BOT_TOKEN=xoxb-...
+cronfish alerts test slack_bot
 ```
 
 ## Always-on dashboard

package/examples/.cronfish.json

@@ -12,6 +12,7 @@
     "on_failure": { "notify": "slack" },
     "default": "slack",
     "slack": { "webhook_url_env": "CRONFISH_SLACK_WEBHOOK" },
+    "slack_bot": { "bot_token_env": "CRONFISH_SLACK_BOT_TOKEN", "channel": "C0123456789" },
     "shell": { "command": "/usr/local/bin/my-notify.sh" }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cronfish",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "A file-based job scheduler for macOS. Drop a script in a folder; launchd runs it on a schedule.",
   "type": "module",
   "bin": {

package/src/alerts/index.ts

@@ -1,6 +1,7 @@
 export { buildRegistry, type AdapterRegistry } from "./registry.ts";
 export { safeNotify, type AlertOutcome, type AlertOutcomeStatus } from "./safe.ts";
 export { createSlackAdapter, buildSlackBlocks } from "./slack.ts";
+export { createSlackBotAdapter, type SlackBotAdapterOptions } from "./slack-bot.ts";
 export { createShellAdapter, payloadEnv } from "./shell.ts";
 export {
   alertStatusFor,

package/src/alerts/registry.ts

@@ -1,4 +1,5 @@
 import { createShellAdapter } from "./shell.ts";
+import { createSlackBotAdapter } from "./slack-bot.ts";
 import { createSlackAdapter } from "./slack.ts";
 import type { Adapter, AlertsConfig } from "./types.ts";
 
@@ -11,6 +12,7 @@ export interface AdapterRegistry {
 export function buildRegistry(cfg: AlertsConfig = {}): AdapterRegistry {
   const map = new Map<string, Adapter>();
   map.set("slack", createSlackAdapter(cfg.slack));
+  map.set("slack_bot", createSlackBotAdapter(cfg.slack_bot));
   map.set("shell", createShellAdapter(cfg.shell));
   return {
     get(name) {

package/src/alerts/slack-bot.ts

@@ -0,0 +1,80 @@
+// Bot-token Slack adapter — the API-driveable twin of the webhook `slack`
+// adapter. Where `slack` POSTs Block Kit to a per-channel incoming webhook (URL
+// bound to one channel at mint time, only creatable via browser OAuth), this
+// posts via `chat.postMessage` with a bot token: one credential reaches any
+// channel by id/name (with `chat:write.public`, without being invited). Same
+// Block Kit body — it reuses `buildSlackBlocks`, so alerts render identically.
+//
+// Unlike an incoming webhook (which signals failure with a non-2xx status),
+// `chat.postMessage` returns HTTP 200 even on logical errors and carries the
+// real outcome in the JSON `ok`/`error` fields — so this adapter parses the
+// body and throws on `ok:false`, not just on a bad status.
+
+import { buildSlackBlocks } from "./slack.ts";
+import type { Adapter, AlertPayload, AlertsConfig } from "./types.ts";
+
+const DEFAULT_TOKEN_ENV = "CRONFISH_SLACK_BOT_TOKEN";
+const POST_MESSAGE_URL = "https://slack.com/api/chat.postMessage";
+
+export interface SlackBotAdapterOptions {
+  botToken?: string;
+  channel?: string;
+  fetchFn?: typeof fetch;
+}
+
+export function createSlackBotAdapter(
+  cfg: AlertsConfig["slack_bot"] = {},
+  opts: SlackBotAdapterOptions = {},
+): Adapter {
+  const tokenEnv = cfg.bot_token_env ?? DEFAULT_TOKEN_ENV;
+  const fetchFn = opts.fetchFn ?? fetch;
+  return {
+    name: "slack_bot",
+    async notify(payload: AlertPayload): Promise<void> {
+      const token = opts.botToken ?? process.env[tokenEnv];
+      if (!token) {
+        throw new Error(`slack-bot adapter: env var ${tokenEnv} not set`);
+      }
+      const channel =
+        opts.channel ??
+        (cfg.channel_env ? process.env[cfg.channel_env] : undefined) ??
+        cfg.channel;
+      if (!channel) {
+        throw new Error(
+          "slack-bot adapter: no channel configured " +
+            "(set alerts.slack_bot.channel or alerts.slack_bot.channel_env)",
+        );
+      }
+      const blocks = buildSlackBlocks(payload);
+      const res = await fetchFn(POST_MESSAGE_URL, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json; charset=utf-8",
+          authorization: `Bearer ${token}`,
+        },
+        // `text` is the notification/accessibility fallback Slack shows when
+        // blocks can't render (push notifications, screen readers).
+        body: JSON.stringify({
+          channel,
+          text: `${payload.status.toUpperCase()} — ${payload.slug}`,
+          blocks,
+        }),
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(
+          `slack-bot adapter: chat.postMessage returned ${res.status} ${body.slice(0, 200)}`,
+        );
+      }
+      const data = (await res.json().catch(() => ({}))) as {
+        ok?: boolean;
+        error?: string;
+      };
+      if (!data.ok) {
+        throw new Error(
+          `slack-bot adapter: chat.postMessage failed: ${data.error ?? "unknown error"}`,
+        );
+      }
+    },
+  };
+}

package/src/alerts/types.ts

@@ -28,6 +28,14 @@ export interface AlertsConfig {
   slack?: {
     webhook_url_env?: string;
   };
+  slack_bot?: {
+    // Env var holding the bot token (xoxb-…). Default CRONFISH_SLACK_BOT_TOKEN.
+    bot_token_env?: string;
+    // Target channel — id (C…) or #name. Literal value…
+    channel?: string;
+    // …or the env var to read it from (takes precedence over `channel`).
+    channel_env?: string;
+  };
   shell?: {
     command?: string;
   };

package/src/runner.ts

@@ -708,6 +708,23 @@ async function main(): Promise<void> {
     }
   }
 
+  // Install lock-release signal handlers the instant a lock exists. There is
+  // real setup below (DB init, log open) before the full `cleanup` handler is
+  // registered, and a SIGTERM in that window would otherwise kill the process
+  // by default disposition — no handler runs, and the concurrency lockfile is
+  // orphaned (unlike the flock, it is not reclaimed by the OS on exit). This
+  // minimal handler is superseded by `cleanup` once the invocation state exists.
+  let releasing = false;
+  const earlyCleanup = (sig: NodeJS.Signals): void => {
+    if (releasing) return;
+    releasing = true;
+    if (job.concurrency) releaseLock(job.slug);
+    if (oneTimeLock) releaseFlock(oneTimeLock);
+    process.exit(sig === "SIGTERM" ? 143 : 130);
+  };
+  process.on("SIGTERM", earlyCleanup);
+  process.on("SIGINT", earlyCleanup);
+
   const db = tryOpenDb();
 
   // Open the log file BEFORE we know the invocation id (we need a real
@@ -739,8 +756,12 @@ async function main(): Promise<void> {
     appendLog(fd, `[runner] invocation_id=${invocationId} trigger=${trigger}`);
   }
 
-  // Signal handlers — release lock + record crash on launchd shutdown.
-  let releasing = false;
+  // Signal handlers — release lock + record crash on launchd shutdown. This
+  // supersedes earlyCleanup now that the invocation row exists, so a SIGTERM
+  // also records the run as crashed. The off→on swap is synchronous (no await
+  // between), so no signal can slip through with zero handlers installed.
+  process.off("SIGTERM", earlyCleanup);
+  process.off("SIGINT", earlyCleanup);
   const cleanup = (sig: NodeJS.Signals): void => {
     if (releasing) return;
     releasing = true;