@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.260

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

@@ -0,0 +1,75 @@
+import { randomUUID } from 'node:crypto';
+import { currentBusSeq } from '@metro-labs/core/events';
+import { newReplayLedger } from '../channels/relay.js';
+import { McpSession, channelLog, type SessionKind } from './session.js';
+import { allowedAgents, type RequestIdentity } from './request-identity.js';
+
+export class SessionSlot {
+  private session: McpSession | undefined;
+  private readonly ledger = newReplayLedger();
+  private started = false;
+  private live: boolean;
+
+  constructor(
+    live = true,
+    private readonly kind: SessionKind = 'chat',
+  ) {
+    this.live = live;
+  }
+
+  get current(): McpSession | undefined {
+    return this.session;
+  }
+
+  get liveEvents(): boolean {
+    return this.live;
+  }
+
+  startInbound(): void {
+    if (this.started) return;
+    this.started = true;
+    if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
+    if (this.live) this.session?.startChannel();
+  }
+
+  setLive(on: boolean): void {
+    if (this.live === on) return;
+    this.live = on;
+    channelLog('inbound: live events', on ? 'on' : 'off');
+    if (!on) {
+      this.session?.stopChannel();
+      this.session?.relay.dropPending();
+      return;
+    }
+    this.ledger.startAt = currentBusSeq();
+    if (this.started) this.session?.startChannel();
+  }
+
+  async open(
+    identity: RequestIdentity,
+    adoptId?: string,
+  ): Promise<McpSession> {
+    await this.session?.close();
+    if (this.ledger.startAt < 0) this.ledger.startAt = currentBusSeq();
+    const id = adoptId ?? randomUUID();
+    const session = await McpSession.open({
+      kind: this.kind,
+      id,
+      scope: allowedAgents(identity),
+      adopted: adoptId !== undefined,
+      ledger: this.ledger,
+      live: () => this.live,
+      onClosed: (s) => {
+        if (this.session === s) this.session = undefined;
+      },
+    });
+    this.session = session;
+    if (this.started && this.live) session.startChannel();
+    channelLog('session: opened', 'id', id, 'kind', this.kind, 'adopted', adoptId !== undefined);
+    return session;
+  }
+
+  async close(): Promise<void> {
+    await this.session?.close();
+  }
+}

package/runtime/node_modules/@metro-labs/{mcp → daemon}/src/mcp/session.ts

@@ -1,20 +1,17 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { InboundRelay } from '../channels/inbound.js';
+import { answerPrompt, forgetPromptsOf, promptLine } from '../approvals/pending.js';
 import { ChannelRelay, type ReplayLedger } from '../channels/relay.js';
-import { errMsg } from '../daemon/log.js';
-import {
-  allowlistForLine,
-  senderMatchesAllowlist,
-} from '../db/agent-map.js';
-import { accountStationNames } from '../stations/registry.js';
-import { MCP_INSTRUCTIONS } from './tool-schemas.js';
-import { ChannelOwner } from './channel-owner.js';
+import { errMsg } from '@metro-labs/core/log';
+import { allowlistForLine, mayApprove, senderPermitted } from '../agents/map.js';
+import { accountStationNames, stationByName } from '../stations/registry.js';
+import { eventInScope } from '../agents/scope.js';
+import { MCP_INSTRUCTIONS, VOICE_MCP_INSTRUCTIONS } from './instructions.js';
 import { BoundedEventStore } from './event-store.js';
 import { registerPermissionRelay } from './permission-relay.js';
 import { registerToolHandlers, toolSchemaSignature } from './tool-dispatch.js';
 import { web, type RawGetSink } from './raw-get-stream.js';
-import type { RequestIdentity } from './request-identity.js';
 
 export const channelLog = (...a: unknown[]): void => {
   console.error('[metro-mcp]', ...a);
@@ -22,10 +19,15 @@ export const channelLog = (...a: unknown[]): void => {
 
 const getStations = (): Set<string> => new Set(accountStationNames());
 
-const senderAllowed = (from: string, line: string): boolean => {
-  const allowlist = allowlistForLine(line);
-  return allowlist ? senderMatchesAllowlist(allowlist, from) : true;
-};
+const senderAllowed = (from: string, line: string, verified?: boolean): boolean =>
+  senderPermitted(allowlistForLine(line), from, verified);
+
+const approves = (station: string): boolean => stationByName(station)?.approvals !== false;
+
+async function answerPermission(requestId: string, behavior: 'allow' | 'deny', line: string, from: string): Promise<boolean> {
+  if (promptLine(requestId) !== line || !mayApprove(line, from)) return false;
+  return (await answerPrompt(requestId, behavior, 'chat', line)) !== undefined;
+}
 
 function makeTransport(
   id: string,
@@ -45,24 +47,29 @@ function makeTransport(
   return t;
 }
 
+export type SessionKind = 'chat' | 'voice';
+
+const CHANNEL_CAPABILITIES = { experimental: { 'claude/channel': {}, 'claude/channel/permission': {} } };
+
 export interface SessionInit {
+  kind?: SessionKind;
   id: string;
-  scopeKey: string;
+  scope: Set<string>;
   adopted: boolean;
   ledger: ReplayLedger;
+  live: () => boolean;
   onClosed: (session: McpSession) => void;
 }
 
 export class McpSession {
   readonly id: string;
-  readonly scopeKey: string;
-  readonly owner = new ChannelOwner();
+  readonly scope: Set<string>;
   readonly eventStore: BoundedEventStore;
   readonly transport: StreamableHTTPServerTransport;
   readonly server: Server;
   readonly relay: InboundRelay;
   readonly channel: ChannelRelay;
-  lastSeenAt = Date.now();
+  readonly live: () => boolean;
   private sink: RawGetSink | undefined;
   private unsubscribe: (() => void) | undefined;
   private closed = false;
@@ -72,24 +79,18 @@ export class McpSession {
 
   private constructor(init: SessionInit) {
     this.id = init.id;
-    this.scopeKey = init.scopeKey;
+    this.scope = init.scope;
+    this.live = init.live;
     this.issuedSchema = init.adopted ? undefined : toolSchemaSignature();
     this.onClosed = init.onClosed;
-    this.eventStore = new BoundedEventStore({
-      scopeOf: () => this.owner.scope(),
-    });
+    this.eventStore = new BoundedEventStore();
     this.transport = makeTransport(init.id, this.eventStore, init.adopted);
+    const voice = init.kind === 'voice';
     this.server = new Server(
       { name: 'metro', version: '0.1.0' },
       {
-        capabilities: {
-          experimental: {
-            'claude/channel': {},
-            'claude/channel/permission': {},
-          },
-          tools: { listChanged: true },
-        },
-        instructions: MCP_INSTRUCTIONS,
+        capabilities: { ...(voice ? {} : CHANNEL_CAPABILITIES), tools: { listChanged: true } },
+        instructions: voice ? VOICE_MCP_INSTRUCTIONS : MCP_INSTRUCTIONS,
       },
     );
     registerToolHandlers(this.server, {
@@ -99,23 +100,31 @@ export class McpSession {
       deliver: (send): void => {
         this.deliverSchemaNotice(send, 'request');
       },
+    }, {
+      onSent: (id): void => {
+        this.relay.noteSent(id);
+      },
     });
     this.relay = new InboundRelay({
       mcp: this.server,
       log: channelLog,
       getStations,
       senderAllowed,
+      approves,
+      answerPermission,
     });
-    registerPermissionRelay({
-      mcp: this.server,
-      relay: this.relay,
-      owner: this.owner,
-      log: channelLog,
-    });
+    if (!voice)
+      registerPermissionRelay({
+        mcp: this.server,
+        relay: this.relay,
+        inScope: (line) => this.inScope(line),
+        live: this.live,
+        log: channelLog,
+      });
     this.channel = new ChannelRelay({
       relay: this.relay,
       log: channelLog,
-      inScope: (line) => this.owner.inScope(line),
+      inScope: (line) => this.live() && this.inScope(line),
       ledger: init.ledger,
     });
   }
@@ -139,22 +148,26 @@ export class McpSession {
     return this.sink;
   }
 
-  touch(): void {
-    this.lastSeenAt = Date.now();
+  inScope(line: string): boolean {
+    return this.streamAttached && eventInScope(this.scope, line);
   }
 
   startChannel(): void {
     this.unsubscribe ??= this.channel.start();
   }
 
-  bindSink(sink: RawGetSink | undefined, identity: RequestIdentity): void {
+  stopChannel(): void {
+    this.unsubscribe?.();
+    this.unsubscribe = undefined;
+  }
+
+  replayMissed(): void {
+    if (this.live()) this.channel.replayMissed();
+  }
+
+  bindSink(sink: RawGetSink | undefined): void {
     this.sink = sink;
-    if (sink === undefined) {
-      this.owner.releaseStream();
-      return;
-    }
-    this.owner.bindStream(identity);
-    this.announceToolSchema();
+    if (sink !== undefined) this.announceToolSchema();
   }
 
   private get schemaNoticeDue(): boolean {
@@ -172,15 +185,7 @@ export class McpSession {
   private deliverSchemaNotice(send: () => Promise<void>, via: string): void {
     if (!this.schemaNoticeDue || this.announcing) return;
     this.announcing = true;
-    channelLog(
-      'session: tool list changed',
-      'id',
-      this.id,
-      'scope',
-      this.scopeKey,
-      'via',
-      via,
-    );
+    channelLog('session: tool list changed', 'id', this.id, 'via', via);
     send()
       .then(() => {
         this.issuedSchema = toolSchemaSignature();
@@ -195,7 +200,6 @@ export class McpSession {
   dropStream(): void {
     const sink = this.sink;
     this.sink = undefined;
-    this.owner.releaseStream();
     sink?.close();
   }
 
@@ -203,9 +207,9 @@ export class McpSession {
     if (this.closed) return;
     this.closed = true;
     this.onClosed(this);
+    forgetPromptsOf(this.server);
     this.dropStream();
-    this.unsubscribe?.();
-    this.unsubscribe = undefined;
+    this.stopChannel();
     await this.server.close().catch(() => undefined);
   }
 }

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

@@ -0,0 +1,93 @@
+import type { GroupOp, Station, StationTool, ToolGroup } from '@metro-labs/core/stations/types';
+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 type { ToolDef } from './tool-def.js';
+
+const defOf = (tool: StationTool): ToolDef => ({
+  name: tool.name,
+  description: tool.description,
+  inputSchema: tool.inputSchema,
+  ...(tool.group === undefined ? {} : { group: tool.group }),
+  ...(tool.destructive === true ? { destructive: true } : {}),
+});
+
+export const TOOL_DEFS: ToolDef[] = [
+  ...COMMON_TOOLS,
+  ...STATIONS.flatMap((s) => s.tools.map(defOf)),
+  LIST_ACCOUNTS_TOOL,
+  SET_PROFILE_TOOL,
+  GET_PROFILE_TOOL,
+];
+
+const BY_NAME = new Map(TOOL_DEFS.map((d) => [d.name, d] as const));
+
+export const declaredGroup = (name: string): ToolGroup | undefined => BY_NAME.get(name)?.group;
+
+export const toolGroupOf = (name: string): ToolGroup => declaredGroup(name) ?? 'write';
+
+export interface ToolAnnotations {
+  readOnlyHint: boolean;
+  destructiveHint?: boolean;
+}
+
+export interface PublishedTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  annotations: ToolAnnotations;
+  _meta?: Record<string, boolean>;
+}
+
+const ALWAYS_LOADED = new Set(['react', 'typing', 'send', 'reply']);
+const ALWAYS_LOAD = { 'anthropic/alwaysLoad': true };
+
+const annotationsOf = (def: ToolDef): ToolAnnotations =>
+  toolGroupOf(def.name) === 'read'
+    ? { readOnlyHint: true }
+    : { readOnlyHint: false, destructiveHint: def.destructive === true };
+
+export const listedTools = (): PublishedTool[] =>
+  TOOL_DEFS.map((def) => ({
+    name: def.name,
+    description: def.description,
+    inputSchema: def.inputSchema,
+    annotations: annotationsOf(def),
+    ...(ALWAYS_LOADED.has(def.name) ? { _meta: ALWAYS_LOAD } : {}),
+  }));
+
+const STATION_OF_TOOL = new Map(STATIONS.flatMap((s) => s.tools.map((t) => [t.name, s.name] as const)));
+
+export const stationToolOwners = (): Record<string, string> => Object.fromEntries(STATION_OF_TOOL);
+
+export function stationForTool(name: string, args: Record<string, unknown>): string | undefined {
+  if (name === 'create_group' || name === 'set_profile')
+    return typeof args.station === 'string' && args.station !== '' ? args.station : undefined;
+  return STATION_OF_TOOL.get(name);
+}
+
+const GROUP_OP_TOOLS: Record<GroupOp, string> = {
+  create_group: 'create_group',
+  add_members: 'add_members',
+  remove_members: 'remove_members',
+  invite_link: 'export_invite',
+};
+
+export interface GroupedTool {
+  name: string;
+  group: ToolGroup;
+}
+
+export const stationToolGroups = (): Record<string, GroupedTool[]> =>
+  Object.fromEntries(STATIONS.filter((s) => s.hasAccounts).map((s) => [s.name, channelToolsOf(s)]));
+
+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.profileFields?.size ?? 0) > 0) names.push('set_profile');
+  if (station.readsProfiles === true) names.push('get_profile');
+  names.push(...station.tools.map((t) => t.name));
+  return names.map((name) => ({ name, group: toolGroupOf(name) }));
+}

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

@@ -0,0 +1,9 @@
+import type { ToolGroup } from '@metro-labs/core/stations/types';
+
+export interface ToolDef {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  group?: ToolGroup;
+  destructive?: boolean;
+}

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

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { Line } from '@metro-labs/core/lines';
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import {
   ListToolsRequestSchema,
@@ -9,10 +10,12 @@ import {
   STATIONS,
   accountStationCapabilities,
 } from '../stations/registry.js';
-import type { Station, StationTool, ToolResult } from '../stations/types.js';
-import { COMMON_TOOLS, LIST_ACCOUNTS_TOOL } from './tool-schemas.js';
+import type { Station, StationTool, ToolResult } from '@metro-labs/core/stations/types';
+import { listedTools, stationForTool, type PublishedTool } from './tool-catalog.js';
+import { policyGate, withEffectivePolicy } from './policy-gate.js';
+import { settlePromptsFor } from '../approvals/pending.js';
 import { errResult, makeCtx, okJson, toErr } from './ctx.js';
-import { dispatchMessageTool } from './call-tools.js';
+import { dispatchMessageTool, type ToolHooks } from './call-tools.js';
 import { dispatchListMembers } from './member-tools.js';
 import {
   dispatchAddMembers,
@@ -21,16 +24,19 @@ import {
   dispatchRemoveMembers,
 } from './group-tools.js';
 import { dispatchCreateUpload } from './upload-tool.js';
-import { callTargetDenied, lineTargetDenied } from '../db/agent-scope.js';
+import { dispatchSetProfile, profileCapabilities } from './profile-tool.js';
+import { dispatchGetProfile, profileScopeLine } from './profile-lookup.js';
+import { callTargetDenied, lineTargetDenied } from '../agents/scope.js';
 import { SOURCE_KEYS } from '../stations/attach-resolve.js';
 import { decodedLengthOf } from '../stations/attach-inline.js';
-import { log } from '../daemon/log.js';
+import { log } from '@metro-labs/core/log';
 import {
   allowedAgents,
   currentIdentity,
   type RequestIdentity,
 } from './request-identity.js';
-import { str } from './str.js';
+import { str } from '@metro-labs/core/str';
+import { linelessRead, stationOfAccount } from './read-tool.js';
 
 const STATION_TOOLS = new Map<
   string,
@@ -49,21 +55,11 @@ const CORE_DISPATCH: Record<
   remove_members: dispatchRemoveMembers,
   export_invite: dispatchInviteLink,
   create_upload: dispatchCreateUpload,
+  set_profile: dispatchSetProfile,
+  get_profile: dispatchGetProfile,
 };
 
-const toolList = (): { tools: unknown[] } => ({
-  tools: [
-    ...COMMON_TOOLS,
-    ...STATIONS.flatMap((s) =>
-      s.tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        inputSchema: t.inputSchema,
-      })),
-    ),
-    LIST_ACCOUNTS_TOOL,
-  ],
-});
+export const toolList = (): { tools: PublishedTool[] } => ({ tools: listedTools() });
 
 let schemaSignature: string | undefined;
 
@@ -80,28 +76,31 @@ async function handleListAccounts(
 ): Promise<ToolResult> {
   try {
     return okJson({
-      accounts: await gatherAccounts(allowedAgents(identity)),
+      accounts: withEffectivePolicy(await gatherAccounts(allowedAgents(identity))),
       capabilities: accountStationCapabilities(),
+      profiles: profileCapabilities(),
     });
   } catch (e) {
     return errResult(`metro list_accounts failed: ${String(e)}`);
   }
 }
 
-function stationForTool(
-  name: string,
-  args: Record<string, unknown>,
-): string | undefined {
-  if (name === 'create_group') return str(args.station) || undefined;
-  return STATION_TOOLS.get(name)?.station.name;
-}
-
 export function scopeDenied(
   identity: RequestIdentity | undefined,
   name: string,
   args: Record<string, unknown>,
 ): boolean {
   const allowed = allowedAgents(identity);
+  if (name === 'read' && !str(args.line)) {
+    const account = str(args.account);
+    if (!account) return false;
+    const station = stationOfAccount(account);
+    return station === undefined || callTargetDenied(allowed, station, args);
+  }
+  if (name === 'get_profile') {
+    const line = profileScopeLine(args);
+    return line === undefined || callTargetDenied(allowed, Line.station(line) ?? '', { line });
+  }
   const station = stationForTool(name, args);
   if (station !== undefined) return callTargetDenied(allowed, station, args);
   return lineTargetDenied(allowed, args);
@@ -142,9 +141,10 @@ function logToolFailure(
   );
 }
 
-async function runTool(req: {
-  params: { name: string; arguments?: Record<string, unknown> };
-}): Promise<ToolResult> {
+async function runTool(
+  req: { params: { name: string; arguments?: Record<string, unknown> } },
+  hooks: ToolHooks,
+): Promise<ToolResult> {
   const name = req.params.name;
   const a = req.params.arguments ?? {};
 
@@ -152,6 +152,19 @@ async function runTool(req: {
   if (name !== 'list_accounts' && scopeDenied(identity, name, a))
     return errResult('metro: this account is outside your authorized scope');
 
+  settlePromptsFor(name, a);
+  const blocked = policyGate(name, a);
+  if (blocked) return blocked;
+
+  return dispatchTool(name, a, identity, hooks);
+}
+
+async function dispatchTool(
+  name: string,
+  a: Record<string, unknown>,
+  identity: RequestIdentity | undefined,
+  hooks: ToolHooks,
+): Promise<ToolResult> {
   const owned = STATION_TOOLS.get(name);
   if (owned) {
     try {
@@ -160,19 +173,18 @@ async function runTool(req: {
       return toErr(name, e);
     }
   }
-
   const core = CORE_DISPATCH[name];
   if (core) return core(a);
-
   if (name === 'list_accounts') return handleListAccounts(identity);
-
-  return dispatchMessageTool(name, a);
+  if (name === 'read' && !str(a.line)) return linelessRead(a);
+  return dispatchMessageTool(name, a, hooks);
 }
 
-export async function callToolHandler(req: {
-  params: { name: string; arguments?: Record<string, unknown> };
-}): Promise<ToolResult> {
-  const result = await runTool(req);
+export async function callToolHandler(
+  req: { params: { name: string; arguments?: Record<string, unknown> } },
+  hooks: ToolHooks = {},
+): Promise<ToolResult> {
+  const result = await runTool(req, hooks);
   if (result.isError === true)
     logToolFailure(req.params.name, req.params.arguments ?? {}, result);
   return result;
@@ -192,6 +204,7 @@ interface NotifyingExtra {
 export function registerToolHandlers(
   server: Server,
   notice?: SchemaNotice,
+  hooks: ToolHooks = {},
 ): void {
   server.setRequestHandler(ListToolsRequestSchema, () => {
     notice?.markCurrent();
@@ -206,7 +219,7 @@ export function registerToolHandlers(
       notice?.deliver(() =>
         extra.sendNotification({ method: TOOL_LIST_CHANGED }),
       );
-      return callToolHandler(req);
+      return callToolHandler(req, hooks);
     }) as Parameters<typeof server.setRequestHandler>[1],
   );
 }