@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.130

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

@@ -0,0 +1,29 @@
+import {
+  saveBufferToCache,
+  assertContentLength,
+} from '@metro-labs/core/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
+
+export type { SavedAttachment };
+
+export interface DiscordAttachmentRef {
+  url: string;
+  name?: string | null;
+  contentType?: string | null;
+}
+
+export async function saveDiscordAttachment(
+  a: DiscordAttachmentRef,
+  messageId: string,
+  index = 0,
+): Promise<SavedAttachment> {
+  const res = await fetch(a.url, { signal: AbortSignal.timeout(60_000) });
+  if (!res.ok)
+    throw new Error(`discord-bot attachment fetch ${res.status} for ${a.url}`);
+  assertContentLength(res.headers.get('content-length'));
+  const data = new Uint8Array(await res.arrayBuffer());
+  return saveBufferToCache(data, messageId, index, {
+    mime: a.contentType ?? undefined,
+    name: a.name ?? undefined,
+  });
+}

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

@@ -0,0 +1,220 @@
+import { MessageFlags, type Message, type MessageReaction, type User } from 'discord.js';
+import { accounts, lineOf } from './accounts.js';
+import { emit, mintId, SELF_URI } from './wire.js';
+import { saveDiscordAttachment } from './attachments.js';
+
+export function emitInbound(
+  accountId: string,
+  e: Record<string, unknown>,
+): void {
+  const owner = accounts.get(accountId)?.cfg.owner;
+  const payload = {
+    ...(e.payload as Record<string, unknown> | undefined),
+    account: accountId,
+  };
+  emit({ ...e, ...(owner ? { to: owner } : {}), account: accountId, payload });
+}
+
+function emitAttachmentSaved(
+  accountId: string,
+  line: string,
+  sourceMsgId: string,
+  index: number,
+  ref: { url: string; name?: string | null; contentType?: string | null },
+  messageId: string,
+): void {
+  void saveDiscordAttachment(ref, messageId, index)
+    .then((saved) => {
+      emitInbound(accountId, {
+        kind: 'inbound',
+        id: mintId(),
+        ts: new Date().toISOString(),
+        station: 'discord-bot',
+        line,
+        from: SELF_URI,
+        text: `📎 saved: ${saved.path}`,
+        payload: {
+          contentType: 'attachmentSaved',
+          attachmentFor: sourceMsgId,
+          index,
+          attachmentPath: saved.path,
+          localPath: saved.path,
+          mime: saved.mime,
+          name: saved.name,
+        },
+      });
+    })
+    .catch((err: unknown) =>
+      process.stderr.write(
+        `discord-bot attachment save failed: ${err instanceof Error ? err.message : String(err)}\n`,
+      ),
+    );
+}
+
+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,
+  };
+}
+
+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) => {
+    emitAttachmentSaved(
+      accountId,
+      line,
+      envId,
+      i,
+      { url: a.url, name: a.name, contentType: a.contentType },
+      m.id,
+    );
+  });
+  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}`,
+    from_name: m.author.username,
+    from_display_name: m.author.globalName ?? undefined,
+    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: SELF_URI,
+    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,127 @@
+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, messageEnvelope, reactionEnvelope } from './format.js';
+import { mintId } from './wire.js';
+import { readCalls } from '@metro-labs/core/trains/protocol';
+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,
+      GatewayIntentBits.GuildVoiceStates,
+    ],
+    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 ?? '?'} (owner=${cfg.owner ?? '(broadcast)'})\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`,
+    );
+  }
+}
+if (accounts.size === 0) {
+  process.stderr.write('discord-bot: no accounts booted, exiting\n');
+  process.exit(2);
+}
+process.stderr.write(
+  `discord-bot train ready — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
+);