@stage-labs/metro 0.1.0-beta.2 → 0.1.0-beta.200

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

@@ -0,0 +1,174 @@
+import { MessageFlags, type Message, type MessageReaction, type User } from 'discord.js';
+import { reportAttachment, selfUri } from '@metro-labs/core/stations/train-events';
+import { accounts, lineOf } from './accounts.js';
+import { emit, mintId } from './wire.js';
+import { saveDiscordAttachment } from './attachments.js';
+
+const AV_TAG: Record<string, string> = { audio: 'audio', video: 'video' };
+
+function tagFor(att: {
+  contentType?: string | null;
+  name?: string | null;
+  voice?: boolean;
+}): string {
+  const type = (att.contentType ?? '').split('/')[0] ?? '';
+  if (type === 'image') return '[image]';
+  if (att.voice && type === 'audio') return '[voice]';
+  const kind = AV_TAG[type] ?? 'file';
+  return `[${kind}: ${att.name ?? kind}]`;
+}
+
+function addressing(accountId: string, m: Message): { mentions_self: boolean; reply_to_self: boolean } {
+  const me = accounts.get(accountId)?.client.user ?? null;
+  if (me === null) return { mentions_self: false, reply_to_self: false };
+  return {
+    mentions_self: m.mentions.has(me, { ignoreRepliedUser: true, ignoreEveryone: true }),
+    reply_to_self: m.mentions.repliedUser?.id === me.id,
+  };
+}
+
+const senderOf = (m: Message): Record<string, string | undefined> => ({
+  from_name: m.author.username,
+  from_display_name: m.member?.displayName ?? m.author.globalName ?? undefined,
+});
+
+export function messageEnvelope(
+  accountId: string,
+  m: Message,
+): Record<string, unknown> | null {
+  if (m.author.bot) return null;
+  const voice = m.flags.has(MessageFlags.IsVoiceMessage);
+  const tags = m.attachments.map((a) =>
+    tagFor({ contentType: a.contentType, name: a.name, voice }),
+  );
+  const stickerTags = m.stickers.map((s) => `[sticker: ${s.name}]`);
+  const text = [m.content.trim(), ...tags, ...stickerTags]
+    .filter(Boolean)
+    .join(' ');
+  const line = lineOf(accountId, m.channelId);
+  const envId = mintId();
+  const attachments = [...m.attachments.values()].map((a) => ({
+    id: a.id,
+    url: a.url,
+    proxyURL: a.proxyURL,
+    name: a.name,
+    contentType: a.contentType,
+    size: a.size,
+  }));
+  attachments.forEach((a, i) => {
+    reportAttachment(
+      saveDiscordAttachment({ url: a.url, name: a.name, contentType: a.contentType }, m.id, i),
+      { station: 'discord-bot', account: accountId, line, forId: envId, index: i },
+      { failed: { name: a.name, mime: a.contentType ?? undefined } },
+    );
+  });
+  return {
+    kind: 'inbound',
+    id: envId,
+    ts: new Date(m.createdTimestamp).toISOString(),
+    station: 'discord-bot',
+    line,
+    line_name: 'name' in m.channel ? m.channel.name : undefined,
+    from: `metro://discord-bot/${accountId}/user/${m.author.id}`,
+    ...senderOf(m),
+    message_id: m.id,
+    text,
+    is_private: m.guildId == null,
+    reply_to: m.reference?.messageId ?? undefined,
+    ...addressing(accountId, m),
+    ...(m.reference?.messageId
+      ? { event: { type: 'reply', replyTo: m.reference.messageId } }
+      : {}),
+    payload: { ...(m.toJSON() as Record<string, unknown>), attachments },
+  };
+}
+
+export function reactionEnvelope(
+  accountId: string,
+  r: MessageReaction,
+  u: User,
+): Record<string, unknown> | null {
+  if (u.bot) return null;
+  return {
+    kind: 'react',
+    id: mintId(),
+    ts: new Date().toISOString(),
+    station: 'discord-bot',
+    line: lineOf(accountId, r.message.channelId),
+    from: `metro://discord-bot/${accountId}/user/${u.id}`,
+    from_name: u.username,
+    from_display_name: u.globalName ?? undefined,
+    message_id: r.message.id,
+    emoji: r.emoji.name ?? r.emoji.id ?? '?',
+    is_private: r.message.guildId == null,
+    event: {
+      type: 'react',
+      emoji: r.emoji.name ?? r.emoji.id ?? '?',
+      targetId: r.message.id,
+    },
+    payload: {
+      channel_id: r.message.channelId,
+      guild_id: r.message.guildId,
+      emoji: r.emoji.toJSON(),
+      user_id: u.id,
+    },
+  };
+}
+
+function outbound(
+  kind: string,
+  accountId: string,
+  line: string,
+  messageId: string,
+  extra: object,
+): void {
+  emit({
+    kind,
+    id: mintId(),
+    ts: new Date().toISOString(),
+    station: 'discord-bot',
+    line,
+    from: selfUri('discord-bot', accountId),
+    to: line,
+    message_id: messageId,
+    ...extra,
+    account: accountId,
+    payload: { account: accountId },
+  });
+}
+
+export function emitOutbound(
+  accountId: string,
+  line: string,
+  messageId: string,
+  text: string,
+  replyTo?: string,
+): void {
+  outbound('outbound', accountId, line, messageId, {
+    text,
+    reply_to: replyTo,
+    ...(replyTo ? { event: { type: 'reply', replyTo } } : {}),
+  });
+}
+export function emitOutboundReact(
+  accountId: string,
+  line: string,
+  messageId: string,
+  emoji: string,
+): void {
+  outbound('react', accountId, line, messageId, {
+    emoji,
+    event: { type: 'react', emoji, targetId: messageId },
+  });
+}
+export function emitOutboundEdit(
+  accountId: string,
+  line: string,
+  messageId: string,
+  text: string,
+): void {
+  outbound('edit', accountId, line, messageId, {
+    text,
+    event: { type: 'edit', targetId: messageId },
+  });
+}

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

@@ -0,0 +1,50 @@
+import { routeOf, rest } from './accounts.js';
+import { respond } from './wire.js';
+import {
+  groupAddMembers,
+  groupCreate,
+  groupRemoveMembers,
+} from './group.js';
+
+export async function groupCreateHandler(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { parent, account } = args as { parent?: string; account?: string };
+  if (!parent) {
+    respond(id, {
+      result: {
+        capability: {
+          supported: false,
+          reason:
+            'discord-bot create_group requires `parent` (the metro:// line of the channel to open the thread under)',
+        },
+      },
+    });
+    return;
+  }
+  const { accountId, channelId } = routeOf(parent, account);
+  respond(id, { result: await groupCreate(rest, accountId, channelId, args) });
+}
+
+export async function groupAddHandler(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, channelId } = routeOf(line, account);
+  respond(id, {
+    result: await groupAddMembers(rest, accountId, channelId, line, args),
+  });
+}
+
+export async function groupRemoveHandler(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, channelId } = routeOf(line, account);
+  respond(id, {
+    result: await groupRemoveMembers(rest, accountId, channelId, line, args),
+  });
+}

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

@@ -0,0 +1,115 @@
+import { errMsg } from '@metro-labs/core/log';
+import type {
+  GroupResult,
+  MemberOutcome,
+} from '@metro-labs/core/stations/types';
+import { lineOf } from './accounts.js';
+
+export type RestFn = <T = unknown>(
+  accountId: string,
+  method: string,
+  path: string,
+  body?: unknown,
+) => Promise<T>;
+
+const PUBLIC_THREAD = 11;
+const PRIVATE_THREAD = 12;
+const AUTO_ARCHIVE = 1440;
+
+function membersOf(args: Record<string, unknown>): string[] {
+  const raw = args.members;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((v) => typeof v === 'string' && v.length > 0) as string[];
+}
+
+async function addThreadMembers(
+  rest: RestFn,
+  accountId: string,
+  threadId: string,
+  members: string[],
+): Promise<MemberOutcome[]> {
+  const outcomes: MemberOutcome[] = [];
+  for (const userId of members) {
+    try {
+      await rest(
+        accountId,
+        'PUT',
+        `/channels/${threadId}/thread-members/${userId}`,
+      );
+      outcomes.push({ id: userId, status: 'added' });
+    } catch (e) {
+      outcomes.push({ id: userId, status: 'failed', reason: errMsg(e) });
+    }
+  }
+  return outcomes;
+}
+
+export async function groupCreate(
+  rest: RestFn,
+  accountId: string,
+  parentChannelId: string,
+  args: Record<string, unknown>,
+): Promise<GroupResult> {
+  const name = typeof args.name === 'string' ? args.name : '';
+  if (!name)
+    return { capability: { supported: false, reason: 'create_group requires a `name`' } };
+  const type = args.private === true ? PRIVATE_THREAD : PUBLIC_THREAD;
+  const thread = await rest<{ id: string }>(
+    accountId,
+    'POST',
+    `/channels/${parentChannelId}/threads`,
+    { name, type, auto_archive_duration: AUTO_ARCHIVE },
+  );
+  const members = await addThreadMembers(
+    rest,
+    accountId,
+    thread.id,
+    membersOf(args),
+  );
+  return {
+    capability: { supported: true },
+    line: lineOf(accountId, thread.id),
+    id: thread.id,
+    name,
+    members,
+  };
+}
+
+export async function groupAddMembers(
+  rest: RestFn,
+  accountId: string,
+  threadId: string,
+  line: string,
+  args: Record<string, unknown>,
+): Promise<GroupResult> {
+  const members = await addThreadMembers(
+    rest,
+    accountId,
+    threadId,
+    membersOf(args),
+  );
+  return { capability: { supported: true }, line, id: threadId, members };
+}
+
+export async function groupRemoveMembers(
+  rest: RestFn,
+  accountId: string,
+  threadId: string,
+  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 };
+}

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

@@ -0,0 +1,122 @@
+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 './wire.js';
+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, {
+    kind: 'edit',
+    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);
+}