@stage-labs/metro 0.1.0-beta.7 → 0.1.0-beta.71

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

@@ -0,0 +1,388 @@
+import {
+  ActivityType,
+  type Message,
+  type PresenceStatusData,
+} from 'discord.js';
+import {
+  accountFor,
+  accounts,
+  encodeEmoji,
+  lineOf,
+  rest,
+  routeOf,
+} from './accounts.js';
+import { emitOutbound, emitOutboundEdit, emitOutboundReact } from './format.js';
+import { respond } from './wire.js';
+import { normalizeDiscord } from '@metro-labs/mcp/stations/messaging-normalize';
+import { assertContentLength } from '@metro-labs/mcp/stations/attachments';
+import {
+  appendFiles,
+  outgoingFiles,
+  type OutgoingFile,
+} from './send-files.js';
+import {
+  makeStation,
+  type CallMsg,
+  type StationHandler,
+} from '@metro-labs/mcp/stations/station-runtime';
+import { joinVoice, leaveVoice, voiceDebug, voiceTranscribe } from './voice.js';
+import { speak } from './voice-speak.js';
+import { discordMembers } from './members.js';
+import {
+  groupAddHandler,
+  groupCreateHandler,
+  groupRemoveHandler,
+} from './group-actions.js';
+
+async function sendMessage(
+  accountId: string,
+  channel: string,
+  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 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 };
+}
+
+export type { CallMsg };
+
+async function send(id: string, args: Record<string, unknown>): Promise<void> {
+  const {
+    line,
+    text,
+    replyTo,
+    embeds,
+    stickerIds,
+    images,
+    files,
+    account,
+    attachmentKinds,
+    attachmentNames,
+  } = args as {
+    line: string;
+    text?: string;
+    replyTo?: string;
+    embeds?: unknown[];
+    stickerIds?: string[];
+    images?: string[];
+    files?: string[];
+    account?: string;
+    attachmentKinds?: string[];
+    attachmentNames?: string[];
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const body: Record<string, unknown> = { flags: 4 };
+  if (text !== undefined) body.content = text;
+  if (replyTo) body.message_reference = { message_id: replyTo };
+  if (embeds) body.embeds = embeds;
+  if (stickerIds) body.sticker_ids = stickerIds;
+  const outgoing = outgoingFiles(
+    [...(images ?? []), ...(files ?? [])],
+    attachmentNames,
+    attachmentKinds,
+  );
+  const res = await sendMessage(accountId, channelId, body, outgoing);
+  emitOutbound(accountId, line, res.id, text ?? '', replyTo);
+  respond(id, {
+    result: {
+      messageId: res.id,
+      account: accountId,
+      ...(res.delivered.length ? { attachments: res.delivered } : {}),
+    },
+  });
+}
+
+function presence(id: string, args: Record<string, unknown>): void {
+  const {
+    text,
+    status = 'online',
+    account,
+  } = args as {
+    text?: string;
+    status?: PresenceStatusData;
+    account?: string;
+  };
+  const accountId = accountFor({ account });
+  const acct = accounts.get(accountId);
+  if (!acct) {
+    respond(id, { error: `unknown account '${accountId}'` });
+    return;
+  }
+  const client = acct.client;
+  if (!client.user) {
+    respond(id, { error: `gateway not ready for account '${accountId}'` });
+    return;
+  }
+  client.user.setPresence({
+    status,
+    activities: text
+      ? [{ name: 'Custom Status', type: ActivityType.Custom, state: text }]
+      : [],
+  });
+  respond(id, {
+    result: { ok: true, text: text ?? null, status, account: accountId },
+  });
+}
+
+const profileUrl = (userId?: string): string | null =>
+  userId === undefined ? null : `https://discord.com/users/${userId}`;
+
+function listAccounts(id: string): void {
+  respond(id, {
+    result: {
+      accounts: [...accounts.values()].map((a) => ({
+        id: a.cfg.id,
+        handle: a.client.user?.username ?? null,
+        url: profileUrl(a.client.user?.id),
+        userId: a.client.user?.id ?? null,
+        username: a.client.user?.username ?? null,
+        owner: a.cfg.owner ?? null,
+        ready: a.client.isReady(),
+      })),
+    },
+  });
+}
+
+async function react(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, emoji, account } = args as {
+    line: string;
+    messageId: string;
+    emoji: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  if (emoji) {
+    const e = encodeEmoji(emoji);
+    await rest(
+      accountId,
+      'PUT',
+      `/channels/${channelId}/messages/${messageId}/reactions/${e}/@me`,
+    );
+    emitOutboundReact(accountId, line, messageId, emoji);
+  } else {
+    await rest(
+      accountId,
+      'DELETE',
+      `/channels/${channelId}/messages/${messageId}/reactions/@me`,
+    );
+  }
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function edit(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, text, account } = args as {
+    line: string;
+    messageId: string;
+    text: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'PATCH', `/channels/${channelId}/messages/${messageId}`, {
+    content: text,
+  });
+  emitOutboundEdit(accountId, line, messageId, text);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function remove(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, messageId, account } = args as {
+    line: string;
+    messageId: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'DELETE', `/channels/${channelId}/messages/${messageId}`);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function fetchMessages(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const {
+    line,
+    limit = 20,
+    before,
+    account,
+  } = args as {
+    line: string;
+    limit?: number;
+    before?: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const qs = new URLSearchParams({
+    limit: String(limit),
+    ...(before ? { before } : {}),
+  });
+  const msgs = await rest<Message[]>(
+    accountId,
+    'GET',
+    `/channels/${channelId}/messages?${qs}`,
+  );
+  respond(id, { result: { messages: msgs, account: accountId } });
+}
+
+async function download(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const {
+    line,
+    messageId,
+    outDir = '/tmp',
+    account,
+  } = args as {
+    line: string;
+    messageId: string;
+    outDir?: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const msg = await rest<{
+    attachments: { url: string; content_type?: string; filename: string }[];
+  }>(accountId, 'GET', `/channels/${channelId}/messages/${messageId}`);
+  const files: { path: string; mediaType: string }[] = [];
+  for (const att of msg.attachments) {
+    const res = await fetch(att.url, { signal: AbortSignal.timeout(60_000) });
+    if (!res.ok)
+      throw new Error(`discord-bot download ${res.status} for ${att.url}`);
+    assertContentLength(res.headers.get('content-length'));
+    const buf = await res.arrayBuffer();
+    const path = `${outDir}/${messageId}-${att.filename}`;
+    await Bun.write(path, buf);
+    files.push({
+      path,
+      mediaType: att.content_type ?? 'application/octet-stream',
+    });
+  }
+  respond(id, { result: { files, account: accountId } });
+}
+
+async function threadCreate(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const {
+    line,
+    messageId,
+    name,
+    autoArchiveDuration = 1440,
+    account,
+  } = args as {
+    line: string;
+    messageId?: string;
+    name: string;
+    autoArchiveDuration?: number;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const path = messageId
+    ? `/channels/${channelId}/messages/${messageId}/threads`
+    : `/channels/${channelId}/threads`;
+  const res = await rest<{ id: string }>(accountId, 'POST', path, {
+    name,
+    auto_archive_duration: autoArchiveDuration,
+  });
+  respond(id, {
+    result: {
+      threadId: res.id,
+      line: lineOf(accountId, res.id),
+      account: accountId,
+    },
+  });
+}
+
+async function pin(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, messageId, account } = args as {
+    line: string;
+    messageId: string;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'PUT', `/channels/${channelId}/pins/${messageId}`);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function typing(id: string, args: Record<string, unknown>): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, channelId } = routeOf(line, account);
+  await rest(accountId, 'POST', `/channels/${channelId}/typing`);
+  respond(id, { result: { ok: true, account: accountId } });
+}
+
+async function channel(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, account } = args as { line: string; account?: string };
+  const { accountId, channelId } = routeOf(line, account);
+  const res = await rest(accountId, 'GET', `/channels/${channelId}`);
+  respond(id, { result: res });
+}
+
+async function listMembers(
+  id: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const { line, limit, account } = args as {
+    line: string;
+    limit?: number;
+    account?: string;
+  };
+  const { accountId, channelId } = routeOf(line, account);
+  const result = await discordMembers(accountId, channelId, limit);
+  respond(id, { result });
+}
+
+const HANDLERS: Record<string, StationHandler> = {
+  accounts: (id) => {
+    listAccounts(id);
+  },
+  groupCreate: groupCreateHandler,
+  groupAddMembers: groupAddHandler,
+  groupRemoveMembers: groupRemoveHandler,
+  send,
+  react,
+  edit,
+  delete: remove,
+  fetch: fetchMessages,
+  download,
+  thread_create: threadCreate,
+  pin,
+  typing,
+  channel,
+  listMembers,
+  set_presence: presence,
+  joinVoice,
+  leaveVoice,
+  speak,
+  voiceDebug,
+  voiceTranscribe,
+};
+
+export const handleCall = makeStation({
+  handlers: HANDLERS,
+  normalize: normalizeDiscord,
+});

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

@@ -0,0 +1 @@
+export const API = 'https://discord.com/api/v10';

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

@@ -0,0 +1,29 @@
+import {
+  saveBufferToCache,
+  assertContentLength,
+} from '@metro-labs/mcp/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/mcp/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),
+  });
+}