@stage-labs/metro 0.1.0-beta.22 → 0.1.0-beta.221

package/runtime/node_modules/@metro-labs/{mcp/src/stations → core/src}/lines.ts

@@ -5,50 +5,40 @@ const PREFIX = 'metro://';
 const build = (station: string, ...seg: (string | number)[]): Line =>
   asLine(`${PREFIX}${station}/${seg.map(String).join('/')}`);
 
-export function parseAccountScoped(
+function parseAccountScoped(
   line: Line | string,
   station: string,
   validate?: (resource: string) => boolean,
 ): { accountId: string; resource: string } | null {
   const p = Line.parse(line);
-  if (p?.station !== station) return null;
-  let accountId: string, resource: string;
-  if (p.path.length === 2 && p.path[0] !== undefined && p.path[1] !== undefined) {
-    accountId = p.path[0];
-    resource = p.path[1];
-  } else if (p.path.length === 1 && p.path[0] !== undefined) {
-    accountId = 'default';
-    resource = p.path[0];
-  } else return null;
+  if (p?.station !== station || p.path.length !== 2) return null;
+  const [accountId, resource] = p.path;
+  if (accountId === undefined || resource === undefined) return null;
   if (validate && !validate(resource)) return null;
   return { accountId, resource };
 }
 
 const isSnowflake = (s: string): boolean => /^\d+$/.test(s);
+const isThreemaResource = (s: string): boolean =>
+  /^(?:[A-Z0-9]{8}|\*[A-Z0-9]{7})(?:-[0-9a-f]{16})?$/i.test(s);
+const isMailResource = (s: string): boolean => /^[A-Za-z0-9=_%.@+-]+$/.test(s);
 const isSignedInt = (s: string): boolean => /^-?\d+$/.test(s);
 
-function splitTelegramAccount(path: string[]): { accountId: string; rest: string[] } {
-  const first = path[0];
-  if (path.length >= 2 && first !== undefined && !isSignedInt(first))
-    return { accountId: first, rest: path.slice(1) };
-  return { accountId: 'default', rest: path };
-}
+const topicPart = (topicId: string | undefined): { topicId?: number } | null => {
+  if (topicId === undefined) return {};
+  return isSnowflake(topicId) ? { topicId: Number(topicId) } : null;
+};
 
 function parseTelegramLine(
   line: Line | string,
 ): { accountId: string; chatId: number; topicId?: number } | null {
   const p = Line.parse(line);
   if (p?.station !== 'telegram-bot') return null;
-  const { accountId, rest } = splitTelegramAccount(p.path);
-  const [chatId, topicId] = rest;
-  if (rest.length < 1 || rest.length > 2 || chatId === undefined || !isSignedInt(chatId))
-    return null;
-  if (topicId !== undefined && !isSnowflake(topicId)) return null;
-  return {
-    accountId,
-    chatId: Number(chatId),
-    ...(topicId !== undefined ? { topicId: Number(topicId) } : {}),
-  };
+  const [accountId, chatId, topicId, ...extra] = p.path;
+  if (accountId === undefined || chatId === undefined || extra.length > 0) return null;
+  if (!isSignedInt(chatId)) return null;
+  const topic = topicPart(topicId);
+  return topic === null ? null : { accountId, chatId: Number(chatId), ...topic };
 }
 
 export const Line = {
@@ -79,4 +69,10 @@ export const Line = {
     parseAccountScoped(line, 'discord-bot', isSnowflake),
 
   parseTelegram: (line: Line | string) => parseTelegramLine(line),
+
+  parseThreema: (line: Line | string) =>
+    parseAccountScoped(line, 'threema', isThreemaResource),
+
+  parseMail: (line: Line | string, station: 'outlook' | 'gmail') =>
+    parseAccountScoped(line, station, isMailResource),
 };

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → core/src}/protocol.ts

@@ -3,7 +3,7 @@ import { join, parse as parsePath } from 'node:path';
 import { errMsg, log } from './log.js';
 import { coerceErrorInfo, type TrainErrorInfo } from './train-error.js';
 import type { StructuredEvent } from './events.js';
-import type { CallMsg } from '../stations/station-runtime.js';
+import type { CallMsg } from './stations/station-runtime.js';
 
 export {
   TrainError,
@@ -11,7 +11,7 @@ export {
   type TrainErrorInfo,
 } from './train-error.js';
 
-export const CALL_TIMEOUT_MS = 60_000;
+const CALL_TIMEOUT_MS = 60_000;
 
 export interface Pending {
   resolve: (r: TrainCallResponse) => void;
@@ -24,7 +24,7 @@ export interface CallTarget {
   proc: ({ stdin?: unknown } & Record<string, unknown>) | null;
 }
 
-export const STDOUT_LINE_MAX = 4 * 1024 * 1024;
+const STDOUT_LINE_MAX = 4 * 1024 * 1024;
 
 export type TrainEvent = {
   station?: string;
@@ -37,6 +37,9 @@ export type TrainEvent = {
   message_id?: string;
   reply_to?: string;
   is_private?: boolean;
+  mentions_self?: boolean;
+  reply_to_self?: boolean;
+  sender_verified?: boolean;
   text?: string;
   emoji?: string;
   payload?: unknown;
@@ -149,7 +152,7 @@ export function readCalls(
   });
 }
 
-export function encodeCall(id: string, action: string, args: unknown): string {
+function encodeCall(id: string, action: string, args: unknown): string {
   return JSON.stringify({ op: 'call', id, action, args }) + '\n';
 }
 

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → core/src}/secure-fs.ts

@@ -38,6 +38,23 @@ export function writeSecure(path: string, data: string): void {
   chmodIfExists(path, 0o600);
 }
 
+function modeOf(path: string): number | null {
+  try {
+    return statSync(path).mode & 0o777;
+  } catch {
+    return null;
+  }
+}
+
+export function writeAtomic(path: string, data: string, mode?: number): void {
+  const chosen = mode ?? modeOf(path) ?? 0o644;
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.metro-${String(process.pid)}.tmp`;
+  writeFileSync(tmp, data, { mode: chosen });
+  chmodSync(tmp, chosen);
+  renameSync(tmp, path);
+}
+
 export function readJson<T>(
   path: string,
   fallback: T,

package/runtime/node_modules/@metro-labs/core/src/station-names.ts

@@ -0,0 +1,14 @@
+export const STATIONS = [
+  'xmtp',
+  'telegram-bot',
+  'telegram',
+  'discord-bot',
+  'whatsapp',
+  'threema',
+  'outlook',
+  'gmail',
+  'webhook',
+] as const;
+
+export type StationName = (typeof STATIONS)[number];
+

package/runtime/node_modules/@metro-labs/core/src/stations/account-files.ts

@@ -0,0 +1,41 @@
+import { readdirSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { log } from '../log.js';
+
+export interface AccountFiles {
+  path: (accountId: string) => string;
+  forget: (accountId: string) => void;
+  forgetExcept: (keptAccountIds: readonly string[]) => void;
+}
+
+const safeSegment = (s: string): string => s.replace(/[^A-Za-z0-9_-]/g, '_');
+
+function listed(dir: string): string[] {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+export function accountFiles(dirEnv: string, prefix: string): AccountFiles {
+  const dir = (): string => process.env[dirEnv] ?? join(homedir(), '.metro');
+  const name = (accountId: string): string => `${prefix}${safeSegment(accountId)}.json`;
+  const remove = (file: string, reason: string): void => {
+    rmSync(join(dir(), file), { force: true });
+    log.info({ file: join(dir(), file) }, reason);
+  };
+  return {
+    path: (accountId) => join(dir(), name(accountId)),
+    forget: (accountId) => {
+      remove(name(accountId), 'station: removed the files of a detached account');
+    },
+    forgetExcept: (keptAccountIds) => {
+      const kept = new Set(keptAccountIds.map(name));
+      for (const file of listed(dir()))
+        if (file.startsWith(prefix) && file.endsWith('.json') && !kept.has(file))
+          remove(file, 'station: removed the files of an account that is no longer attached');
+    },
+  };
+}

package/runtime/node_modules/@metro-labs/core/src/stations/account-store.ts

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { errMsg } from '../log.js';
+import { chmodIfExists } from '../secure-fs.js';
+
+export type Die = (msg: string) => never;
+
+export interface AccountStoreOpts<T> {
+  prefix: string;
+  validate?: (raw: T[], die: Die) => void;
+}
+
+export interface Loader<T> {
+  die: Die;
+  loadAccounts: () => T[];
+}
+
+const envName = (prefix: string): string =>
+  `${prefix.toUpperCase().replace(/-/g, '_')}_ACCOUNTS_FILE`;
+
+const accountsFile = (prefix: string): string =>
+  process.env[envName(prefix)] ?? join(homedir(), '.metro', `${prefix}-accounts.json`);
+
+function checkIds(raw: { id: string }[], die: Die): void {
+  const seen = new Set<string>();
+  for (const a of raw) {
+    if (!a.id) die('account missing id');
+    if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
+    seen.add(a.id);
+  }
+}
+
+function readList<T>(file: string, die: Die): T[] {
+  if (!existsSync(file))
+    return die(
+      `no accounts file ${file} — the daemon writes it from ~/.metro/agents/agent.json at boot; attach an account to this station from the page first`,
+    );
+  chmodIfExists(file);
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(file, 'utf8'));
+  } catch (e) {
+    return die(`bad ${file}: ${errMsg(e)}`);
+  }
+  if (!Array.isArray(raw) || raw.length === 0)
+    return die(`${file} must be a non-empty array`);
+  return raw as T[];
+}
+
+export function makeAccountStore<T extends { id: string }>(
+  opts: AccountStoreOpts<T>,
+): Loader<T> {
+  const die: Die = (msg) => {
+    process.stderr.write(`${opts.prefix}: ${msg}\n`);
+    process.exit(2);
+  };
+
+  function loadAccounts(): T[] {
+    const raw = readList<T>(accountsFile(opts.prefix), die);
+    checkIds(raw, die);
+    opts.validate?.(raw, die);
+    return raw;
+  }
+
+  return { die, loadAccounts };
+}
+
+export function resolveAccountId(
+  accounts: Map<string, unknown>,
+  args: { account?: string; line?: string },
+  parseAccountId: (line: string) => string | undefined,
+): string {
+  const have = [...accounts.keys()];
+  let id = args.account;
+  id ??= args.line ? parseAccountId(args.line) : undefined;
+  id ??= have.length === 1 ? have[0] : undefined;
+  if (id === undefined)
+    throw new Error(`name an account (have: ${have.join(', ')})`);
+  if (!accounts.has(id))
+    throw new Error(`unknown account '${id}' (have: ${have.join(', ')})`);
+  return id;
+}

package/runtime/node_modules/@metro-labs/{mcp → core}/src/stations/attachments.ts

@@ -190,7 +190,6 @@ export const toCanonical = (a: {
 }): Record<string, unknown> => ({
   kind: kindOf(a.mime, a.path),
   path: a.path,
-  url: a.path,
   name: a.name,
   mime: a.mime,
 });

package/runtime/node_modules/@metro-labs/core/src/stations/mail-text.ts

@@ -0,0 +1,72 @@
+export const MAX_TEXT_CHARS = 20_000;
+
+const ENTITIES: Record<string, string> = {
+  amp: '&',
+  lt: '<',
+  gt: '>',
+  quot: '"',
+  apos: "'",
+  nbsp: ' ',
+  ndash: '-',
+  mdash: '-',
+  hellip: '...',
+  rsquo: "'",
+  lsquo: "'",
+  rdquo: '"',
+  ldquo: '"',
+};
+
+function codePoint(n: number): string {
+  return Number.isInteger(n) && n > 0 && n <= 0x10ffff ? String.fromCodePoint(n) : '';
+}
+
+export function decodeEntities(text: string): string {
+  return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (whole, name: string) => {
+    if (name.startsWith('#x') || name.startsWith('#X')) return codePoint(parseInt(name.slice(2), 16));
+    if (name.startsWith('#')) return codePoint(Number(name.slice(1)));
+    return ENTITIES[name.toLowerCase()] ?? whole;
+  });
+}
+
+export function htmlToText(html: string): string {
+  const text = html
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/<(head|style|script|title)\b[\s\S]*?<\/\1\s*>/gi, '')
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<li\b[^>]*>/gi, '\n- ')
+    .replace(/<\/(p|div|tr|h[1-6]|blockquote|table|ul|ol)\s*>/gi, '\n')
+    .replace(/<(p|div|tr|h[1-6]|blockquote|table)\b[^>]*>/gi, '\n')
+    .replace(/<\/t[dh]\s*>/gi, ' ')
+    .replace(/<[^>]*>/g, '');
+  return tidy(decodeEntities(text));
+}
+
+export function tidy(text: string): string {
+  return text
+    .replace(/\r\n?/g, '\n')
+    .replace(/[ \t ]+/g, ' ')
+    .split('\n')
+    .map((l) => l.trim())
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+export function capText(text: string, max = MAX_TEXT_CHARS): string {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}\n[... ${String(text.length - max)} more characters]`;
+}
+
+export function bodyText(body: { contentType?: unknown; content?: unknown } | undefined): string {
+  const content = typeof body?.content === 'string' ? body.content : '';
+  return String(body?.contentType).toLowerCase() === 'html' ? htmlToText(content) : tidy(content);
+}
+
+export function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/\r?\n/g, '<br>');
+}

package/runtime/node_modules/@metro-labs/core/src/stations/mail-trust.ts

@@ -0,0 +1,29 @@
+export interface MailHeader {
+  name?: string;
+  value?: string;
+}
+
+export type Screened = { skip: string } | { verified: boolean };
+
+const AUTOMATED_LOCAL = /^(no-?reply|do-?not-?reply|donotreply|mailer-daemon|notifications?)([+._-].*)?$/i;
+const BULK = new Set(['bulk', 'list', 'junk']);
+
+export const headerValues = (headers: MailHeader[], name: string): string[] =>
+  headers.filter((h) => (h.name ?? '').toLowerCase() === name).map((h) => (h.value ?? '').trim());
+
+export const firstHeader = (headers: MailHeader[], name: string): string | undefined => headerValues(headers, name)[0];
+
+export function automatedBySender(address: string): string | null {
+  const local = address.split('@')[0] ?? '';
+  return AUTOMATED_LOCAL.test(local) ? `sender ${address}` : null;
+}
+
+export function automatedByHeaders(headers: MailHeader[]): string | null {
+  if (firstHeader(headers, 'list-unsubscribe') !== undefined) return 'List-Unsubscribe';
+  const auto = firstHeader(headers, 'auto-submitted');
+  if (auto !== undefined && auto.toLowerCase() !== 'no') return `Auto-Submitted: ${auto}`;
+  const precedence = (firstHeader(headers, 'precedence') ?? '').toLowerCase();
+  return BULK.has(precedence) ? `Precedence: ${precedence}` : null;
+}
+
+export const domainOf = (address: string): string => (address.split('@')[1] ?? '').toLowerCase();

package/runtime/node_modules/@metro-labs/core/src/stations/mail.ts

@@ -0,0 +1,212 @@
+import { mintId } from '../ids.js';
+import { Line } from '../lines.js';
+import { TrainError } from '../train-error.js';
+import { capText } from './mail-text.js';
+
+export type MailStation = 'outlook' | 'gmail';
+
+type Args = Record<string, unknown>;
+
+export interface MailItem {
+  id: string;
+  threadId: string;
+  subject: string;
+  from: string;
+  fromName: string;
+  to: string[];
+  cc: string[];
+  date: string | null;
+  preview: string;
+  text: string;
+  hasAttachments: boolean;
+  isRead: boolean;
+  internetMessageId: string | null;
+}
+
+export interface AttachmentMeta {
+  kind: string;
+  name: string;
+  mime: string;
+  size?: number;
+}
+
+export interface OutgoingFile {
+  path: string;
+  mime: string;
+  name: string;
+}
+
+export interface ReadQuery {
+  threadId: string | null;
+  query: string;
+  from: string;
+  since: string;
+  until: string;
+  before: string;
+  unreadOnly: boolean;
+  limit: number;
+}
+
+export const DEFAULT_LIMIT = 20;
+export const MAX_LIMIT = 50;
+const SEEN_MAX = 500;
+const SUBJECT_MAX = 255;
+const ADDRESS_RE = /^[^@\s/]+@[^@\s/]+\.[^@\s/]+$/;
+
+export interface MailService {
+  station: MailStation;
+  company: string;
+  product: string;
+  api: string;
+  apiCode: string;
+}
+
+export function refusalOf(s: MailService, status: number, detail: string): TrainError {
+  const refuse = (code: string, text: string, retryable = false): TrainError => new TrainError(`${s.station}_${code}`, text, { retryable });
+  if (status === 401) return refuse('signed_out', `${s.company} refused this mailbox's sign-in (${detail}); connect ${s.product} again from the page`);
+  if (status === 403) return refuse('forbidden', `${s.company} does not let Metro do that on this mailbox (${detail})`);
+  if (status === 404) return refuse('not_found', `${s.product} has no such message or conversation (${detail})`);
+  if (status === 413) return refuse('too_large', `${s.product} refused the size of that request (${detail})`);
+  if (status === 429) return refuse('throttled', `${s.company} asked Metro to slow down (${detail}); try again in a minute`, true);
+  return refuse(s.apiCode, `${s.api} answered ${String(status)} (${detail})`, status >= 500);
+}
+
+export const str = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');
+
+const encodeResource = (id: string): string => id.replace(/%/g, '%25').replace(/\//g, '%2F').replace(/\+/g, '%2B');
+
+export const mailLine = (station: MailStation, accountId: string, threadId: string): string =>
+  `metro://${station}/${accountId}/${encodeResource(threadId)}`;
+
+const mailUser = (station: MailStation, accountId: string, address: string): string =>
+  `metro://${station}/${accountId}/user/${address.toLowerCase()}`;
+
+export function threadOfLine(station: MailStation, line: string): { accountId: string; threadId: string } | null {
+  const parsed = Line.parseMail(line, station);
+  if (parsed === null) return null;
+  try {
+    return { accountId: parsed.accountId, threadId: decodeURIComponent(parsed.resource) };
+  } catch {
+    return null;
+  }
+}
+
+const isPrivateTo = (m: MailItem, self: string): boolean => m.to.length === 1 && m.to[0] === self && m.cc.length === 0;
+
+export function mailEnvelope(station: MailStation, accountId: string, self: string, m: MailItem, attachments: AttachmentMeta[], verified: boolean): Record<string, unknown> {
+  const body = capText(m.text);
+  return {
+    id: mintId(),
+    ts: m.date ?? new Date().toISOString(),
+    station,
+    line: mailLine(station, accountId, m.threadId),
+    line_name: m.subject === '' ? '(no subject)' : m.subject,
+    from: mailUser(station, accountId, m.from === '' ? 'unknown' : m.from),
+    from_name: m.fromName || m.from,
+    from_display_name: m.fromName || undefined,
+    message_id: m.id,
+    text: m.subject === '' ? body : `Subject: ${m.subject}\n\n${body}`,
+    is_private: isPrivateTo(m, self),
+    sender_verified: verified,
+    payload: {
+      from: m.from,
+      to: m.to,
+      cc: m.cc,
+      subject: m.subject,
+      internetMessageId: m.internetMessageId,
+      ...(attachments.length === 0 ? {} : { attachments }),
+    },
+  };
+}
+
+const heading = (station: MailStation, accountId: string, m: MailItem): Record<string, unknown> => ({
+  message_id: m.id,
+  line: mailLine(station, accountId, m.threadId),
+  from: m.from,
+  from_name: m.fromName,
+  date: m.date,
+  title: m.subject,
+});
+
+export const mailSummary = (station: MailStation, accountId: string, m: MailItem): Record<string, unknown> => ({
+  ...heading(station, accountId, m),
+  text_preview: m.preview,
+  has_attachments: m.hasAttachments,
+  is_read: m.isRead,
+});
+
+export const mailFull = (station: MailStation, accountId: string, m: MailItem): Record<string, unknown> => ({
+  ...heading(station, accountId, m),
+  has_attachments: m.hasAttachments,
+  is_read: m.isRead,
+  to: m.to,
+  cc: m.cc,
+  text: capText(m.text),
+});
+
+export const isAddress = (target: string): boolean => target.includes('@');
+
+export const isEmailAddress = (value: string): boolean => ADDRESS_RE.test(value);
+
+export function checkAddress(station: MailStation, to: string): void {
+  if (!isEmailAddress(to)) throw new TrainError(`${station}_bad_address`, `not an email address: ${to}`, { retryable: false });
+}
+
+export function subjectOf(station: MailStation, subject: string, text: string): string {
+  const chosen = subject !== '' ? subject : (text.split('\n').find((l) => l.trim() !== '') ?? '').trim();
+  if (chosen === '') throw new TrainError(`${station}_subject_required`, 'a new email needs a subject or some text', { retryable: false });
+  return chosen.length > SUBJECT_MAX ? `${chosen.slice(0, SUBJECT_MAX - 3)}...` : chosen;
+}
+
+export const filesOf = (raw: unknown): OutgoingFile[] =>
+  (Array.isArray(raw) ? raw : [])
+    .map((a) => (a ?? {}) as Record<string, unknown>)
+    .filter((a) => typeof a.path === 'string' && a.path !== '')
+    .map((a) => ({
+      path: String(a.path),
+      mime: typeof a.mime === 'string' && a.mime !== '' ? a.mime : 'application/octet-stream',
+      name: typeof a.name === 'string' && a.name !== '' ? a.name : 'file',
+    }));
+
+function isoOf(station: MailStation, raw: string, field: string): string {
+  if (raw === '') return '';
+  const at = Date.parse(raw);
+  if (Number.isNaN(at)) throw new TrainError(`${station}_bad_date`, `${field} must be a date, for example 2026-09-24 or 2026-09-24T10:00:00Z`, { retryable: false });
+  return new Date(at).toISOString();
+}
+
+export function readQueryOf(station: MailStation, args: Args): ReadQuery {
+  const line = str(args.line);
+  const thread = line === '' ? null : threadOfLine(station, line);
+  if (line !== '' && thread === null) throw new TrainError(`${station}_bad_line`, `not a valid ${station} line: ${line}`, { retryable: false });
+  return {
+    threadId: thread?.threadId ?? null,
+    query: str(args.query),
+    from: str(args.from).toLowerCase(),
+    since: isoOf(station, str(args.since), 'since'),
+    until: isoOf(station, str(args.until), 'until'),
+    before: str(args.before),
+    unreadOnly: args.unreadOnly === true,
+    limit: typeof args.limit === 'number' && args.limit > 0 ? Math.min(Math.floor(args.limit), MAX_LIMIT) : DEFAULT_LIMIT,
+  };
+}
+
+export const seenOf = (raw: unknown): string[] => (Array.isArray(raw) ? raw.filter((s): s is string => typeof s === 'string') : []);
+
+export function noteSeen(seen: string[], messageId: string): void {
+  seen.push(messageId);
+  if (seen.length > SEEN_MAX) seen.splice(0, seen.length - SEEN_MAX);
+}
+
+export function pollForever(tag: string, once: () => Promise<unknown>, intervalMs: number): void {
+  const tick = (): void => {
+    once()
+      .catch((err: unknown) => {
+        process.stderr.write(`${tag} mail check failed: ${err instanceof Error ? err.message : String(err)}\n`);
+      })
+      .finally(() => {
+        setTimeout(tick, intervalMs);
+      });
+  };
+  tick();
+}

package/runtime/node_modules/@metro-labs/core/src/stations/messaging-normalize.ts

@@ -0,0 +1,16 @@
+type Args = Record<string, unknown>;
+
+export interface Normalized {
+  action: string;
+  args: Args;
+}
+
+export type Normalize = (action: string, args: Args) => Normalized;
+
+export const messagingAliases =
+  (removal: Args = { emoji: '' }): Normalize =>
+  (action, args) => {
+    if (action === 'reply') return { action: 'send', args };
+    if (action === 'unreact') return { action: 'react', args: { ...args, ...removal } };
+    return { action, args };
+  };