@stage-labs/metro 0.1.0-beta.276 → 0.1.0-beta.277

package/runtime/node_modules/@metro-labs/core/src/stations/channel-directory.ts

@@ -0,0 +1,159 @@
+import { Line } from '../lines.js';
+import { ticketStore } from '../tickets.js';
+import { TrainError } from '../train-error.js';
+
+export const DIRECTORY_LIMIT = 5000;
+const SNAPSHOT_BYTES = 2 * 1024 * 1024;
+const CURSOR_TTL = 5 * 60 * 1000;
+const KINDS = new Set(['direct', 'group', 'channel', 'thread']);
+
+export interface ChannelEntry {
+  id: string;
+  line: string;
+  name?: string;
+  kind: 'direct' | 'group' | 'channel' | 'thread';
+}
+
+export interface ChannelCapability {
+  supported: boolean;
+  complete: boolean;
+  source: 'remote' | 'local' | 'mixed' | 'unsupported';
+  reason?: string;
+}
+
+export interface ChannelSnapshot {
+  channels: ChannelEntry[];
+  capability: ChannelCapability;
+}
+
+export interface ChannelList extends ChannelSnapshot {
+  next_cursor?: string;
+}
+
+export interface ChannelOptions {
+  query: string;
+  limit: number;
+  cursor?: string;
+}
+
+function cursorOf(cursor: unknown): string | undefined {
+  if (cursor === undefined) return undefined;
+  if (typeof cursor !== 'string' || !cursor || cursor.length > 2048)
+    throw new TrainError('bad_request', 'cursor must be a nonempty string of at most 2048 characters');
+  return cursor;
+}
+
+export function channelOptions(args: Record<string, unknown>): ChannelOptions {
+  const { query = '', limit = 50 } = args;
+  if (typeof query !== 'string' || query.length > 200)
+    throw new TrainError('bad_request', 'query must be a string of at most 200 characters');
+  if (typeof limit !== 'number' || !Number.isInteger(limit) || limit < 1 || limit > 100)
+    throw new TrainError('bad_request', 'limit must be an integer from 1 to 100');
+  const cursor = cursorOf(args.cursor);
+  return { query: query.trim().toLowerCase(), limit, ...(cursor === undefined ? {} : { cursor }) };
+}
+
+export function channelMatches(entry: ChannelEntry, query: string): boolean {
+  return [entry.id, entry.line, entry.name ?? ''].some((value) => value.toLowerCase().includes(query));
+}
+
+export function channelEntry(entry: ChannelEntry, account: string): ChannelEntry | undefined {
+  if (!entry.id || entry.id.length > 1024 || entry.line.length > 2048 || !KINDS.has(entry.kind))
+    return undefined;
+  const parsed = Line.parse(entry.line);
+  if (parsed?.path[0] !== account || parsed.path.length < 2) return undefined;
+  return {
+    id: entry.id,
+    line: entry.line,
+    kind: entry.kind,
+    ...(entry.name ? { name: Array.from(entry.name).slice(0, 256).join('') } : {}),
+  };
+}
+
+function limitedCapability(capability: ChannelCapability): ChannelCapability {
+  return {
+    ...capability,
+    complete: false,
+    reason: [capability.reason, 'Directory metadata exceeded the local size or entry limit; results are partial.']
+      .filter(Boolean).join(' '),
+  };
+}
+
+function bounded(snapshot: ChannelSnapshot, account: string, query: string): ChannelSnapshot {
+  const seen = new Set<string>();
+  const channels: ChannelEntry[] = [];
+  let bytes = 0;
+  let clipped = snapshot.channels.length > DIRECTORY_LIMIT;
+  for (const raw of snapshot.channels.slice(0, DIRECTORY_LIMIT)) {
+    const entry = channelEntry(raw, account);
+    if (!entry) {
+      clipped = true;
+      continue;
+    }
+    if (seen.has(entry.line)) continue;
+    bytes += Buffer.byteLength(JSON.stringify(entry));
+    if (bytes > SNAPSHOT_BYTES) {
+      clipped = true;
+      break;
+    }
+    seen.add(entry.line);
+    if (channelMatches(raw, query)) channels.push(entry);
+  }
+  channels.sort((a, b) => a.line < b.line ? -1 : Number(a.line > b.line));
+  return { channels, capability: clipped ? limitedCapability(snapshot.capability) : { ...snapshot.capability } };
+}
+
+interface Cursor {
+  account: string;
+  query: string;
+  snapshot: ChannelSnapshot;
+  offset: number;
+  expiresAt: number;
+}
+
+export class ChannelDirectory {
+  private readonly cursors = ticketStore<Cursor>(CURSOR_TTL, 32);
+
+  async list(
+    account: string,
+    args: Record<string, unknown>,
+    load: () => Promise<ChannelSnapshot>,
+  ): Promise<ChannelList> {
+    const options = channelOptions(args);
+    const cursor = options.cursor === undefined
+      ? {
+        account,
+        query: options.query,
+        snapshot: bounded(await load(), account, options.query),
+        offset: 0,
+        expiresAt: Date.now() + CURSOR_TTL,
+      }
+      : this.resume(options.cursor, account, options.query);
+    return this.page(cursor, options.limit);
+  }
+
+  private resume(ticket: string, account: string, query: string): Cursor {
+    const cursor = this.cursors.peek(ticket);
+    if (!cursor || cursor.account !== account || cursor.query !== query || cursor.expiresAt <= Date.now())
+      throw new TrainError('channel_cursor', 'Invalid or expired channel cursor; start a new listing for this account and query.');
+    return cursor;
+  }
+
+  private page(cursor: Cursor, limit: number): ChannelList {
+    const { snapshot, offset } = cursor;
+    const channels = snapshot.channels.slice(offset, offset + limit).map((entry) => ({ ...entry }));
+    const nextOffset = offset + channels.length;
+    if (nextOffset >= snapshot.channels.length)
+      return { channels, capability: { ...snapshot.capability } };
+    const { ticket } = this.cursors.mint({ ...cursor, offset: nextOffset });
+    return {
+      channels,
+      capability: {
+        ...snapshot.capability,
+        complete: false,
+        reason: [snapshot.capability.reason, 'More channels are available; follow next_cursor.'].filter(Boolean).join(' '),
+      },
+      next_cursor: ticket,
+    };
+  }
+}

package/runtime/node_modules/@metro-labs/core/src/stations/channel-pages.ts

@@ -0,0 +1,129 @@
+import { ticketStore } from '../tickets.js';
+import { TrainError } from '../train-error.js';
+import { channelEntry, channelMatches, channelOptions, DIRECTORY_LIMIT, type ChannelEntry, type ChannelList } from './channel-directory.js';
+
+const TTL = 5 * 60 * 1000;
+const MAX_BYTES = 2 * 1024 * 1024;
+const CAP_REASON = 'Stopped after 5000 metadata records or pages; search does not cover the whole mailbox.';
+const SIZE_REASON = 'Directory metadata exceeded the local size or entry limit; search is partial.';
+
+export interface ChannelPage {
+  channels: ChannelEntry[];
+  scanned: number;
+  next?: string;
+}
+
+export type ChannelPageLoader = (token: string | undefined, limit: number, seen: ReadonlySet<string>) => Promise<ChannelPage>;
+
+interface Scan {
+  next?: string;
+  channels: ChannelEntry[];
+  seen: Set<string>;
+  visited: Set<string>;
+  scanned: number;
+  bytes: number;
+  complete: boolean;
+  stopped?: string;
+}
+
+interface Cursor {
+  account: string;
+  query: string;
+  scope: string;
+  expiresAt: number;
+  scan: Scan;
+  loaded?: Promise<Scan>;
+}
+
+function addEntries(scan: Scan, rows: ChannelEntry[], account: string, query: string): void {
+  for (const raw of rows) {
+    const entry = channelEntry(raw, account);
+    if (!entry) {
+      scan.stopped = SIZE_REASON;
+      continue;
+    }
+    if (scan.seen.has(entry.id)) continue;
+    const size = Buffer.byteLength(JSON.stringify(entry)) + Buffer.byteLength(JSON.stringify(entry.id));
+    if (scan.bytes + size > MAX_BYTES) {
+      scan.stopped = SIZE_REASON;
+      break;
+    }
+    scan.bytes += size;
+    scan.seen.add(entry.id);
+    if (channelMatches(raw, query)) scan.channels.push(entry);
+  }
+}
+
+function project(cursor: Cursor, page: ChannelPage): Scan {
+  const scan: Scan = {
+    next: page.next, channels: [], seen: new Set(cursor.scan.seen),
+    visited: new Set(cursor.scan.visited).add(cursor.scan.next ?? ''),
+    scanned: cursor.scan.scanned + page.scanned,
+    bytes: cursor.scan.bytes + Buffer.byteLength(page.next ?? ''), complete: !page.next,
+  };
+  if (page.next && scan.visited.has(page.next)) throw new TrainError('channel_page', 'The mailbox repeated a channel page token.');
+  addEntries(scan, page.channels, cursor.account, cursor.query);
+  if (scan.bytes > MAX_BYTES) scan.stopped = SIZE_REASON;
+  if (page.next && Math.max(scan.scanned, scan.visited.size) >= DIRECTORY_LIMIT) scan.stopped ??= CAP_REASON;
+  if (scan.stopped) {
+    scan.next = undefined;
+    scan.complete = false;
+  }
+  return scan;
+}
+
+export class ChannelPages {
+  private readonly cursors = ticketStore<Cursor>(TTL, 32);
+
+  async list(account: string, args: Record<string, unknown>, load: ChannelPageLoader, scope: string): Promise<ChannelList> {
+    const { query, limit, cursor: ticket } = channelOptions(args);
+    const cursor: Cursor = ticket === undefined
+      ? {
+        account, query, scope, expiresAt: Date.now() + TTL,
+        scan: { channels: [], seen: new Set(), visited: new Set(), scanned: 0, bytes: Buffer.byteLength(account + query + scope), complete: false },
+      }
+      : this.resume(ticket, account, query);
+    const scan = await this.load(cursor, load);
+    if (cursor.expiresAt <= Date.now()) throw new TrainError('channel_cursor', 'Channel listing expired; start a new listing.');
+    const channels = scan.channels.slice(0, limit);
+    const remaining = scan.channels.slice(channels.length);
+    const more = remaining.length > 0 || (!scan.complete && !scan.stopped);
+    const next = more ? this.cursors.mint({ ...cursor, scan: { ...scan, channels: remaining }, loaded: undefined }).ticket : undefined;
+    return {
+      channels: channels.map((entry) => ({ ...entry })),
+      capability: {
+        supported: true, complete: scan.complete && !more, source: 'remote',
+        reason: [cursor.scope, scan.stopped, more ? 'More metadata remains; follow next_cursor, even after an empty page.' : ''].filter(Boolean).join(' '),
+      },
+      ...(next === undefined ? {} : { next_cursor: next }),
+    };
+  }
+
+  private resume(ticket: string, account: string, query: string): Cursor {
+    const cursor = this.cursors.peek(ticket);
+    if (!cursor || cursor.account !== account || cursor.query !== query || cursor.expiresAt <= Date.now())
+      throw new TrainError('channel_cursor', 'Invalid or expired channel cursor; start a new listing for this account and query.');
+    return cursor;
+  }
+
+  private async load(cursor: Cursor, load: ChannelPageLoader): Promise<Scan> {
+    if (cursor.scan.channels.length || cursor.scan.complete || cursor.scan.stopped) return cursor.scan;
+    cursor.loaded ??= this.fetch(cursor, load);
+    try {
+      return await cursor.loaded;
+    } catch (err) {
+      cursor.loaded = undefined;
+      throw err;
+    }
+  }
+
+  private async fetch(cursor: Cursor, load: ChannelPageLoader): Promise<Scan> {
+    const count = Math.min(100, DIRECTORY_LIMIT - cursor.scan.scanned);
+    const page = await load(cursor.scan.next, count, new Set(cursor.scan.seen));
+    if (!Number.isInteger(page.scanned) || page.scanned < 0 || page.scanned > count || page.channels.length > page.scanned)
+      throw new TrainError('channel_page', 'The mailbox returned more channel metadata than requested.');
+    if (page.next !== undefined && (typeof page.next !== 'string' || !page.next || page.next.length > 16384))
+      throw new TrainError('channel_page', 'The mailbox returned an invalid channel page token.');
+    return project(cursor, page);
+  }
+}

package/runtime/node_modules/@metro-labs/core/src/stations/types.ts

@@ -110,6 +110,7 @@ export interface Station {
   profileFields?: ReadonlySet<ProfileField>;
   claimsName?: boolean;
   readsProfiles?: boolean;
+  discoversChannels?: boolean;
   readFilters?: ReadonlySet<ReadFilter>;
   approvals?: boolean;
   sendsFrames?: boolean;

package/runtime/node_modules/@metro-labs/daemon/src/claude/api.ts

@@ -148,7 +148,7 @@ function sessionCommand(body: Record<string, unknown>, session: SessionDeps): un
   }
   if (body.action === 'stop') {
     setAutostart(false, session.agents);
-    return stopSession(session);
+    return stopSession(session, true);
   }
   if (body.action !== undefined) throw new ApiError('action must be start or stop', 400);
   if (typeof body.autostart === 'boolean') setAutostart(body.autostart, session.agents);

package/runtime/node_modules/@metro-labs/daemon/src/claude/runner-process.ts

@@ -25,7 +25,7 @@ function pidAlive(pid: number): boolean {
   }
 }
 
-export function sdkAlive(activity: RunnerActivity | null): boolean {
+export function sdkAlive(activity: RunnerActivity | null): activity is RunnerActivity {
   if (activity === null) return false;
   const found = identity(activity.pid);
   if (found?.zombie === true) return false;
@@ -40,11 +40,13 @@ function assertIdentity(activity: RunnerActivity): void {
     throw new ApiError('The Agent SDK is still running outside tmux, but its process identity cannot be verified safely. Stop that metro agent process from its terminal.', 503);
 }
 
-export function stopSdkRunner(home: string): void {
+export function stopSdkRunner(home: string, cancelActive = false): boolean {
   const activity = readAgentActivity(home);
-  if (activity === null || !sdkAlive(activity)) return;
+  if (!sdkAlive(activity)) return false;
   assertIdentity(activity);
-  const run = spawnSync(...asAgent('kill', ['-TERM', String(activity.pid)]), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  const signal = cancelActive && activity.cancelSignal === 'SIGUSR2' ? '-USR2' : '-TERM';
+  const run = spawnSync(...asAgent('kill', [signal, String(activity.pid)]), { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
   if ((run.error !== undefined || run.status !== 0) && sdkAlive(activity))
     throw new ApiError(`The Agent SDK could not be stopped: ${run.error?.message ?? run.stderr.trim()}`, 503);
+  return true;
 }

package/runtime/node_modules/@metro-labs/daemon/src/claude/session.ts

@@ -265,9 +265,9 @@ export function startSession(deps: SessionDeps = {}): SessionStatus {
   return sessionStatus(deps);
 }
 
-export function stopSession(deps: SessionDeps = {}): SessionStatus {
-  spawnSync(...asAgent(deps.tmux ?? 'tmux', ['kill-session', '-t', SESSION_NAME]), { stdio: 'ignore' });
-  stopSdkRunner(sessionHome(deps));
+export function stopSession(deps: SessionDeps = {}, cancelActive = false): SessionStatus {
+  if (!stopSdkRunner(sessionHome(deps), cancelActive))
+    spawnSync(...asAgent(deps.tmux ?? 'tmux', ['kill-session', '-t', SESSION_NAME]), { stdio: 'ignore' });
   return sessionStatus(deps);
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/mcp/channel-tool.ts

@@ -0,0 +1,80 @@
+import { channelOptions, type ChannelList } from '@metro-labs/core/stations/channel-directory';
+import type { ToolResult } from '@metro-labs/core/stations/types';
+import { str } from '@metro-labs/core/str';
+import { stationByName } from '../stations/registry.js';
+import { callTargetDenied } from '../agents/scope.js';
+import { errResult, makeCtx, okJson, toErr } from './ctx.js';
+import { stationOfAccount } from './read-tool.js';
+import type { ToolDef } from './tool-def.js';
+
+export const LIST_CHANNELS_TOOL: ToolDef = {
+  name: 'list_channels',
+  group: 'read',
+  description:
+    'Discover existing conversations for one account from list_accounts, returning metadata only. ' +
+    'Args: account (required), query?, limit? (1 to 100, default 50), cursor?. Query matches names, ids or lines ' +
+    'case-insensitively. Returns {account, station, channels:[{id, line, name?, kind:direct|group|channel|thread}], ' +
+    'capability:{supported, complete, source:remote|local|mixed|unsupported, reason?}, next_cursor?}. ' +
+    'Use each returned line with other Metro tools. Follow next_cursor with the same account and query. ' +
+    'Check capability: local or partial directories are not exhaustive, and unsupported is not an empty account. ' +
+    'No recent message is required. Receive messages Off does not disable discovery; read policies still apply.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      account: { type: 'string', minLength: 1, description: 'An account id from list_accounts.' },
+      query: { type: 'string', maxLength: 200, description: 'Case-insensitive name, id or line substring.' },
+      limit: { type: 'integer', minimum: 1, maximum: 100, default: 50, description: 'Maximum channels per page.' },
+      cursor: { type: 'string', minLength: 1, maxLength: 2048, description: 'The next_cursor from the previous page.' },
+    },
+    required: ['account'],
+  },
+};
+
+export function channelScopeDenied(allowed: Set<string>, a: Record<string, unknown>): boolean {
+  const account = str(a.account);
+  const station = account ? stationOfAccount(account) : undefined;
+  return station === undefined || stationByName(station) === undefined || callTargetDenied(allowed, station, { account });
+}
+
+export function channelArgsError(a: Record<string, unknown>): ToolResult | undefined {
+  if (typeof a.account !== 'string' || !a.account.trim())
+    return errResult('list_channels requires `account` from list_accounts');
+  try {
+    channelOptions(a);
+    return undefined;
+  } catch (e) {
+    return toErr('list_channels', e);
+  }
+}
+
+export async function dispatchListChannels(a: Record<string, unknown>): Promise<ToolResult> {
+  const account = str(a.account);
+  const name = stationOfAccount(account);
+  const station = name === undefined ? undefined : stationByName(name);
+  if (station === undefined) return errResult('list_channels requires a unique account from list_accounts');
+  if (!station.hasTrain || station.discoversChannels !== true) {
+    const list: ChannelList = {
+      channels: [],
+      capability: {
+        supported: false,
+        complete: false,
+        source: 'unsupported',
+        reason: `${station.name} does not support channel discovery`,
+      },
+    };
+    return okJson({ account, station: station.name, ...list });
+  }
+  try {
+    const { limit, cursor } = channelOptions(a);
+    const args = {
+      account,
+      limit,
+      ...(a.query === undefined ? {} : { query: str(a.query) }),
+      ...(cursor === undefined ? {} : { cursor }),
+    };
+    const { result } = await makeCtx(station.name).call('listChannels', args);
+    return okJson({ ...result as ChannelList, account, station: station.name });
+  } catch (e) {
+    return toErr('list_channels', e);
+  }
+}

package/runtime/node_modules/@metro-labs/daemon/src/mcp/permission-prompt.ts

@@ -1,5 +1,8 @@
+import { str } from '@metro-labs/core/str';
 import { readPreview, shownValue } from '../approvals/preview.js';
 import { connectorToolOf } from '../connectors/gates.js';
+import { stationByName } from '../stations/registry.js';
+import { stationOfAccount } from './read-tool.js';
 
 export interface PermissionParams {
   request_id: string;
@@ -37,6 +40,14 @@ function channelOf(input: Record<string, unknown>): string | undefined {
   return typeof input.station === 'string' && input.station !== '' ? input.station : undefined;
 }
 
+function discoveryChannel(input: Record<string, unknown>): string {
+  const account = str(input.account);
+  if (!account) return 'unknown account';
+  const name = stationOfAccount(account);
+  const station = name === undefined ? undefined : stationByName(name);
+  return `${station?.name ?? 'unknown station'} · ${shorten(account)}`;
+}
+
 function argText(value: unknown): string | undefined {
   const plain = valueText(value);
   if (plain !== undefined || value === null || typeof value !== 'object') return plain;
@@ -50,7 +61,7 @@ function fieldText(key: string, value: unknown): string | undefined {
 
 function metroLines(tool: string, input: Record<string, unknown>): string[] {
   const lines = [`Approval needed: ${tool}`];
-  const channel = channelOf(input);
+  const channel = tool === 'list_channels' ? discoveryChannel(input) : channelOf(input);
   if (channel !== undefined) lines.push(`Channel: ${channel}`);
   if (tool === 'send' && input.speech !== undefined) lines.push('Delivery: voice call only, no chat post');
   const keys = [...LEAD, ...Object.keys(input).filter((k) => !LEAD.includes(k))];

package/runtime/node_modules/@metro-labs/daemon/src/mcp/policy-gate.ts

@@ -25,8 +25,14 @@ function channelTargets(name: string, a: Record<string, unknown>): ChannelTarget
     return line === undefined ? [] : fromLine(line, undefined);
   }
   const account = str(a.account);
+  if (name === 'list_channels') return accountTargets(name, { account });
   const line = str(a.line);
   if (line) return fromLine(line, name === 'list_members' ? undefined : account);
+  return accountTargets(name, a);
+}
+
+function accountTargets(name: string, a: Record<string, unknown>): ChannelTarget[] {
+  const account = str(a.account);
   const station = stationForTool(name, a) ?? (account ? stationOfAccount(account) : undefined);
   if (station === undefined) return [];
   if (account) return [{ kind: 'channel', station, account }];

package/runtime/node_modules/@metro-labs/daemon/src/mcp/tool-catalog.ts

@@ -3,6 +3,7 @@ import { STATIONS } from '../stations/registry.js';
 import { COMMON_TOOLS, LIST_ACCOUNTS_TOOL } from './tool-schemas.js';
 import { SET_PROFILE_TOOL } from './profile-tool.js';
 import { GET_PROFILE_TOOL } from './profile-lookup.js';
+import { LIST_CHANNELS_TOOL } from './channel-tool.js';
 import type { ToolDef } from './tool-def.js';
 
 const defOf = (tool: StationTool): ToolDef => ({
@@ -17,6 +18,7 @@ export const TOOL_DEFS: ToolDef[] = [
   ...COMMON_TOOLS,
   ...STATIONS.flatMap((s) => s.tools.map(defOf)),
   LIST_ACCOUNTS_TOOL,
+  LIST_CHANNELS_TOOL,
   SET_PROFILE_TOOL,
   GET_PROFILE_TOOL,
 ];
@@ -85,7 +87,8 @@ export const stationToolGroups = (): Record<string, GroupedTool[]> =>
 export function channelToolsOf(station: Station): GroupedTool[] {
   const names: string[] = [...station.messageVerbs];
   if (station.hasTrain && station.hasAccounts) names.push('list_members');
-  for (const op of station.groupOps ?? []) names.push(GROUP_OP_TOOLS[op]);
+  if (station.hasTrain && station.discoversChannels === true) names.push('list_channels');
+  names.push(...Array.from(station.groupOps ?? [], (op) => GROUP_OP_TOOLS[op]));
   if ((station.profileFields?.size ?? 0) > 0) names.push('set_profile');
   if (station.readsProfiles === true) names.push('get_profile');
   names.push(...station.tools.map((t) => t.name));

package/runtime/node_modules/@metro-labs/daemon/src/mcp/tool-dispatch.ts

@@ -37,6 +37,7 @@ import {
 } from './request-identity.js';
 import { str } from '@metro-labs/core/str';
 import { linelessRead, stationOfAccount } from './read-tool.js';
+import { channelArgsError, channelScopeDenied, dispatchListChannels } from './channel-tool.js';
 
 const STATION_TOOLS = new Map<
   string,
@@ -50,6 +51,7 @@ const CORE_DISPATCH: Record<
   (a: Record<string, unknown>) => Promise<ToolResult>
 > = {
   list_members: dispatchListMembers,
+  list_channels: dispatchListChannels,
   create_group: dispatchCreateGroup,
   add_members: dispatchAddMembers,
   remove_members: dispatchRemoveMembers,
@@ -91,6 +93,7 @@ export function scopeDenied(
   args: Record<string, unknown>,
 ): boolean {
   const allowed = allowedAgents(identity);
+  if (name === 'list_channels') return channelScopeDenied(allowed, args);
   if (name === 'read' && !str(args.line)) {
     const account = str(args.account);
     if (!account) return false;
@@ -147,6 +150,10 @@ async function runTool(
 ): Promise<ToolResult> {
   const name = req.params.name;
   const a = req.params.arguments ?? {};
+  if (name === 'list_channels') {
+    const invalid = channelArgsError(a);
+    if (invalid) return invalid;
+  }
 
   const identity = currentIdentity();
   if (name !== 'list_accounts' && scopeDenied(identity, name, a))

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

@@ -15,6 +15,7 @@ import {
 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,
@@ -210,6 +211,7 @@ const HANDLERS: Record<string, StationHandler> = {
   delete: remove,
   read,
   listMembers,
+  listChannels,
   set_profile: setProfile,
   profile: readProfile,
 };

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