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

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

@@ -0,0 +1,79 @@
+import {
+  ChannelType,
+  type Client,
+  type Guild,
+  type GuildBasedChannel,
+  type GuildMember,
+  type PermissionsBitField,
+} from 'discord.js';
+
+export interface DiscordChannelMetadata {
+  id: string;
+  name?: string;
+  type: ChannelType;
+  permissions?: Readonly<PermissionsBitField> | null;
+  joined?: boolean;
+  archived?: boolean | null;
+}
+
+export interface DiscordGuildSource {
+  channels(): Promise<Iterable<DiscordChannelMetadata>>;
+  threads(): Promise<Iterable<DiscordChannelMetadata>>;
+}
+
+export interface DiscordChannelSource {
+  guilds(after: string | undefined, limit: number): Promise<string[]>;
+  guild(id: string): Promise<DiscordGuildSource>;
+  directs(): Iterable<DiscordChannelMetadata>;
+}
+
+function* guildMetadata(
+  channels: Iterable<GuildBasedChannel | null>,
+  me: GuildMember,
+): Iterable<DiscordChannelMetadata> {
+  for (const channel of channels) {
+    if (!channel) continue;
+    yield {
+      id: channel.id,
+      name: channel.name,
+      type: channel.type,
+      permissions: channel.permissionsFor(me),
+      ...(channel.isThread() ? { joined: channel.joined, archived: channel.archived } : {}),
+    };
+  }
+}
+
+function guildSource(guild: Guild, me: GuildMember): DiscordGuildSource {
+  return {
+    async channels() {
+      return guildMetadata((await guild.channels.fetch()).values(), me);
+    },
+    async threads() {
+      const result = await guild.channels.fetchActiveThreads(false);
+      return guildMetadata(result.threads.values(), me);
+    },
+  };
+}
+
+export function discordChannelSource(client: Client): DiscordChannelSource {
+  return {
+    async guilds(after, limit) {
+      return [...(await client.guilds.fetch({ after, limit })).keys()];
+    },
+    async guild(id) {
+      const guild = await client.guilds.fetch({ guild: id, force: true, withCounts: false });
+      const me = await guild.members.fetchMe({ force: true });
+      return guildSource(guild, me);
+    },
+    *directs() {
+      for (const channel of client.channels.cache.values()) {
+        if (channel.type !== ChannelType.DM && channel.type !== ChannelType.GroupDM) continue;
+        yield {
+          id: channel.id,
+          type: channel.type,
+          ...('name' in channel && channel.name ? { name: channel.name } : {}),
+        };
+      }
+    },
+  };
+}

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

@@ -0,0 +1,186 @@
+import {
+  ChannelDirectory,
+  DIRECTORY_LIMIT,
+  type ChannelEntry,
+  type ChannelSnapshot,
+} from '@metro-labs/core/stations/channel-directory';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { ChannelType, PermissionFlagsBits } from 'discord.js';
+import { accounts, lineOf, type Account } from './accounts.js';
+import {
+  discordChannelSource,
+  type DiscordChannelMetadata,
+  type DiscordChannelSource,
+  type DiscordGuildSource,
+} from './channel-source.js';
+
+const directories = new WeakMap<Account, ChannelDirectory>();
+const GUILD_PAGE = 20;
+const REQUEST_LIMIT = 100;
+const SCAN_MS = 30_000;
+const LIMIT_REASON = `Discovery stopped at the ${DIRECTORY_LIMIT} metadata scan limit; results are partial.`;
+const THREAD_REASON = 'Archived and inaccessible threads are omitted; only accessible active threads are listed.';
+const DM_REASON = 'DMs are limited to channels already cached by this bot; Discord has no complete bot DM directory.';
+
+function kindOf(type: ChannelType): ChannelEntry['kind'] | undefined {
+  switch (type) {
+    case ChannelType.DM: return 'direct';
+    case ChannelType.GroupDM: return 'group';
+    case ChannelType.AnnouncementThread:
+    case ChannelType.PublicThread:
+    case ChannelType.PrivateThread: return 'thread';
+    case ChannelType.GuildCategory: return undefined;
+    default: return 'channel';
+  }
+}
+
+function visible(channel: DiscordChannelMetadata): boolean {
+  if (!channel.permissions?.has(PermissionFlagsBits.ViewChannel)) return false;
+  return channel.type !== ChannelType.PrivateThread || channel.joined === true ||
+    channel.permissions.has(PermissionFlagsBits.ManageThreads);
+}
+
+function inaccessible(error: unknown): boolean {
+  return typeof error === 'object' && error !== null && 'status' in error &&
+    (error.status === 403 || error.status === 404);
+}
+
+class Snapshot {
+  readonly channels = new Map<string, ChannelEntry>();
+  readonly reasons = new Set([THREAD_REASON, DM_REASON]);
+  private scanned = 0;
+  private requests = 0;
+  private readonly started: number;
+  remote = false;
+
+  constructor(private readonly account: string, private readonly now: () => number) {
+    this.started = now();
+  }
+
+  canFetch(cost = 1): boolean {
+    if (this.requests + cost > REQUEST_LIMIT || this.now() - this.started >= SCAN_MS) {
+      this.reasons.add('Discovery request or time budget reached; additional guilds or threads may be missing.');
+      return false;
+    }
+    this.requests += cost;
+    return true;
+  }
+
+  collect(channels: Iterable<DiscordChannelMetadata>, direct = false): boolean {
+    for (const channel of channels) {
+      if (++this.scanned > DIRECTORY_LIMIT) {
+        this.reasons.add(LIMIT_REASON);
+        return false;
+      }
+      this.add(channel, direct);
+    }
+    return true;
+  }
+
+  private add(channel: DiscordChannelMetadata, direct: boolean): void {
+    const kind = kindOf(channel.type);
+    if (!kind || channel.archived) return;
+    if (direct ? kind !== 'direct' && kind !== 'group' : !visible(channel)) return;
+    const line = lineOf(this.account, channel.id);
+    if (!this.channels.has(line)) {
+      this.channels.set(line, {
+        id: channel.id,
+        line,
+        kind,
+        ...(channel.name ? { name: channel.name } : {}),
+      });
+    }
+  }
+
+  result(): ChannelSnapshot {
+    return {
+      channels: [...this.channels.values()],
+      capability: {
+        supported: true,
+        complete: false,
+        source: this.remote ? 'mixed' : 'local',
+        reason: [...this.reasons].join(' '),
+      },
+    };
+  }
+}
+
+async function collectGuild(guild: DiscordGuildSource, snapshot: Snapshot): Promise<boolean> {
+  if (!snapshot.canFetch() || !snapshot.collect(await guild.channels())) return false;
+  if (!snapshot.canFetch()) return false;
+  try {
+    return snapshot.collect(await guild.threads());
+  } catch (error) {
+    if (!inaccessible(error)) throw error;
+    snapshot.reasons.add('Some active threads could not be accessed and were omitted.');
+    return true;
+  }
+}
+
+async function visitGuild(id: string, source: DiscordChannelSource, snapshot: Snapshot): Promise<boolean> {
+  try {
+    return await collectGuild(await source.guild(id), snapshot);
+  } catch (error) {
+    if (!inaccessible(error)) throw error;
+    snapshot.reasons.add('Some guilds or their channel permissions could not be accessed and were omitted.');
+    return true;
+  }
+}
+
+async function collectGuilds(source: DiscordChannelSource, snapshot: Snapshot): Promise<void> {
+  const visited = new Set<string>();
+  let after: string | undefined;
+  for (;;) {
+    if (!snapshot.canFetch()) return;
+    const page = await source.guilds(after, GUILD_PAGE);
+    snapshot.remote = true;
+    const previousSize = visited.size;
+    for (const id of page) {
+      if (visited.has(id)) continue;
+      if (!snapshot.canFetch(2)) return;
+      visited.add(id);
+      if (!await visitGuild(id, source, snapshot)) return;
+    }
+    if (page.length < GUILD_PAGE) return;
+    if (visited.size === previousSize || page.at(-1) === after) {
+      snapshot.reasons.add('Discord guild pagination did not advance; results are partial.');
+      return;
+    }
+    after = page.at(-1);
+  }
+}
+
+export async function loadDiscordChannels(
+  account: string,
+  source: DiscordChannelSource,
+  now: () => number = Date.now,
+): Promise<ChannelSnapshot> {
+  const snapshot = new Snapshot(account, now);
+  if (snapshot.collect(source.directs(), true)) {
+    try {
+      await collectGuilds(source, snapshot);
+    } catch (error) {
+      if (!inaccessible(error)) throw error;
+      snapshot.reasons.add(snapshot.remote
+        ? 'Discord guild pagination became inaccessible; channels from remaining guilds are omitted.'
+        : 'The bot guild directory could not be accessed; only cached DMs are listed.');
+    }
+  }
+  return snapshot.result();
+}
+
+export async function listChannels(id: string, args: Record<string, unknown>): Promise<void> {
+  const { account } = args;
+  if (typeof account !== 'string' || !account.trim())
+    throw new TrainError('bad_request', 'account is required to list Discord channels');
+  const bot = accounts.get(account);
+  if (!bot) throw new TrainError('bad_request', `Unknown Discord account '${account}'`);
+  const directory = directories.get(bot) ?? new ChannelDirectory();
+  directories.set(bot, directory);
+  const result = await directory.list(account, args, () => {
+    if (!bot.client.isReady()) throw new TrainError('unavailable', 'Discord bot is not ready');
+    return loadDiscordChannels(account, discordChannelSource(bot.client));
+  });
+  respond(id, { result });
+}

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

@@ -0,0 +1,169 @@
+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 '@metro-labs/core/stations/station-runtime';
+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 {
+    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 {
+    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(
+  accountId: string,
+  line: string,
+  messageId: string,
+  extra: object,
+): void {
+  emit({
+    id: mintId(),
+    ts: new Date().toISOString(),
+    station: 'discord-bot',
+    line,
+    from: selfUri(),
+    to: line,
+    message_id: messageId,
+    ...extra,
+    payload: { account: accountId },
+  });
+}
+
+export function emitOutbound(
+  accountId: string,
+  line: string,
+  messageId: string,
+  text: string,
+  replyTo?: string,
+): void {
+  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(accountId, line, messageId, {
+    emoji,
+    event: { type: 'react', emoji, targetId: messageId },
+  });
+}
+export function emitOutboundEdit(
+  accountId: string,
+  line: string,
+  messageId: string,
+  text: string,
+): void {
+  outbound(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 '@metro-labs/core/stations/station-runtime';
+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 };
+}