@stage-labs/metro 0.1.0-beta.3 → 0.1.0-beta.300

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

@@ -0,0 +1,121 @@
+import { errMsg } from '@metro-labs/core/log';
+import {
+  Client,
+  Events,
+  GatewayIntentBits,
+  Partials,
+  type Message,
+  type MessageReaction,
+  type User,
+} from 'discord.js';
+import {
+  accounts,
+  loadAccounts,
+  lineOf,
+  type AccountConfig,
+} from './accounts.js';
+import { emitInbound } from '@metro-labs/core/stations/train-events';
+import { messageEnvelope, reactionEnvelope } from './format.js';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
+import { readCalls } from '@metro-labs/core/trains/protocol';
+import { announceAccounts } from '@metro-labs/core/stations/train-boot';
+import { handleCall } from './actions.js';
+
+readCalls('discord-bot', handleCall);
+
+function makeClient(): Client {
+  return new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.GuildMessageReactions,
+      GatewayIntentBits.DirectMessages,
+      GatewayIntentBits.DirectMessageReactions,
+    ],
+    partials: [
+      Partials.Channel,
+      Partials.Message,
+      Partials.Reaction,
+      Partials.User,
+    ],
+  });
+}
+
+function onEdit(accountId: string, m: Message): void {
+  if (m.author.bot) return;
+  emitInbound(accountId, {
+    id: mintId(),
+    ts: new Date(m.editedTimestamp ?? Date.now()).toISOString(),
+    station: 'discord-bot',
+    line: lineOf(accountId, m.channelId),
+    from: `metro://discord-bot/${accountId}/user/${m.author.id}`,
+    from_name: m.author.username,
+    from_display_name: m.author.globalName ?? undefined,
+    message_id: m.id,
+    text: m.content,
+    is_private: m.guildId == null,
+    event: { type: 'edit', targetId: m.id },
+    payload: m.toJSON(),
+  });
+}
+
+async function bootAccount(cfg: AccountConfig): Promise<void> {
+  const client = makeClient();
+  const accountId = cfg.id;
+
+  client.on(Events.MessageCreate, (m) => {
+    const env = messageEnvelope(accountId, m);
+    if (env) emitInbound(accountId, env);
+  });
+
+  client.on(Events.MessageReactionAdd, (r, u) => {
+    void (async () => {
+      try {
+        if (r.partial) await r.fetch();
+        if (u.partial) await u.fetch();
+      } catch {
+      }
+      const env = reactionEnvelope(accountId, r as MessageReaction, u as User);
+      if (env) emitInbound(accountId, env);
+    })().catch((err: unknown) => {
+      process.stderr.write(
+        `discord-bot[${accountId}] reaction handler failed: ${errMsg(err)}\n`,
+      );
+    });
+  });
+
+  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`,
+        );
+      }
+    })().catch((err: unknown) => {
+      process.stderr.write(
+        `discord-bot[${accountId}] message update handler failed: ${errMsg(err)}\n`,
+      );
+    });
+  });
+
+  accounts.set(accountId, { cfg, client });
+  await client.login(cfg.token);
+  process.stderr.write(
+    `discord-bot[${accountId}] ready — ${client.user?.tag ?? '?'}\n`,
+  );
+}
+
+const cfgs = loadAccounts();
+for (const cfg of cfgs) {
+  try {
+    await bootAccount(cfg);
+  } catch (err) {
+    process.stderr.write(
+      `discord-bot[${cfg.id}] boot FAILED: ${errMsg(err)}\n`,
+    );
+  }
+}
+announceAccounts('discord-bot', accounts.keys());

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

@@ -0,0 +1,215 @@
+import { errMsg } from '@metro-labs/core/log';
+import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
+import { rest } from './accounts.js';
+
+export interface DiscordRole {
+  id: string;
+  name: string;
+  permissions: string;
+}
+
+export interface DiscordUser {
+  id: string;
+  username?: string;
+  global_name?: string | null;
+  bot?: boolean;
+}
+
+export interface DiscordGuildMember {
+  user?: DiscordUser;
+  nick?: string | null;
+  roles?: string[];
+}
+
+const ADMINISTRATOR = 1n << 3n;
+const PAGE = 1000;
+
+export interface RoleInfo {
+  name: string;
+  admin: boolean;
+}
+
+function roleIsAdmin(permissions: string): boolean {
+  try {
+    return (BigInt(permissions) & ADMINISTRATOR) === ADMINISTRATOR;
+  } catch {
+    return false;
+  }
+}
+
+export function indexRoles(roles: DiscordRole[]): Map<string, RoleInfo> {
+  const out = new Map<string, RoleInfo>();
+  for (const r of roles)
+    out.set(r.id, { name: r.name, admin: roleIsAdmin(r.permissions) });
+  return out;
+}
+
+function isAdmin(
+  userId: string,
+  roleIds: string[],
+  roles: Map<string, RoleInfo>,
+  ownerId?: string,
+): boolean {
+  if (ownerId !== undefined && userId === ownerId) return true;
+  return roleIds.some((id) => roles.get(id)?.admin === true);
+}
+
+export function mapGuildMember(
+  m: DiscordGuildMember,
+  roles: Map<string, RoleInfo>,
+  ownerId?: string,
+): MetroMember | null {
+  const user = m.user;
+  if (!user?.id) return null;
+  const member: MetroMember = { id: user.id };
+  if (user.username) member.name = user.username;
+  const display = m.nick ?? user.global_name ?? undefined;
+  if (display) member.display_name = display;
+  const roleIds = m.roles ?? [];
+  const roleNames = roleIds
+    .map((id) => roles.get(id)?.name)
+    .filter((n): n is string => Boolean(n));
+  if (roleNames.length) member.roles = roleNames;
+  member.is_admin = isAdmin(user.id, roleIds, roles, ownerId);
+  member.is_bot = Boolean(user.bot);
+  return member;
+}
+
+export function mapGuildMembers(
+  members: DiscordGuildMember[],
+  roles: Map<string, RoleInfo>,
+  ownerId?: string,
+): MetroMember[] {
+  return members
+    .map((m) => mapGuildMember(m, roles, ownerId))
+    .filter((x): x is MetroMember => x !== null);
+}
+
+export function mapRecipients(users: DiscordUser[]): MetroMember[] {
+  return users
+    .filter((u) => Boolean(u?.id))
+    .map((u) => {
+      const m: MetroMember = { id: u.id };
+      if (u.username) m.name = u.username;
+      if (u.global_name) m.display_name = u.global_name;
+      m.is_bot = Boolean(u.bot);
+      return m;
+    });
+}
+
+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;
+}
+
+async function paginate(
+  accountId: string,
+  guildId: string,
+  cap: number,
+): Promise<Collected> {
+  const raw: DiscordGuildMember[] = [];
+  let after: string | undefined;
+  for (;;) {
+    const want = Math.min(PAGE, cap - raw.length);
+    if (want <= 0) return { raw, exhausted: false };
+    const qs = new URLSearchParams({ limit: String(want) });
+    if (after) qs.set('after', after);
+    const page = await rest<DiscordGuildMember[]>(
+      accountId,
+      'GET',
+      `/guilds/${guildId}/members?${qs}`,
+    );
+    raw.push(...page);
+    if (page.length < want) return { raw, exhausted: true };
+    after = page[page.length - 1]?.user?.id;
+    if (!after) return { raw, exhausted: true };
+  }
+}
+
+const INTENT_HINT =
+  'Discord bot lacks the privileged GUILD_MEMBERS intent (enable it in the ' +
+  'Developer Portal) or channel access; returning what is reachable.';
+
+export async function listGuildMembers(
+  accountId: string,
+  guildId: string,
+  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);
+  try {
+    const { raw, exhausted } = await paginate(accountId, guildId, cap);
+    const members = mapGuildMembers(raw, roles, ownerId);
+    return {
+      members,
+      capability: exhausted
+        ? { supported: true, complete: true, total: members.length }
+        : {
+            supported: true,
+            complete: false,
+            reason: `truncated at limit ${cap}`,
+          },
+    };
+  } catch (e) {
+    const msg = errMsg(e);
+    if (/\b40[13]\b/.test(msg))
+      return {
+        members: [],
+        capability: { supported: false, complete: false, reason: INTENT_HINT },
+      };
+    throw e;
+  }
+}
+
+export async function discordMembers(
+  accountId: string,
+  channelId: string,
+  limit?: number,
+): Promise<MemberList> {
+  const chan = await rest<{ guild_id?: string; recipients?: DiscordUser[] }>(
+    accountId,
+    'GET',
+    `/channels/${channelId}`,
+  );
+  if (!chan.guild_id) {
+    const members = mapRecipients(chan.recipients ?? []);
+    return {
+      members,
+      capability: { supported: true, complete: true, total: members.length },
+    };
+  }
+  return listGuildMembers(accountId, chan.guild_id, limit);
+}

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

@@ -0,0 +1,68 @@
+import { readFile } from 'node:fs/promises';
+import type { Client } from 'discord.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import {
+  assertImage,
+  fieldsOf,
+  parseProfileChange,
+  type ProfileApplied,
+  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 { respond } from '@metro-labs/core/stations/station-runtime';
+
+export async function applyProfile(
+  client: Client,
+  change: ProfileChange,
+): Promise<void> {
+  const user = client.user;
+  if (!user) throw new TrainError('discord_not_ready', 'the gateway is not ready yet');
+  if (change.avatar !== undefined) assertImage(change.avatar);
+  const avatar = change.avatar === undefined ? undefined : await readFile(change.avatar.path);
+  if (change.name !== undefined || avatar !== undefined)
+    await user.edit({
+      ...(change.name === undefined ? {} : { username: change.name }),
+      ...(avatar === undefined ? {} : { avatar }),
+    });
+  if (change.bio !== undefined) {
+    const app = client.application;
+    if (!app) throw new TrainError('discord_not_ready', 'the application is not loaded yet');
+    await app.edit({ description: change.bio });
+  }
+}
+
+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 change = parseProfileChange(args);
+  await applyProfile(acct.client, change);
+  const result: ProfileApplied = { account: accountId, 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 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);
+  const result: SenderProfile = {
+    id: user,
+    name: found.username,
+    ...(found.globalName === null ? {} : { display_name: found.globalName }),
+    avatar: found.displayAvatarURL({ size: 256 }),
+  };
+  respond(id, { result });
+}

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

@@ -0,0 +1,42 @@
+import { appendFile } from '@metro-labs/core/stations/attachments';
+import type { CanonicalAttachment } from '@metro-labs/core/stations/types';
+
+export interface OutgoingFile {
+  path: string;
+  name: string;
+  kind: string;
+}
+
+type WireAttachment = CanonicalAttachment & { kind?: string };
+
+const basenameOf = (path: string, index: number): string =>
+  path.split('/').pop() ?? `file-${index}`;
+
+export function outgoingFiles(attachments: unknown): OutgoingFile[] {
+  if (!Array.isArray(attachments)) return [];
+  const out: OutgoingFile[] = [];
+  (attachments as WireAttachment[]).forEach((a, i) => {
+    const path = a.path;
+    if (path === undefined || path === '') return;
+    out.push({
+      path,
+      name: a.name !== undefined && a.name !== '' ? a.name : basenameOf(path, i),
+      kind: a.kind ?? 'file',
+    });
+  });
+  return out;
+}
+
+export async function appendFiles(
+  form: FormData,
+  files: OutgoingFile[],
+): Promise<string[]> {
+  const delivered: string[] = [];
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    if (!file) continue;
+    await appendFile(form, `files[${i}]`, file.path, file.name);
+    delivered.push(file.kind);
+  }
+  return delivered;
+}

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

@@ -0,0 +1,24 @@
+import type { GroupOp, Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
+
+export const discordBotStation: Station = {
+  name: 'discord-bot',
+  hasAccounts: true,
+  hasTrain: true,
+  messageVerbs: new Set<Verb>([
+    'send',
+    'reply',
+    'react',
+    'unreact',
+    'edit',
+    'delete',
+    'read',
+    'typing',
+  ]),
+  groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
+  attachmentMode: 'canonical',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
+  discoversChannels: true,
+  tools: [],
+};

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

@@ -0,0 +1,82 @@
+import { API } from './api-base.js';
+
+export class DiscordTokenError extends Error {}
+
+export interface DiscordBotIdentity {
+  userId: string;
+  username: string;
+  messageContent: boolean;
+}
+
+const MESSAGE_CONTENT = 1 << 18;
+const MESSAGE_CONTENT_LIMITED = 1 << 19;
+const TIMEOUT_MS = 10_000;
+
+function botFetch(token: string, path: string): Promise<Response> {
+  return fetch(`${API}${path}`, {
+    headers: {
+      authorization: `Bot ${token}`,
+      'user-agent': 'metro-daemon (https://github.com/bonustrack/metro)',
+    },
+    signal: AbortSignal.timeout(TIMEOUT_MS),
+  });
+}
+
+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>)
+      : {};
+  } catch {
+    throw new DiscordTokenError('Discord returned a response Metro could not read');
+  }
+}
+
+async function selfUser(token: string): Promise<Record<string, unknown>> {
+  let res: Response;
+  try {
+    res = await botFetch(token, '/users/@me');
+  } catch {
+    throw new DiscordTokenError(
+      'could not reach the Discord API to check that bot token',
+    );
+  }
+  if (res.status === 401 || res.status === 403)
+    throw new DiscordTokenError('Discord rejected that bot token');
+  if (!res.ok)
+    throw new DiscordTokenError(
+      `Discord answered ${res.status} while checking that bot token`,
+    );
+  return readJson(res);
+}
+
+async function messageContentEnabled(token: string): Promise<boolean> {
+  try {
+    const res = await botFetch(token, '/applications/@me');
+    if (!res.ok) return true;
+    const flags = (await readJson(res)).flags;
+    if (typeof flags !== 'number') return true;
+    return (flags & (MESSAGE_CONTENT | MESSAGE_CONTENT_LIMITED)) !== 0;
+  } catch {
+    return true;
+  }
+}
+
+export async function verifyDiscordBotToken(
+  token: string,
+): Promise<DiscordBotIdentity> {
+  const me = await selfUser(token);
+  const userId = typeof me.id === 'string' ? me.id : '';
+  if (userId === '')
+    throw new DiscordTokenError('Discord returned no bot identity for that token');
+  if (me.bot !== true)
+    throw new DiscordTokenError(
+      'that token belongs to a Discord user, not a bot application',
+    );
+  return {
+    userId,
+    username: typeof me.username === 'string' ? me.username : '',
+    messageContent: await messageContentEnabled(token),
+  };
+}

package/runtime/node_modules/@metro-labs/gmail/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@metro-labs/gmail",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/station.ts",
+    "./train": "./src/index.ts",
+    "./login": "./src/login.ts",
+    "./managed": "./src/managed.ts",
+    "./managed-binding": "./src/managed-binding.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && bun test test/"
+  },
+  "dependencies": {
+    "@metro-labs/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.3",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}