@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -1,37 +1,22 @@
 import { Client } from 'discord.js';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import {
   makeAccountStore,
   resolveAccountId,
-} from '@metro-labs/mcp/stations/account-store';
-import { Line } from '@metro-labs/mcp/lines';
-import { emit } from './wire.js';
+} from '@metro-labs/core/stations/account-store';
+import { Line } from '@metro-labs/core/lines';
 import { API } from './api-base.js';
 
-const ACCOUNTS_FILE =
-  process.env.DISCORD_BOT_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'discord-bot-accounts.json');
-
 export interface AccountConfig {
   id: string;
   token: string;
-  owner?: string;
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
   prefix: 'discord-bot',
-  file: ACCOUNTS_FILE,
-  allowlistEnv: ['DISCORD_BOT_ONLY_ACCOUNTS', 'DISCORD_BOT_ACCOUNTS'],
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) {
-      if (!a.id) die('account missing id');
+    for (const a of raw)
       if (!a.token || typeof a.token !== 'string')
         die(`account '${a.id}' missing token`);
-      if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-      seen.add(a.id);
-    }
   },
 });
 
@@ -71,17 +56,12 @@ export async function rest<T = unknown>(
   };
   if (body !== undefined && !isForm)
     headers['Content-Type'] = 'application/json';
-  emit({ op: 'log', text: `discord-bot[${accountId}] api ${method} ${path}` });
   const res = await fetch(`${API}${path}`, {
     method,
     headers,
     body: restBody(body, isForm),
     signal: AbortSignal.timeout(30_000),
   });
-  emit({
-    op: 'log',
-    text: `discord-bot[${accountId}] api ${method} ${path} -> ${res.status}`,
-  });
   if (!res.ok) {
     const text = await res.text().catch(() => '');
     throw new Error(`discord-bot ${method} ${path}: ${res.status} ${text}`);

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

@@ -1,33 +1,21 @@
+import type { Message } from 'discord.js';
 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 { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 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 { makeStation, respond, type CallMsg, type StationHandler } from '@metro-labs/core/stations/station-runtime';
+import { readProfile, setProfile } from './profile.js';
 import { discordMembers } from './members.js';
+import { listChannels } from './channels.js';
 import {
   groupAddHandler,
   groupCreateHandler,
@@ -65,40 +53,17 @@ async function sendMessage(
 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 {
+  const { line, text, replyTo, account } = 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 outgoing = outgoingFiles(args.attachments);
   const res = await sendMessage(accountId, channelId, body, outgoing);
   emitOutbound(accountId, line, res.id, text ?? '', replyTo);
   respond(id, {
@@ -110,38 +75,6 @@ async function send(id: string, args: Record<string, unknown>): Promise<void> {
   });
 }
 
-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}`;
 
@@ -154,13 +87,19 @@ function listAccounts(id: string): void {
         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 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 react(id: string, args: Record<string, unknown>): Promise<void> {
   const { line, messageId, emoji, account } = args as {
     line: string;
@@ -216,7 +155,7 @@ async function remove(
   respond(id, { result: { ok: true, account: accountId } });
 }
 
-async function fetchMessages(
+async function read(
   id: string,
   args: Record<string, unknown>,
 ): Promise<void> {
@@ -244,104 +183,6 @@ async function fetchMessages(
   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>,
@@ -365,24 +206,17 @@ const HANDLERS: Record<string, StationHandler> = {
   groupRemoveMembers: groupRemoveHandler,
   send,
   react,
+  typing,
   edit,
   delete: remove,
-  fetch: fetchMessages,
-  download,
-  thread_create: threadCreate,
-  pin,
-  typing,
-  channel,
+  read,
   listMembers,
-  set_presence: presence,
-  joinVoice,
-  leaveVoice,
-  speak,
-  voiceDebug,
-  voiceTranscribe,
+  listChannels,
+  set_profile: setProfile,
+  profile: readProfile,
 };
 
 export const handleCall = makeStation({
   handlers: HANDLERS,
-  normalize: normalizeDiscord,
+  normalize: messagingAliases(),
 });

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

@@ -1,8 +1,8 @@
 import {
   saveBufferToCache,
   assertContentLength,
-} from '@metro-labs/mcp/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
+} from '@metro-labs/core/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
 
 export type { SavedAttachment };
 

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 });
+}