@stage-labs/metro 0.1.0-beta.324 → 0.1.0-beta.326

package/runtime/node_modules/@metro-labs/daemon/src/stations/materialize.ts

@@ -22,12 +22,7 @@ import {
 } from '../agents/map.js';
 import { setKeyMap } from '../agents/keys.js';
 import { STATIONS, type StationName } from '@metro-labs/core/station-names';
-
-interface StationTarget {
-  file: string;
-  fileEnv: string;
-  trainImport: string | null;
-}
+import { stationByName } from './registry.js';
 
 export interface LoadedAccount {
   station: StationName;
@@ -48,59 +43,15 @@ export interface LoadedAgent {
 
 const METRO_DIR = join(homedir(), '.metro');
 
-const STATION_TARGETS: Record<StationName, StationTarget> = {
-  xmtp: {
-    file: 'xmtp-accounts.json',
-    fileEnv: 'XMTP_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/xmtp/train',
-  },
-  'telegram-bot': {
-    file: 'telegram-bot-accounts.json',
-    fileEnv: 'TELEGRAM_BOT_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/telegram-bot/train',
-  },
-  'telegram': {
-    file: 'telegram-accounts.json',
-    fileEnv: 'TELEGRAM_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/telegram/train',
-  },
-  'discord-bot': {
-    file: 'discord-bot-accounts.json',
-    fileEnv: 'DISCORD_BOT_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/discord-bot/train',
-  },
-  whatsapp: {
-    file: 'whatsapp-accounts.json',
-    fileEnv: 'WHATSAPP_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/whatsapp/train',
-  },
-  threema: {
-    file: 'threema-accounts.json',
-    fileEnv: 'THREEMA_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/threema/train',
-  },
-  outlook: {
-    file: 'outlook-accounts.json',
-    fileEnv: 'OUTLOOK_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/outlook/train',
-  },
-  gmail: {
-    file: 'gmail-accounts.json',
-    fileEnv: 'GMAIL_ACCOUNTS_FILE',
-    trainImport: '@metro-labs/gmail/train',
-  },
-  webhook: {
-    file: 'webhook-accounts.json',
-    fileEnv: 'WEBHOOK_ACCOUNTS_FILE',
-    trainImport: null,
-  },
-};
+const STATION_SET = new Set<string>(STATIONS);
 
 export function accountFilePath(station: StationName): string {
-  const target = STATION_TARGETS[station];
-  return process.env[target.fileEnv] ?? join(METRO_DIR, target.file);
+  return process.env[`${station.toUpperCase().replace(/-/g, '_')}_ACCOUNTS_FILE`] ?? join(METRO_DIR, `${station}-accounts.json`);
 }
 
+const trainImport = (station: StationName): string | null =>
+  stationByName(station)?.hasTrain === false ? null : `@metro-labs/${station}/train`;
+
 export type StationSource = () => Promise<LoadedAgent[]>;
 
 export const MOVABLE_STATIONS = new Set<StationName>(
@@ -154,7 +105,7 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
   for (const agent of list) {
     names[agent.id] = agent.name;
     for (const a of agent.accounts) {
-      if (!(a.station in STATION_TARGETS)) {
+      if (!STATION_SET.has(a.station)) {
         log.error(
           { station: a.station, id: a.id },
           'unknown station — this metro is older or newer than the row; skipping it',
@@ -185,9 +136,9 @@ function writeStations(list: LoadedAgent[]): WrittenStations {
       writeSecure(path, content);
       changed.push(station);
     }
-    const { trainImport } = STATION_TARGETS[station];
-    if (trainImport !== null)
-      writeIfChanged(trainStubPath(station), `import '${trainImport}';\n`);
+    const train = trainImport(station);
+    if (train !== null)
+      writeIfChanged(trainStubPath(station), `import '${train}';\n`);
     active.set(station, accts.length);
   }
   return { active, changed };
@@ -197,9 +148,9 @@ const BLANKED = '[]\n';
 
 function pruneStations(present: Map<StationName, number>): StationName[] {
   const removed: StationName[] = [];
-  for (const station of Object.keys(STATION_TARGETS) as StationName[]) {
+  for (const station of STATIONS) {
     if (present.has(station)) continue;
-    const hasTrain = STATION_TARGETS[station].trainImport !== null;
+    const hasTrain = trainImport(station) !== null;
     const stub = trainStubPath(station);
     const stubGone = !hasTrain || !existsSync(stub);
     const file = currentText(accountFilePath(station));

package/runtime/node_modules/@metro-labs/daemon/src/stations/supervisor.ts

@@ -44,10 +44,6 @@ export class TrainSupervisor {
 
   constructor(private dir: string = trainsDir()) {}
 
-  running(): string[] {
-    return [...this.trains.keys()];
-  }
-
   onTrainEvent(handler: (event: TrainEvent, train: string) => void): void {
     this.onEvent = handler;
   }
@@ -89,13 +85,7 @@ export class TrainSupervisor {
       clearTimeout(timer);
       this.reloadTimers.delete(name);
     }
-    t.stopped = true;
-    if (t.restartTimer) {
-      clearTimeout(t.restartTimer);
-      t.restartTimer = null;
-    }
-    failAllPending(t.pending, `train '${name}' stopped`);
-    const wait = killGracefully(t.proc);
+    const wait = this.halt(t, `train '${name}' stopped`);
     if (wait) await wait;
     this.trains.delete(name);
     log.info({ name }, 'train: stopped, last account detached');
@@ -133,13 +123,7 @@ export class TrainSupervisor {
     this.reloadTimers.clear();
     const tasks: Promise<unknown>[] = [];
     for (const t of this.trains.values()) {
-      t.stopped = true;
-      if (t.restartTimer) {
-        clearTimeout(t.restartTimer);
-        t.restartTimer = null;
-      }
-      failAllPending(t.pending, 'train shutting down');
-      const wait = killGracefully(t.proc);
+      const wait = this.halt(t, 'train shutting down');
       if (wait) tasks.push(wait);
     }
     await Promise.all(tasks);
@@ -148,13 +132,7 @@ export class TrainSupervisor {
   async restart(name: string): Promise<void> {
     const t = this.trains.get(name);
     if (!t) throw new Error(`no train named '${name}'`);
-    if (t.restartTimer) {
-      clearTimeout(t.restartTimer);
-      t.restartTimer = null;
-    }
-    failAllPending(t.pending, `train '${name}' restarting`);
-    t.stopped = true;
-    const wait = killGracefully(t.proc);
+    const wait = this.halt(t, `train '${name}' restarting`);
     if (wait) await wait;
     t.stopped = false;
     t.failCount = 0;
@@ -162,6 +140,16 @@ export class TrainSupervisor {
     this.spawn(t);
   }
 
+  private halt(t: TrainState, reason: string): Promise<unknown> | null {
+    t.stopped = true;
+    if (t.restartTimer) {
+      clearTimeout(t.restartTimer);
+      t.restartTimer = null;
+    }
+    failAllPending(t.pending, reason);
+    return killGracefully(t.proc);
+  }
+
   async call(
     name: string,
     action: string,

package/runtime/node_modules/@metro-labs/daemon/src/stations/threema-callbacks.ts

@@ -1,4 +1,5 @@
 import { readJson } from '@metro-labs/core/secure-fs';
+import { isRecord } from '@metro-labs/core/is-record';
 import { accountFilePath } from './materialize.js';
 
 export interface ThreemaCallback {
@@ -11,11 +12,10 @@ const str = (v: unknown): string | undefined =>
   typeof v === 'string' && v !== '' ? v : undefined;
 
 function toCallback(row: unknown): ThreemaCallback | null {
-  if (typeof row !== 'object' || row === null) return null;
-  const rec = row as Record<string, unknown>;
-  const id = str(rec.id);
-  const callbackId = str(rec.callbackId);
-  const callbackToken = str(rec.callbackToken);
+  if (!isRecord(row)) return null;
+  const id = str(row.id);
+  const callbackId = str(row.callbackId);
+  const callbackToken = str(row.callbackToken);
   if (id === undefined || callbackId === undefined || callbackToken === undefined) return null;
   return { id, callbackId, callbackToken };
 }

package/runtime/node_modules/@metro-labs/daemon/src/stations/webhook-endpoints.ts

@@ -1,8 +1,7 @@
 import type { Endpoint } from '@metro-labs/core/endpoints';
 import { timingSafeEqual } from 'node:crypto';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import { readJson } from '@metro-labs/core/secure-fs';
+import { accountFilePath } from './materialize.js';
 
 interface AccountRecord {
   id?: unknown;
@@ -12,10 +11,6 @@ interface AccountRecord {
   createdAt?: unknown;
 }
 
-const accountsFile = (): string =>
-  process.env.WEBHOOK_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'webhook-accounts.json');
-
 const str = (v: unknown): string | undefined =>
   typeof v === 'string' && v !== '' ? v : undefined;
 
@@ -32,7 +27,7 @@ function toEndpoint(raw: AccountRecord): Endpoint | null {
 }
 
 export function listEndpoints(): Endpoint[] {
-  const raw = readJson<AccountRecord[]>(accountsFile(), [], {
+  const raw = readJson<AccountRecord[]>(accountFilePath('webhook'), [], {
     warn: 'webhook-accounts.json: malformed, ignoring',
   });
   if (!Array.isArray(raw)) return [];

package/runtime/node_modules/@metro-labs/daemon/src/voice/call.ts

@@ -114,12 +114,8 @@ export class Call {
     else if (raw.kind === 'leave' && fromCaller) this.hangUp('the caller hung up');
   }
 
-  hangUp(reason: string): void {
-    this.end(reason);
-  }
-
   leave(reason: string): Promise<void> {
-    this.end(reason);
+    this.hangUp(reason);
     return this.left;
   }
 
@@ -149,7 +145,7 @@ export class Call {
     return this.deps.train('callSignal', { line: this.start.line, signal });
   }
 
-  private end(reason: string): void {
+  hangUp(reason: string): void {
     if (this.over) return;
     this.over = true;
     if (this.timer !== null) clearTimeout(this.timer);

package/runtime/node_modules/@metro-labs/daemon/src/voice/calls.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { errMsg, log } from '@metro-labs/core/log';
 import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
 import type { TrainEvent } from '@metro-labs/core/trains/protocol';
 import { agentIdForLine, allowlistForLine, lineReceives, mayApprove, senderPermitted } from '../agents/map.js';
 import { Call, trainCall, type CallStart } from './call.js';
@@ -22,10 +23,9 @@ const INVITES_MAX = 256;
 const makeCall: MakeCall = (start, cfg, onOver) => new Call(start, cfg, onOver);
 
 const record = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});
-const str = (value: unknown): string => (typeof value === 'string' ? value : '');
 
-const contentTypeOf = (env: TrainEvent): string => str(record(env.payload).contentType);
-const sourceIdOf = (env: TrainEvent): string => str(env.message_id) || str(env.id) || randomUUID();
+const contentTypeOf = (env: TrainEvent): string => stringOf(record(env.payload).contentType);
+const sourceIdOf = (env: TrainEvent): string => stringOf(env.message_id) || stringOf(env.id) || randomUUID();
 
 export const isCallEvent = (env: TrainEvent): boolean => CALL_TYPES.has(contentTypeOf(env));
 
@@ -46,16 +46,16 @@ function decline(line: string, callId: string): void {
 }
 
 function ringing(env: TrainEvent): boolean {
-  const sent = Date.parse(str(env.ts));
+  const sent = Date.parse(stringOf(env.ts));
   const age = Date.now() - sent;
   return Number.isFinite(age) && age >= -5_000 && age < RING_MS;
 }
 
 function invite(env: TrainEvent, body: Record<string, unknown>, create: MakeCall): void {
-  const line = str(env.line);
-  const from = str(env.from);
-  const callId = str(body.callId);
-  const callerPeer = str(body.from);
+  const line = stringOf(env.line);
+  const from = stringOf(env.from);
+  const callId = stringOf(body.callId);
+  const callerPeer = stringOf(body.from);
   const key = JSON.stringify([line, from, callId]);
   if (callId === '' || callerPeer === '' || invites.has(key)) return;
   if (!ringing(env)) {
@@ -85,16 +85,16 @@ function invite(env: TrainEvent, body: Record<string, unknown>, create: MakeCall
 
 function authenticated(env: TrainEvent): boolean {
   if (env.sender_verified === false || (env.station !== undefined && env.station !== 'xmtp')) return false;
-  const line = str(env.line);
+  const line = stringOf(env.line);
   const match = /^metro:\/\/xmtp\/([^/]+)\/[^/]+$/.exec(line);
-  return match !== null && str(env.from).startsWith(`metro://xmtp/${String(match[1])}/user/`) && str(env.from).split('/').length === 6;
+  return match !== null && stringOf(env.from).startsWith(`metro://xmtp/${String(match[1])}/user/`) && stringOf(env.from).split('/').length === 6;
 }
 
 export function onCallEvent(env: TrainEvent, train = 'xmtp', create: MakeCall = makeCall): void {
   if (train !== 'xmtp' || !authenticated(env)) return;
   const body = record(record(env.payload).call);
   if (contentTypeOf(env) === 'callInvite') invite(env, body, create);
-  else if (contentTypeOf(env) === 'callSignal' && current !== null && sameCaller(current, str(env.line), str(env.from)))
+  else if (contentTypeOf(env) === 'callSignal' && current !== null && sameCaller(current, stringOf(env.line), stringOf(env.from)))
     current.signalled(body);
 }
 
@@ -117,7 +117,7 @@ function leftoversOf(result: unknown): Leftover[] {
   const rows = isRecord(result) && Array.isArray(result.calls) ? result.calls : [];
   return rows
     .map((row) => record(row))
-    .map((row) => ({ line: str(row.line), callId: str(row.callId), peer: str(row.peer) }))
+    .map((row) => ({ line: stringOf(row.line), callId: stringOf(row.callId), peer: stringOf(row.peer) }))
     .filter((row) => row.line !== '' && row.callId !== '' && row.peer !== '');
 }
 

package/runtime/node_modules/@metro-labs/discord-bot/src/actions.ts

@@ -12,7 +12,7 @@ import {
   outgoingFiles,
   type OutgoingFile,
 } from './send-files.js';
-import { makeStation, respond, type CallMsg, type StationHandler } from '@metro-labs/core/stations/station-runtime';
+import { makeStation, respond, type StationHandler } from '@metro-labs/core/stations/station-runtime';
 import { readProfile, setProfile } from './profile.js';
 import { discordMembers } from './members.js';
 import { listChannels } from './channels.js';
@@ -28,30 +28,14 @@ async function sendMessage(
   body: Record<string, unknown>,
   files: OutgoingFile[],
 ): Promise<{ id: string; delivered: string[] }> {
-  if (files.length === 0) {
-    const plain = await rest<{ id: string }>(
-      accountId,
-      'POST',
-      `/channels/${channel}/messages`,
-      body,
-    );
-    return { id: plain.id, delivered: [] };
-  }
+  const path = `/channels/${channel}/messages`;
+  if (files.length === 0) return { id: (await rest<{ id: string }>(accountId, 'POST', path, body)).id, delivered: [] };
   const form = new FormData();
   form.append('payload_json', JSON.stringify(body));
   const delivered = await appendFiles(form, files);
-  const res = await rest<{ id: string }>(
-    accountId,
-    'POST',
-    `/channels/${channel}/messages`,
-    form,
-    true,
-  );
-  return { id: res.id, delivered };
+  return { id: (await rest<{ id: string }>(accountId, 'POST', path, form, true)).id, delivered };
 }
 
-export type { CallMsg };
-
 async function send(id: string, args: Record<string, unknown>): Promise<void> {
   const { line, text, replyTo, account } = args as {
     line: string;
@@ -198,9 +182,7 @@ async function listMembers(
 }
 
 const HANDLERS: Record<string, StationHandler> = {
-  accounts: (id) => {
-    listAccounts(id);
-  },
+  accounts: listAccounts,
   groupCreate: groupCreateHandler,
   groupAddMembers: groupAddHandler,
   groupRemoveMembers: groupRemoveHandler,

package/runtime/node_modules/@metro-labs/discord-bot/src/attachments.ts

@@ -1,10 +1,4 @@
-import {
-  saveBufferToCache,
-  assertContentLength,
-} from '@metro-labs/core/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
-
-export type { SavedAttachment };
+import { assertContentLength, saveBufferToCache, type SavedAttachment } from '@metro-labs/core/stations/attachments';
 
 export interface DiscordAttachmentRef {
   url: string;

package/runtime/node_modules/@metro-labs/discord-bot/src/channels.ts

@@ -4,6 +4,7 @@ import {
   type ChannelEntry,
   type ChannelSnapshot,
 } from '@metro-labs/core/stations/channel-directory';
+import { isRecord } from '@metro-labs/core/is-record';
 import { respond } from '@metro-labs/core/stations/station-runtime';
 import { TrainError } from '@metro-labs/core/train-error';
 import { ChannelType, PermissionFlagsBits } from 'discord.js';
@@ -42,8 +43,7 @@ function visible(channel: DiscordChannelMetadata): boolean {
 }
 
 function inaccessible(error: unknown): boolean {
-  return typeof error === 'object' && error !== null && 'status' in error &&
-    (error.status === 403 || error.status === 404);
+  return isRecord(error) && (error.status === 403 || error.status === 404);
 }
 
 class Snapshot {

package/runtime/node_modules/@metro-labs/discord-bot/src/group.ts

@@ -22,21 +22,18 @@ function membersOf(args: Record<string, unknown>): string[] {
   return raw.filter((v) => typeof v === 'string' && v.length > 0) as string[];
 }
 
-async function addThreadMembers(
+async function threadMembers(
   rest: RestFn,
   accountId: string,
   threadId: string,
-  members: string[],
+  args: Record<string, unknown>,
+  method: 'PUT' | 'DELETE',
 ): Promise<MemberOutcome[]> {
   const outcomes: MemberOutcome[] = [];
-  for (const userId of members) {
+  for (const userId of membersOf(args)) {
     try {
-      await rest(
-        accountId,
-        'PUT',
-        `/channels/${threadId}/thread-members/${userId}`,
-      );
-      outcomes.push({ id: userId, status: 'added' });
+      await rest(accountId, method, `/channels/${threadId}/thread-members/${userId}`);
+      outcomes.push({ id: userId, status: method === 'PUT' ? 'added' : 'removed' });
     } catch (e) {
       outcomes.push({ id: userId, status: 'failed', reason: errMsg(e) });
     }
@@ -60,12 +57,7 @@ export async function groupCreate(
     `/channels/${parentChannelId}/threads`,
     { name, type, auto_archive_duration: AUTO_ARCHIVE },
   );
-  const members = await addThreadMembers(
-    rest,
-    accountId,
-    thread.id,
-    membersOf(args),
-  );
+  const members = await threadMembers(rest, accountId, thread.id, args, 'PUT');
   return {
     capability: { supported: true },
     line: lineOf(accountId, thread.id),
@@ -82,12 +74,7 @@ export async function groupAddMembers(
   line: string,
   args: Record<string, unknown>,
 ): Promise<GroupResult> {
-  const members = await addThreadMembers(
-    rest,
-    accountId,
-    threadId,
-    membersOf(args),
-  );
+  const members = await threadMembers(rest, accountId, threadId, args, 'PUT');
   return { capability: { supported: true }, line, id: threadId, members };
 }
 
@@ -98,18 +85,6 @@ export async function groupRemoveMembers(
   line: string,
   args: Record<string, unknown>,
 ): Promise<GroupResult> {
-  const outcomes: MemberOutcome[] = [];
-  for (const userId of membersOf(args)) {
-    try {
-      await rest(
-        accountId,
-        'DELETE',
-        `/channels/${threadId}/thread-members/${userId}`,
-      );
-      outcomes.push({ id: userId, status: 'removed' });
-    } catch (e) {
-      outcomes.push({ id: userId, status: 'failed', reason: errMsg(e) });
-    }
-  }
-  return { capability: { supported: true }, line, id: threadId, members: outcomes };
+  const members = await threadMembers(rest, accountId, threadId, args, 'DELETE');
+  return { capability: { supported: true }, line, id: threadId, members };
 }

package/runtime/node_modules/@metro-labs/discord-bot/src/index.ts

@@ -70,7 +70,7 @@ async function bootAccount(cfg: AccountConfig): Promise<void> {
   });
 
   client.on(Events.MessageReactionAdd, (r, u) => {
-    void (async () => {
+    (async () => {
       try {
         if (r.partial) await r.fetch();
         if (u.partial) await u.fetch();
@@ -85,18 +85,12 @@ async function bootAccount(cfg: AccountConfig): Promise<void> {
     });
   });
 
-  client.on(Events.MessageUpdate, (_old, _new) => {
-    void (async () => {
-      try {
-        onEdit(accountId, _new.partial ? await _new.fetch() : _new);
-      } catch (err) {
-        process.stderr.write(
-          `discord-bot[${accountId}] message update fetch failed: ${errMsg(err)}\n`,
-        );
-      }
+  client.on(Events.MessageUpdate, (_old, updated) => {
+    (async () => {
+      onEdit(accountId, updated.partial ? await updated.fetch() : updated);
     })().catch((err: unknown) => {
       process.stderr.write(
-        `discord-bot[${accountId}] message update handler failed: ${errMsg(err)}\n`,
+        `discord-bot[${accountId}] message update fetch failed: ${errMsg(err)}\n`,
       );
     });
   });

package/runtime/node_modules/@metro-labs/discord-bot/src/members.ts

@@ -97,38 +97,6 @@ export function mapRecipients(users: DiscordUser[]): MetroMember[] {
     });
 }
 
-async function fetchRoles(
-  accountId: string,
-  guildId: string,
-): Promise<Map<string, RoleInfo>> {
-  try {
-    const roles = await rest<DiscordRole[]>(
-      accountId,
-      'GET',
-      `/guilds/${guildId}/roles`,
-    );
-    return indexRoles(roles);
-  } catch {
-    return new Map();
-  }
-}
-
-async function fetchOwnerId(
-  accountId: string,
-  guildId: string,
-): Promise<string | undefined> {
-  try {
-    const g = await rest<{ owner_id?: string }>(
-      accountId,
-      'GET',
-      `/guilds/${guildId}`,
-    );
-    return g.owner_id;
-  } catch {
-    return undefined;
-  }
-}
-
 interface Collected {
   raw: DiscordGuildMember[];
   exhausted: boolean;
@@ -168,8 +136,12 @@ export async function listGuildMembers(
   limit?: number,
 ): Promise<MemberList> {
   const cap = Math.min(Math.max(1, limit ?? PAGE), 10_000);
-  const roles = await fetchRoles(accountId, guildId);
-  const ownerId = await fetchOwnerId(accountId, guildId);
+  const roles = await rest<DiscordRole[]>(accountId, 'GET', `/guilds/${guildId}/roles`)
+    .then(indexRoles)
+    .catch(() => new Map<string, RoleInfo>());
+  const ownerId = await rest<{ owner_id?: string }>(accountId, 'GET', `/guilds/${guildId}`)
+    .then((g) => g.owner_id)
+    .catch(() => undefined);
   try {
     const { raw, exhausted } = await paginate(accountId, guildId, cap);
     const members = mapGuildMembers(raw, roles, ownerId);

package/runtime/node_modules/@metro-labs/discord-bot/src/profile.ts

@@ -9,7 +9,7 @@ import {
   type ProfileChange,
 } from '@metro-labs/core/stations/profile';
 import type { SenderProfile } from '@metro-labs/core/stations/sender-profile';
-import { accountFor, accounts } from './accounts.js';
+import { accountFor, accounts, type Account } from './accounts.js';
 import { respond } from '@metro-labs/core/stations/station-runtime';
 
 export async function applyProfile(
@@ -32,29 +32,26 @@ export async function applyProfile(
   }
 }
 
+function accountOf(args: Record<string, unknown>): Account {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const acct = accounts.get(accountId);
+  if (!acct) throw new Error(`unknown account '${accountId}'`);
+  return acct;
+}
+
 export async function setProfile(
   id: string,
   args: Record<string, unknown>,
 ): Promise<void> {
-  const accountId = accountFor({ account: args.account as string | undefined });
-  const acct = accounts.get(accountId);
-  if (!acct) {
-    respond(id, { error: `unknown account '${accountId}'` });
-    return;
-  }
+  const acct = accountOf(args);
   const change = parseProfileChange(args);
   await applyProfile(acct.client, change);
-  const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
+  const result: ProfileApplied = { account: acct.cfg.id, applied: fieldsOf(change) };
   respond(id, { result });
 }
 
 export async function readProfile(id: string, args: Record<string, unknown>): Promise<void> {
-  const accountId = accountFor({ account: args.account as string | undefined });
-  const acct = accounts.get(accountId);
-  if (!acct) {
-    respond(id, { error: `unknown account '${accountId}'` });
-    return;
-  }
+  const acct = accountOf(args);
   const user = typeof args.user === 'string' ? args.user.trim() : '';
   if (!/^\d+$/.test(user)) throw new TrainError('discord_user_required', 'profile needs the Discord id of the person', { retryable: false });
   const found = await acct.client.users.fetch(user);

package/runtime/node_modules/@metro-labs/discord-bot/src/send-files.ts

@@ -32,9 +32,7 @@ export async function appendFiles(
   files: OutgoingFile[],
 ): Promise<string[]> {
   const delivered: string[] = [];
-  for (let i = 0; i < files.length; i++) {
-    const file = files[i];
-    if (!file) continue;
+  for (const [i, file] of files.entries()) {
     await appendFile(form, `files[${i}]`, file.path, file.name);
     delivered.push(file.kind);
   }

package/runtime/node_modules/@metro-labs/discord-bot/src/verify.ts

@@ -1,3 +1,4 @@
+import { isRecord } from '@metro-labs/core/is-record';
 import { API } from './api-base.js';
 
 export class DiscordTokenError extends Error {}
@@ -25,9 +26,7 @@ function botFetch(token: string, path: string): Promise<Response> {
 async function readJson(res: Response): Promise<Record<string, unknown>> {
   try {
     const body: unknown = await res.json();
-    return typeof body === 'object' && body !== null
-      ? (body as Record<string, unknown>)
-      : {};
+    return isRecord(body) ? body : {};
   } catch {
     throw new DiscordTokenError('Discord returned a response Metro could not read');
   }