@stage-labs/metro 0.1.0-beta.85 → 0.1.0-beta.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.85",
+  "version": "0.1.0-beta.87",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

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

@@ -1,5 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from '@metro-labs/core/log';
+import { normalizeAllowlist } from './allowlist.js';
+import type { RecentSender } from './senders.js';
 import { ApiError } from '@metro-labs/http/api-error';
 import {
   apiFailure,
@@ -63,13 +65,24 @@ export interface AccountApiDeps {
     accountId: string,
   ) => Promise<AccountRef>;
   syncStations: (station: StationName) => Promise<void>;
+  reloadAgents: () => Promise<void>;
+  setAllowlist: (
+    subject: string,
+    agentId: string,
+    station: StationName,
+    accountId: string,
+    allowlist: string[],
+  ) => Promise<string[]>;
+  recentSenders: (station: StationName, accountId: string) => RecentSender[];
 }
 
 export type AccountRoute =
   | { kind: 'start' }
   | { kind: 'session'; attachId: string }
   | { kind: 'step'; attachId: string }
-  | { kind: 'account'; station: StationName; accountId: string };
+  | { kind: 'account'; station: StationName; accountId: string }
+  | { kind: 'allowlist'; station: StationName; accountId: string }
+  | { kind: 'senders'; station: StationName; accountId: string };
 
 export const ATTACHABLE: string[] = [
   ...ATTACHABLE_STATIONS,
@@ -81,6 +94,8 @@ const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   session: ['GET', 'DELETE'],
   step: ['POST'],
   account: ['DELETE'],
+  allowlist: ['PUT'],
+  senders: ['GET'],
 };
 
 function twoSegmentRoute(head: string, tail: string): AccountRoute | null {
@@ -100,10 +115,17 @@ export function accountRoute(rest: string[]): AccountRoute | null {
       : ATTACH_ID_RE.test(head)
         ? { kind: 'session', attachId: head }
         : null;
+  if (rest.length === 3 && tail !== undefined) return accountSubRoute(head, tail, rest[2]);
   if (rest.length !== 2 || tail === undefined) return null;
   return twoSegmentRoute(head, tail);
 }
 
+function accountSubRoute(head: string, tail: string, sub: string | undefined): AccountRoute | null {
+  if (!isStationName(head) || (sub !== 'allowlist' && sub !== 'senders')) return null;
+  const accountId = parseAccountId(tail);
+  return accountId === null ? null : { kind: sub, station: head, accountId };
+}
+
 export function accountRouteAllows(
   route: AccountRoute,
   method: string | undefined,
@@ -242,6 +264,36 @@ async function handleDetach(
   });
 }
 
+async function applied(deps: AccountApiDeps): Promise<boolean> {
+  try {
+    await deps.reloadAgents();
+    return true;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'account-api: allowlist reload failed, the change lands at the next boot');
+    return false;
+  }
+}
+
+async function handleAllowlist(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  session: ApiSession,
+  agentId: string,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  const wanted = normalizeAllowlist(bodyField(await readJsonBody(req), 'allowlist'));
+  const allowlist = await deps.setAllowlist(session.subject, agentId, target.station, target.accountId, wanted);
+  log.info({ agentId, station: target.station, account: target.accountId, senders: allowlist.length }, 'account-api: allowlist set');
+  sendJson(req, res, 200, {
+    agentId,
+    station: target.station,
+    accountId: target.accountId,
+    allowlist,
+    activated: await applied(deps),
+  });
+}
+
 async function handleSession(
   req: IncomingMessage,
   res: ServerResponse,
@@ -292,6 +344,11 @@ async function dispatchRoute(
     );
   if (route.kind === 'step')
     return handleStep(req, res, deps, ownerOf(session, agentId), route.attachId);
+  if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, session, agentId, route);
+  if (route.kind === 'senders') {
+    sendJson(req, res, 200, { senders: deps.recentSenders(route.station, route.accountId) });
+    return;
+  }
   return handleDetach(req, res, deps, session, agentId, route);
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/agents/allowlist.ts

@@ -0,0 +1,37 @@
+import { ApiError } from '@metro-labs/http/api-error';
+
+export const EVERYONE = '*';
+const MAX_ENTRIES = 500;
+const MAX_LENGTH = 200;
+
+function hasControlChar(value: string): boolean {
+  for (const ch of value) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code < 0x20 || code === 0x7f) return true;
+  }
+  return false;
+}
+
+function senderId(entry: unknown): string {
+  if (typeof entry !== 'string') throw new ApiError('allowlist must be a list of sender ids', 400);
+  const value = entry.trim();
+  if (value.length > MAX_LENGTH || hasControlChar(value))
+    throw new ApiError(`a sender id is at most ${String(MAX_LENGTH)} plain characters`, 400);
+  return value;
+}
+
+export function normalizeAllowlist(raw: unknown): string[] {
+  if (!Array.isArray(raw)) throw new ApiError('allowlist must be a list of sender ids', 400);
+  if (raw.length > MAX_ENTRIES) throw new ApiError(`allowlist holds at most ${String(MAX_ENTRIES)} senders`, 400);
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const entry of raw) {
+    const value = senderId(entry);
+    if (value === EVERYONE) return [EVERYONE];
+    const key = value.toLowerCase();
+    if (key === '' || seen.has(key)) continue;
+    seen.add(key);
+    out.push(value);
+  }
+  return out.length === 0 ? [EVERYONE] : out;
+}

package/runtime/node_modules/@metro-labs/daemon/src/agents/file-admin.ts

@@ -310,6 +310,22 @@ export async function localAttachAccount(
   return Promise.resolve({ agentId, station, accountId });
 }
 
+export async function localSetAllowlist(
+  subject: string,
+  agentId: string,
+  station: StationName,
+  accountId: string,
+  allowlist: string[],
+  dir = agentsDir(),
+): Promise<string[]> {
+  const stored = ownedOrThrow(subject, agentId, dir);
+  const account = stored.file.stations.find((a) => a.station === station && a.id === accountId);
+  if (account === undefined) throw new AgentAdminError('no such account on this agent', 404);
+  account.allowlist = allowlist;
+  save(stored);
+  return Promise.resolve(allowlist);
+}
+
 export async function localDetachAccount(
   subject: string,
   agentId: string,

package/runtime/node_modules/@metro-labs/daemon/src/agents/map.ts

@@ -65,6 +65,10 @@ export function stationAgentIds(station: string): string[] {
     .map(([, id]) => id);
 }
 
+export function allowlistForAccount(station: string, accountId: string): string[] | undefined {
+  return allowlistMap[mapKey(station, accountId)];
+}
+
 export function allowlistForLine(line: string): string[] | undefined {
   const a = accountFromLine(line);
   return a ? allowlistMap[mapKey(a.station, a.accountId)] : undefined;

package/runtime/node_modules/@metro-labs/daemon/src/agents/senders.ts

@@ -0,0 +1,38 @@
+import { bufferedSince, type MetroEvent } from '@metro-labs/core/events';
+import { accountFromLine } from './map.js';
+
+export interface RecentSender {
+  id: string;
+  name: string;
+  at: string;
+}
+
+const DEFAULT_LIMIT = 20;
+
+const SKIP = new Set(['', 'self', 'unknown']);
+
+function sameAccount(from: string, station: string, accountId: string): boolean {
+  const account = accountFromLine(from);
+  return account?.station === station && account.accountId === accountId;
+}
+
+function senderOf(event: MetroEvent, station: string, accountId: string): { id: string; name: string } | null {
+  const from = String(event.from);
+  if (event.station !== station || !sameAccount(from, station, accountId)) return null;
+  const id = from.split('/').pop() ?? '';
+  if (SKIP.has(id)) return null;
+  return { id, name: event.fromDisplayName ?? event.fromName ?? '' };
+}
+
+export function recentSenders(station: string, accountId: string, limit = DEFAULT_LIMIT): RecentSender[] {
+  const seen = new Set<string>();
+  const out: RecentSender[] = [];
+  for (const { event } of bufferedSince(0).reverse()) {
+    const sender = senderOf(event, station, accountId);
+    if (sender === null || seen.has(sender.id.toLowerCase())) continue;
+    seen.add(sender.id.toLowerCase());
+    out.push({ ...sender, at: event.ts });
+    if (out.length >= limit) break;
+  }
+  return out;
+}

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

@@ -102,6 +102,9 @@ async function syncStations(station: StationName): Promise<void> {
 function sessionApis(): SessionApis {
   return localSessionApis({
       syncStations,
+      reloadAgents: async () => {
+        await reloadFrom(fileSource);
+      },
       restart: () => {
         exitCode = RESTART_EXIT;
         onShutdown();

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

@@ -4,6 +4,14 @@ import { apiFailure, apiSession, cors, readJsonBody, sendJson } from '@metro-lab
 import { ApiError } from '@metro-labs/http/api-error';
 import { isRecord } from '@metro-labs/core/is-record';
 import { listClaudeSettings, SETTINGS_MAX, writeClaudeSettings } from './settings.js';
+import {
+  createClaudeSkill,
+  deleteClaudeSkill,
+  listClaudeSkills,
+  readClaudeSkill,
+  skillHomes,
+  writeClaudeSkill,
+} from './skills.js';
 import {
   answerClaudeLogin,
   claudeAccount,
@@ -54,6 +62,10 @@ const COLLECTIONS: Record<string, Handler> = {
   sessions: (query, dir) => ({ sessions: listClaudeSessions(projectOf(query), dir) }),
   memory: (query, dir) => listMemory(projectOf(query), dir),
   settings: (_query, dir) => ({ files: listClaudeSettings(dir) }),
+  skills: (_query, dir) => ({
+    skills: listClaudeSkills(dir),
+    places: skillHomes(dir).map((home) => ({ id: home.prefix, scope: home.scope, where: home.where })),
+  }),
 };
 
 const ITEMS: Record<string, Handler> = {
@@ -62,17 +74,30 @@ const ITEMS: Record<string, Handler> = {
     return readTranscript(projectOf(query), id, offset, limit, dir);
   },
   memory: (query, dir, name) => ({ name, content: readMemoryFile(projectOf(query), name, dir) }),
+  skills: (_query, dir, id) => readClaudeSkill(decodeURIComponent(id), dir),
 };
 
 const parts = (path: string): string[] => path.slice(PREFIX.length + 1).split('/').filter(Boolean);
 
+const seenIn = (body: Record<string, unknown>): string | null | undefined =>
+  'seenAt' in body ? (typeof body.seenAt === 'string' ? body.seenAt : null) : undefined;
+
 async function writeAnswer(req: IncomingMessage, path: string, dir: string): Promise<unknown> {
   const [head = '', item = ''] = parts(path);
-  if (head !== 'settings' || item === '') throw new ApiError('method not allowed', 405);
+  if ((head !== 'settings' && head !== 'skills') || item === '') throw new ApiError('method not allowed', 405);
   const body = await readJsonBody(req, BODY_MAX);
   if (!isRecord(body) || typeof body.text !== 'string') throw new ApiError('text is required', 400);
-  const seenAt = 'seenAt' in body ? (typeof body.seenAt === 'string' ? body.seenAt : null) : undefined;
-  return writeClaudeSettings(item, body.text, seenAt, dir);
+  if (head === 'skills') return writeClaudeSkill(decodeURIComponent(item), body.text, seenIn(body), dir);
+  return writeClaudeSettings(item, body.text, seenIn(body), dir);
+}
+
+async function created(req: IncomingMessage, path: string, dir: string): Promise<unknown> {
+  const rest = parts(path);
+  if (rest.length !== 1 || rest[0] !== 'skills') throw new ApiError('method not allowed', 405);
+  const body = await readJsonBody(req, BODY_MAX);
+  if (!isRecord(body) || typeof body.name !== 'string') throw new ApiError('name is required', 400);
+  const scope = typeof body.scope === 'string' ? body.scope : undefined;
+  return createClaudeSkill(body.name, scope, typeof body.text === 'string' ? body.text : undefined, dir);
 }
 
 const LOGIN = 'login';
@@ -94,7 +119,9 @@ async function loginAnswer(req: IncomingMessage, id: string, deps: ClaudeApiDeps
 
 function removed(rest: string[], query: URLSearchParams, dir: string): unknown {
   const [head = '', item = ''] = rest;
-  if (rest.length !== 2 || head !== 'sessions') throw new ApiError('method not allowed', 405);
+  if (rest.length !== 2) throw new ApiError('method not allowed', 405);
+  if (head === 'skills') return { deleted: deleteClaudeSkill(decodeURIComponent(item), dir) };
+  if (head !== 'sessions') throw new ApiError('method not allowed', 405);
   deleteClaudeSession(projectOf(query), item, dir);
   return { deleted: item };
 }
@@ -132,6 +159,7 @@ export function handleClaudeRequest(
       const [head = '', item = ''] = parts(path);
       if (head === LOGIN) return loginAnswer(req, item, deps);
       if (req.method === 'PUT') return writeAnswer(req, path, dir);
+      if (req.method === 'POST') return created(req, path, dir);
       return answer(req.method ?? 'GET', path, new URLSearchParams(search), dir);
     })
     .then((body) => {

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

@@ -0,0 +1,154 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { ApiError } from '@metro-labs/http/api-error';
+import { claudeDir, listClaudeProjects } from './files.js';
+
+export const SKILL_MAX = 256 * 1024;
+export const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const USER_SCOPE = 'user';
+const FILE = 'SKILL.md';
+const DEFAULT_MODE = 0o644;
+const SUMMARY_MAX = 300;
+
+export type SkillScope = 'user' | 'project';
+
+export interface ClaudeSkill {
+  id: string;
+  name: string;
+  title: string;
+  description: string;
+  scope: SkillScope;
+  where: string;
+  path: string;
+  editable: boolean;
+  updatedAt: string | null;
+}
+
+const frontmatterField = (text: string, field: string): string => {
+  const head = text.startsWith('---') ? text.slice(3, text.indexOf('\n---', 3)) : '';
+  for (const line of head.split('\n')) {
+    const at = line.indexOf(':');
+    if (at > 0 && line.slice(0, at).trim() === field) return line.slice(at + 1).trim().replace(/^["']|["']$/g, '').slice(0, SUMMARY_MAX);
+  }
+  return '';
+};
+
+function entryOf(id: string, name: string, scope: SkillScope, where: string, path: string): ClaudeSkill {
+  const stat = statSync(path);
+  const editable = stat.size <= SKILL_MAX;
+  const text = editable ? readFileSync(path, 'utf8') : '';
+  return {
+    id,
+    name,
+    title: frontmatterField(text, 'name') || name,
+    description: frontmatterField(text, 'description'),
+    scope,
+    where,
+    path,
+    editable,
+    updatedAt: stat.mtime.toISOString(),
+  };
+}
+
+function skillsIn(root: string, prefix: string, scope: SkillScope, where: string): ClaudeSkill[] {
+  if (!existsSync(root)) return [];
+  const out: ClaudeSkill[] = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !SKILL_NAME_RE.test(entry.name)) continue;
+    const path = join(root, entry.name, FILE);
+    if (existsSync(path)) out.push(entryOf(`${prefix}:${entry.name}`, entry.name, scope, where, path));
+  }
+  return out;
+}
+
+export const userSkillsRoot = (dir: string): string => join(dir, 'skills');
+
+export interface SkillHome {
+  prefix: string;
+  scope: SkillScope;
+  where: string;
+  root: string;
+}
+
+export function skillHomes(dir = claudeDir()): SkillHome[] {
+  const homes: SkillHome[] = [{ prefix: USER_SCOPE, scope: USER_SCOPE, where: 'This machine', root: userSkillsRoot(dir) }];
+  for (const project of listClaudeProjects(dir)) {
+    const cwd = project.cwd;
+    if (cwd === null || !existsSync(cwd)) continue;
+    homes.push({ prefix: project.id, scope: 'project', where: cwd, root: join(cwd, '.claude', 'skills') });
+  }
+  return homes;
+}
+
+export function listClaudeSkills(dir = claudeDir()): ClaudeSkill[] {
+  const out = skillHomes(dir).flatMap((home) => skillsIn(home.root, home.prefix, home.scope, home.where));
+  return out.sort((a, b) => (b.updatedAt ?? '').localeCompare(a.updatedAt ?? '') || a.name.localeCompare(b.name));
+}
+
+function found(id: string, dir: string): ClaudeSkill {
+  const skill = listClaudeSkills(dir).find((entry) => entry.id === id);
+  if (skill === undefined) throw new ApiError('no such skill', 404);
+  return skill;
+}
+
+export function readClaudeSkill(id: string, dir = claudeDir()): ClaudeSkill & { text: string } {
+  const skill = found(id, dir);
+  return { ...skill, text: skill.editable ? readFileSync(skill.path, 'utf8') : '' };
+}
+
+function writeAtomic(path: string, text: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.metro-${String(process.pid)}`;
+  writeFileSync(tmp, text, { mode: DEFAULT_MODE });
+  renameSync(tmp, path);
+}
+
+function assertText(text: string): void {
+  if (text.length > SKILL_MAX) throw new ApiError('that is more text than a skill may hold', 413);
+  if (text.trim() === '') throw new ApiError('a skill needs some text', 400);
+}
+
+export function writeClaudeSkill(
+  id: string,
+  text: string,
+  seenAt: string | null | undefined,
+  dir = claudeDir(),
+): ClaudeSkill {
+  const skill = found(id, dir);
+  if (!skill.editable) throw new ApiError('that skill is too large to edit here', 409);
+  assertText(text);
+  if (seenAt !== undefined && seenAt !== skill.updatedAt)
+    throw new ApiError('that skill changed on disk since you opened it; reload it before saving', 409);
+  writeAtomic(skill.path, text);
+  return entryOf(skill.id, skill.name, skill.scope, skill.where, skill.path);
+}
+
+export const skillTemplate = (name: string): string =>
+  ['---', `name: ${name}`, 'description: what this skill does, and when Claude should reach for it', '---', '', `# ${name}`, '', 'Write the instructions here.', ''].join('\n');
+
+export function createClaudeSkill(
+  name: string,
+  scope: string | undefined,
+  text: string | undefined,
+  dir = claudeDir(),
+): ClaudeSkill {
+  if (typeof name !== 'string' || !SKILL_NAME_RE.test(name))
+    throw new ApiError('a skill name is lowercase letters, digits and dashes, up to 64 characters', 400);
+  const prefix = scope === undefined || scope === '' ? USER_SCOPE : scope;
+  const home = skillHomes(dir).find((h) => h.prefix === prefix);
+  if (home === undefined) throw new ApiError('no such place to keep a skill', 404);
+  const path = join(home.root, name, FILE);
+  if (existsSync(path)) throw new ApiError('a skill by that name already lives there', 409);
+  const body = text === undefined || text.trim() === '' ? skillTemplate(name) : text;
+  assertText(body);
+  writeAtomic(path, body);
+  return entryOf(`${home.prefix}:${name}`, name, home.scope, home.where, path);
+}
+
+export function deleteClaudeSkill(id: string, dir = claudeDir()): string {
+  const skill = found(id, dir);
+  const folder = dirname(skill.path);
+  if (basename(folder) !== skill.name) throw new ApiError('that skill does not live in its own folder', 409);
+  rmSync(folder, { recursive: true, force: true });
+  return id;
+}

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

@@ -5,7 +5,7 @@ import {
 } from '../stations/registry.js';
 import { listEndpoints } from '../net/tunnel.js';
 import { hookUrl } from '../stations/attach.js';
-import { agentIdForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
+import { agentIdForAccount, allowlistForAccount, knownAccounts, type KnownAccount } from '../agents/map.js';
 
 const accountId = (acc: unknown): string | undefined => {
   const id = (acc as { id?: unknown }).id;
@@ -23,7 +23,9 @@ function withAgentId(station: string, acc: unknown): unknown {
   const id = typeof rec.id === 'string' ? rec.id : undefined;
   if (id === undefined) return acc;
   const agentId = agentIdForAccount(station, id);
-  return agentId === undefined ? acc : { ...rec, agentId };
+  if (agentId === undefined) return acc;
+  const allowlist = allowlistForAccount(station, id);
+  return allowlist === undefined ? { ...rec, agentId } : { ...rec, agentId, allowlist };
 }
 
 export function attachAgentIds(

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -1,6 +1,7 @@
 import { ApiError } from '@metro-labs/http/api-error';
 import { errMsg, log } from '@metro-labs/core/log';
 import { AttachSessions } from '../stations/attach-session.js';
+import { recentSenders } from '../agents/senders.js';
 import type { AgentApiDeps } from '../agents/api.js';
 import { ATTACHABLE, type AccountApiDeps } from '../agents/accounts-api.js';
 import type { SessionApis } from './session-apis.js';
@@ -33,6 +34,7 @@ import {
   localCreateAgent,
   localDeleteAgent,
   localDetachAccount,
+  localSetAllowlist,
   localImportAgent,
   localListAgents,
   localOwnedAgentOrThrow,
@@ -46,6 +48,7 @@ import type { StationName } from '@metro-labs/core/station-names';
 
 export interface LocalModeDeps {
   syncStations: (station: StationName) => Promise<void>;
+  reloadAgents: () => Promise<void>;
   restart: () => void;
   stop: () => void;
   closeAgentSession: (id: string) => Promise<boolean>;
@@ -98,6 +101,9 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
     attachAccount: localAttachAccount,
     detachAccount: localDetachAccount,
     syncStations: deps.syncStations,
+    setAllowlist: localSetAllowlist,
+    recentSenders,
+    reloadAgents: deps.reloadAgents,
   };
 }
 

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.85"
+  "version": "0.1.0-beta.87"
 }