137 lines
8.6 KiB
TypeScript
137 lines
8.6 KiB
TypeScript
// Where `storebound watch` sends events: OS notification, ntfy, Telegram, a webhook. All optional, configured from the
|
|
// environment or ~/.storebound/watch.json (never printed; logs name the sink, not its URL, topic or token):
|
|
// STOREBOUND_NTFY_URL (default https://ntfy.sh) + STOREBOUND_NTFY_TOPIC [+ STOREBOUND_NTFY_TOKEN]
|
|
// STOREBOUND_TELEGRAM_TOKEN + STOREBOUND_TELEGRAM_CHAT
|
|
// STOREBOUND_WEBHOOK_URL
|
|
// watch.json: { "notify": ["os"], "ntfy": { "url", "topic", "token" }, "telegram": { "token", "chat" }, "webhook": { "url" } }
|
|
// Builders are pure (tests check them); `send` takes the fetch and the OS runner as parameters.
|
|
import { spawnSync } from 'node:child_process';
|
|
import { readFileSync } from 'node:fs';
|
|
import { type EventKind, watchConfigFile, type WatchEvent } from './watch';
|
|
|
|
export type SinkName = 'os' | 'ntfy' | 'telegram' | 'webhook';
|
|
export const SINK_NAMES: readonly SinkName[] = ['os', 'ntfy', 'telegram', 'webhook'];
|
|
|
|
export interface SinkConfig {
|
|
os?: true;
|
|
ntfy?: { url: string; topic: string; token?: string };
|
|
telegram?: { token: string; chat: string };
|
|
webhook?: { url: string };
|
|
}
|
|
|
|
type Env = Record<string, string | undefined>;
|
|
|
|
/** The sinks that are configured (os only when the file lists it). `only` limits and, for os, enables. */
|
|
export function sinkConfig(env: Env = process.env, file: string | null = watchConfigFile(env), only?: SinkName[]): SinkConfig {
|
|
let f: { notify?: string[]; ntfy?: Record<string, string>; telegram?: Record<string, string>; webhook?: Record<string, string> } = {};
|
|
if (file) { try { f = JSON.parse(readFileSync(file, 'utf8')); } catch { /* no file */ } }
|
|
const out: SinkConfig = {};
|
|
const topic = env.STOREBOUND_NTFY_TOPIC || f.ntfy?.topic;
|
|
if (topic) out.ntfy = { url: (env.STOREBOUND_NTFY_URL || f.ntfy?.url || 'https://ntfy.sh').replace(/\/+$/, ''), topic, ...(env.STOREBOUND_NTFY_TOKEN || f.ntfy?.token ? { token: (env.STOREBOUND_NTFY_TOKEN || f.ntfy?.token)! } : {}) };
|
|
const tg = { token: env.STOREBOUND_TELEGRAM_TOKEN || f.telegram?.token, chat: env.STOREBOUND_TELEGRAM_CHAT || f.telegram?.chat };
|
|
if (tg.token && tg.chat) out.telegram = { token: tg.token, chat: tg.chat };
|
|
const hook = env.STOREBOUND_WEBHOOK_URL || f.webhook?.url;
|
|
if (hook) out.webhook = { url: hook };
|
|
if (Array.isArray(f.notify) && f.notify.includes('os')) out.os = true;
|
|
if (only) {
|
|
const picked: SinkConfig = {};
|
|
for (const n of only) if (n === 'os') picked.os = true; else if (out[n]) (picked as Record<string, unknown>)[n] = out[n];
|
|
return picked;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
export const configuredSinks = (c: SinkConfig): SinkName[] => SINK_NAMES.filter(n => !!c[n]);
|
|
|
|
/** `--notify os,ntfy` -> names; throws on an unknown one. */
|
|
export function parseNotify(list: string[]): SinkName[] {
|
|
for (const n of list) if (!(SINK_NAMES as readonly string[]).includes(n)) throw new Error(`--notify: ${n} is not a sink (${SINK_NAMES.join(', ')})`);
|
|
return list as SinkName[];
|
|
}
|
|
|
|
const LABEL: Record<EventKind, string> = {
|
|
rejected: 'Rejected', approved: 'Approved', live: 'Live', rollout_halted: 'Rollout halted', crash_threshold: 'Crash threshold',
|
|
review_low: 'Low review', review_needs_reply: 'Review needs a reply',
|
|
};
|
|
const TAGS: Record<EventKind, string> = {
|
|
rejected: 'x', approved: 'white_check_mark', live: 'rocket', rollout_halted: 'octagonal_sign', crash_threshold: 'warning', review_low: 'star', review_needs_reply: 'speech_balloon',
|
|
};
|
|
const URGENT: ReadonlySet<EventKind> = new Set<EventKind>(['rejected', 'rollout_halted']);
|
|
|
|
/** HTTP header values are Latin-1 text on one line. */
|
|
const header = (s: string): string => s.replace(/[\r\n]+/g, ' ').replace(/[^\x20-\x7e]/g, '?').slice(0, 250);
|
|
export const titleOf = (e: WatchEvent): string => `${e.app}${e.version ? ` ${e.version}` : ''}: ${LABEL[e.kind]}`;
|
|
export const textOf = (e: WatchEvent): string => `${e.detail}\n${e.url}`;
|
|
|
|
export interface HttpRequest { url: string; headers: Record<string, string>; body: string }
|
|
|
|
export function ntfyRequest(e: WatchEvent, c: NonNullable<SinkConfig['ntfy']>): HttpRequest {
|
|
return { url: `${c.url}/${encodeURIComponent(c.topic)}`, body: e.detail,
|
|
headers: { Title: header(titleOf(e)), Tags: `${TAGS[e.kind]},${e.store}`, Click: e.url, Priority: URGENT.has(e.kind) ? 'high' : 'default', ...(c.token ? { Authorization: `Bearer ${c.token}` } : {}) } };
|
|
}
|
|
export function telegramRequest(e: WatchEvent, c: NonNullable<SinkConfig['telegram']>): HttpRequest {
|
|
return { url: `https://api.telegram.org/bot${c.token}/sendMessage`, headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ chat_id: c.chat, text: `${titleOf(e)}\n${textOf(e)}`.slice(0, 4000), disable_web_page_preview: true }) };
|
|
}
|
|
export function webhookRequest(e: WatchEvent, c: NonNullable<SinkConfig['webhook']>): HttpRequest {
|
|
return { url: c.url, headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(e) };
|
|
}
|
|
|
|
/** The command of an OS notification (title and message travel in the environment, never inside a script string). */
|
|
export function osCommand(platform: string, title: string, message: string): { cmd: string; args: string[]; env: Record<string, string> } | null {
|
|
const env = { SB_TITLE: title.slice(0, 120), SB_MSG: message.slice(0, 400) };
|
|
if (platform === 'win32') {
|
|
const script = [
|
|
'[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null',
|
|
'$x = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)',
|
|
'$t = $x.GetElementsByTagName(\'text\')',
|
|
'$t.Item(0).AppendChild($x.CreateTextNode($env:SB_TITLE)) > $null',
|
|
'$t.Item(1).AppendChild($x.CreateTextNode($env:SB_MSG)) > $null',
|
|
'[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier(\'storebound\').Show([Windows.UI.Notifications.ToastNotification]::new($x))',
|
|
].join('; ');
|
|
return { cmd: 'powershell', args: ['-NoProfile', '-NonInteractive', '-Command', script], env };
|
|
}
|
|
if (platform === 'darwin') return { cmd: 'osascript', args: ['-e', 'display notification (system attribute "SB_MSG") with title (system attribute "SB_TITLE")'], env };
|
|
if (platform === 'linux') return { cmd: 'notify-send', args: [env.SB_TITLE, env.SB_MSG], env };
|
|
return null;
|
|
}
|
|
|
|
export type FetchLike = (url: string, init: { method: string; headers: Record<string, string>; body: string; signal?: AbortSignal }) => Promise<{ ok: boolean; status: number }>;
|
|
export type OsRunner = (c: { cmd: string; args: string[]; env: Record<string, string> }) => boolean;
|
|
|
|
export const runOs: OsRunner = c => {
|
|
try { return spawnSync(c.cmd, c.args, { env: { ...process.env, ...c.env }, timeout: 10_000, stdio: 'ignore', windowsHide: true }).status === 0; } catch { return false; }
|
|
};
|
|
|
|
/** POST with a timeout and one retry (network error, 429 or 5xx). Resolves to an error text, or null when sent. */
|
|
export async function post(fetchFn: FetchLike, r: HttpRequest, o: { timeoutMs?: number; retryMs?: number } = {}): Promise<string | null> {
|
|
let last = '';
|
|
for (let attempt = 0; attempt < 2; attempt++) {
|
|
if (attempt) await new Promise(res => setTimeout(res, o.retryMs ?? 1500));
|
|
try {
|
|
const res = await fetchFn(r.url, { method: 'POST', headers: r.headers, body: r.body, signal: AbortSignal.timeout(o.timeoutMs ?? 10_000) });
|
|
if (res.ok) return null;
|
|
last = `HTTP ${res.status}`;
|
|
if (res.status < 500 && res.status !== 429) return last;
|
|
} catch (e) { last = (e as Error).name === 'TimeoutError' ? 'timed out' : 'network error'; }
|
|
}
|
|
return last;
|
|
}
|
|
|
|
export interface SendReport { sink: SinkName; ok: boolean; error?: string }
|
|
|
|
/** Sends one event to every sink in the config. A failing sink is a report row, never an exception. */
|
|
export async function sendEvent(e: WatchEvent, c: SinkConfig, d: { fetch?: FetchLike; os?: OsRunner; platform?: string; timeoutMs?: number; retryMs?: number } = {}): Promise<SendReport[]> {
|
|
const fetchFn = d.fetch ?? (fetch as unknown as FetchLike);
|
|
const out: SendReport[] = [];
|
|
const http = async (sink: SinkName, r: HttpRequest): Promise<void> => { const err = await post(fetchFn, r, d); out.push(err ? { sink, ok: false, error: err } : { sink, ok: true }); };
|
|
if (c.os) {
|
|
const cmd = osCommand(d.platform ?? process.platform, titleOf(e), e.detail);
|
|
// unavailable (no notifier on this machine): skipped quietly, not a failure
|
|
if (cmd) { const ok = (d.os ?? runOs)(cmd); if (ok) out.push({ sink: 'os', ok: true }); }
|
|
}
|
|
if (c.ntfy) await http('ntfy', ntfyRequest(e, c.ntfy));
|
|
if (c.telegram) await http('telegram', telegramRequest(e, c.telegram));
|
|
if (c.webhook) await http('webhook', webhookRequest(e, c.webhook));
|
|
return out;
|
|
}
|