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

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

@@ -0,0 +1,190 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import { previewMatches } from './preview.js';
+import { sameCall, speechTarget, type CallRoute, type CallSource } from '@metro-labs/core/call';
+
+export const NEEDS_APPROVAL = (where: string, tool: string): string =>
+  `Needs the owner's approval for ${where} (${tool}). Make this exact call from a background worker so Claude Code asks the owner in chat, and wait for the answer. An approval given only in the terminal does not count.`;
+
+export type Behavior = 'allow' | 'deny';
+
+export type AnsweredVia = 'chat' | 'page' | 'expiry';
+
+export interface PendingPrompt {
+  requestId: string;
+  tool: string;
+  description: string;
+  preview: string;
+  line: string | undefined;
+  at: number;
+  call?: CallSource;
+  origin?: 'mcp-server';
+}
+
+interface Held extends PendingPrompt {
+  owner: object;
+  send: (behavior: Behavior) => Promise<void>;
+  tell: ((text: string) => Promise<void>) | undefined;
+}
+
+const PENDING_MAX = 500;
+const SWEEP_MS = 60_000;
+const APPROVAL_TTL_MS = 24 * 3_600_000;
+
+const held = new Map<string, Held>();
+
+interface Grant {
+  tool: string;
+  preview: string;
+  at: number;
+  owner: object;
+  requestId: string;
+  call?: CallSource;
+}
+
+const GRANT_TTL_MS = 10 * 60_000;
+const GRANTS_MAX = 200;
+let grants: Grant[] = [];
+
+function grant(entry: Held, now = Date.now()): void {
+  grants = [...grants.filter((g) => now - g.at < GRANT_TTL_MS), {
+    tool: entry.tool, preview: entry.preview, at: now, owner: entry.owner, requestId: entry.requestId,
+    ...(entry.call === undefined ? {} : { call: entry.call }),
+  }].slice(-GRANTS_MAX);
+}
+
+function speechMatches(grant: Grant, args: Record<string, unknown>): boolean {
+  if (args.speech === undefined) return grant.call === undefined;
+  const target = speechTarget(args.speech);
+  const bound = grant.call;
+  return target !== null && bound !== undefined && bound.route.line === args.line && bound.route.callId === target.callId &&
+    bound.route.generation === target.generation && bound.sourceId === target.sourceId;
+}
+
+export function takeGrant(toolMatches: (tool: string) => boolean, args: Record<string, unknown>, now = Date.now()): boolean {
+  const at = grants.findIndex((g) => now - g.at < GRANT_TTL_MS && toolMatches(g.tool) && speechMatches(g, args) && previewMatches(g.preview, args));
+  if (at < 0) return false;
+  grants = grants.filter((_, i) => i !== at);
+  return true;
+}
+
+const shown = ({ requestId, tool, description, preview, line, at }: Held): PendingPrompt => ({
+  requestId,
+  tool,
+  description,
+  preview,
+  line,
+  at,
+});
+
+export function holdPrompt(
+  prompt: PendingPrompt,
+  owner: object,
+  send: (behavior: Behavior) => Promise<void>,
+  tell?: (text: string) => Promise<void>,
+): void {
+  held.set(prompt.requestId, { ...prompt, owner, send, tell });
+  while (held.size > PENDING_MAX) {
+    const oldest = held.keys().next();
+    if (oldest.done) break;
+    held.delete(oldest.value);
+  }
+}
+
+export const pendingPrompts = (): PendingPrompt[] => [...held.values()].map(shown).sort((a, b) => b.at - a.at);
+
+export const promptLine = (requestId: string): string | undefined => held.get(requestId)?.line;
+
+export const isPromptHeld = (requestId: string): boolean => held.has(requestId);
+
+function chatNotice(via: AnsweredVia, behavior: Behavior): string | undefined {
+  if (via === 'expiry') return 'Expired, denied.';
+  if (via === 'page') return behavior === 'allow' ? 'Approved on the page.' : 'Denied on the page.';
+  return undefined;
+}
+
+async function tellChat(entry: Held, via: AnsweredVia, behavior: Behavior): Promise<void> {
+  const text = chatNotice(via, behavior);
+  if (text === undefined || entry.tell === undefined) return;
+  await entry.tell(text).catch((err: unknown) => {
+    log.warn({ requestId: entry.requestId, err: errMsg(err) }, 'approvals: the chat could not be told the answer');
+  });
+}
+
+export async function answerPrompt(
+  requestId: string,
+  behavior: Behavior,
+  via: AnsweredVia,
+  who: string = via,
+): Promise<PendingPrompt | undefined> {
+  const entry = held.get(requestId);
+  if (entry === undefined) return undefined;
+  held.delete(requestId);
+  const server = entry.origin === 'mcp-server';
+  if (behavior === 'allow' && via !== 'expiry' && !server) grant(entry);
+  log.info(
+    { requestId, tool: entry.tool, behavior, by: who === via ? via : `${via} ${who}` },
+    server ? 'approvals: an mcp.metro.box approval answered' : 'approvals: a Claude Code permission prompt answered',
+  );
+  await entry.send(behavior);
+  await tellChat(entry, via, behavior);
+  return shown(entry);
+}
+
+export function forgetPromptsOf(owner: object): void {
+  for (const [id, entry] of held) if (entry.owner === owner) held.delete(id);
+  grants = grants.filter((entry) => entry.owner !== owner);
+}
+
+export function cancelPrompt(requestId: string, owner: object): void {
+  grants = grants.filter((entry) => entry.owner !== owner || entry.requestId !== requestId);
+  const entry = held.get(requestId);
+  if (entry?.owner !== owner) return;
+  held.delete(requestId);
+  entry.send('deny').catch((err: unknown) => {
+    log.warn({ requestId, err: errMsg(err) }, 'approvals: cancelled prompt could not be answered');
+  });
+}
+
+export function revokeCallPrompts(route: CallRoute): void {
+  grants = grants.filter((entry) => entry.call === undefined || !sameCall(entry.call.route, route));
+  for (const entry of held.values())
+    if (entry.call !== undefined && sameCall(entry.call.route, route)) cancelPrompt(entry.requestId, entry.owner);
+}
+
+function settlePrompts(toolMatches: (tool: string) => boolean, args: Record<string, unknown>): void {
+  for (const [id, entry] of held)
+    if (entry.origin !== 'mcp-server' && toolMatches(entry.tool) && previewMatches(entry.preview, args)) {
+      held.delete(id);
+      log.info({ requestId: id, tool: entry.tool }, 'approvals: the call reached metro, so Claude Code already closed the prompt');
+    }
+}
+
+export const settlePromptsFor = (name: string, args: Record<string, unknown>): void => {
+  settlePrompts((tool) => tool.endsWith(`__${name}`), args);
+};
+
+export async function expirePrompts(now = Date.now(), ttl = APPROVAL_TTL_MS): Promise<number> {
+  const overdue = [...held.values()].filter((entry) => now - entry.at >= ttl);
+  for (const entry of overdue)
+    await answerPrompt(entry.requestId, 'deny', 'expiry').catch((err: unknown) => {
+      log.warn({ requestId: entry.requestId, err: errMsg(err) }, 'approvals: the expiry answer could not be sent');
+    });
+  return overdue.length;
+}
+
+export function startPromptExpiry(): () => void {
+  const timer = setInterval(() => {
+    expirePrompts().catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'approvals: the expiry sweep failed');
+    });
+  }, SWEEP_MS);
+  timer.unref();
+  return () => {
+    clearInterval(timer);
+  };
+}
+
+export function forgetAllPrompts(): void {
+  held.clear();
+  grants = [];
+}

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

@@ -0,0 +1,66 @@
+import { isDeepStrictEqual } from 'node:util';
+import { isRecord } from '@metro-labs/core/is-record';
+
+const ELIDED = '\u0000';
+
+const CODE_POINTS = /(?:\\n|\n)⋯ \d+ code points elided ⋯(?:\\n|\n)/g;
+const FIELD_BLOCK = /[\s,]*(?:\\n|\n)?\s*⋯[^]*$/;
+
+export interface ReadPreview {
+  input: Record<string, unknown> | undefined;
+  partial: boolean;
+}
+
+function parsedRecord(text: string): Record<string, unknown> | undefined {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function readPreview(preview: string): ReadPreview {
+  const text = preview.replace(CODE_POINTS, '\\u0000');
+  const whole = parsedRecord(text);
+  if (whole !== undefined) return { input: whole, partial: false };
+  if (!text.includes('⋯')) return { input: undefined, partial: false };
+  const head = text.replace(FIELD_BLOCK, '').replace(/[\s,]*$/, '');
+  const input = parsedRecord(`${head}}`) ?? parsedRecord(head);
+  return { input, partial: input !== undefined };
+}
+
+export const shownValue = (text: string): string => text.split(ELIDED).join('…');
+
+function stringMatches(shown: string, real: string): boolean {
+  if (!shown.includes(ELIDED)) return shown === real;
+  const [first = '', ...rest] = shown.split(ELIDED);
+  const last = rest.pop() ?? '';
+  if (!real.startsWith(first) || !real.endsWith(last)) return false;
+  let at = first.length;
+  for (const part of rest) {
+    const found = real.indexOf(part, at);
+    if (found < 0) return false;
+    at = found + part.length;
+  }
+  return at <= real.length - last.length;
+}
+
+function valueMatches(shown: unknown, real: unknown): boolean {
+  if (typeof shown === 'string') return typeof real === 'string' && stringMatches(shown, real);
+  if (Array.isArray(shown))
+    return Array.isArray(real) && shown.length === real.length && shown.every((v, i) => valueMatches(v, real[i]));
+  if (isRecord(shown)) return isRecord(real) && recordMatches(shown, real, false);
+  return isDeepStrictEqual(shown, real);
+}
+
+function recordMatches(shown: Record<string, unknown>, real: Record<string, unknown>, partial: boolean): boolean {
+  const keys = Object.keys(shown);
+  if (!partial && keys.length !== Object.keys(real).length) return false;
+  return keys.every((key) => key in real && valueMatches(shown[key], real[key]));
+}
+
+export function previewMatches(preview: string, args: Record<string, unknown>): boolean {
+  const { input, partial } = readPreview(preview);
+  return input !== undefined && recordMatches(input, args, partial);
+}

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

@@ -0,0 +1,264 @@
+import { join } from 'node:path';
+import { type Server } from 'node:http';
+import { userSelf } from '@metro-labs/core/events';
+import { setTrainCallBackend } from '../stations/train-call.js';
+import { errMsg, log, logFatalSync } from '@metro-labs/core/log';
+import { acquireLock, STATE_DIR, trainsDir } from './paths.js';
+import { installCrashGuard, markDaemonReady } from './crash-guard.js';
+import { METRO_VERSION } from '@metro-labs/core/version';
+import { funnelDriver, Tunnel, tunnelWanted } from '../net/tunnel.js';
+import { publicBaseUrl, webhookPort } from '../files/attach-serve.js';
+import { setManagedHost } from '@metro-labs/gmail/managed-binding';
+import {
+  localConnectHint,
+  publicConnectHint,
+  tunnelPendingHint,
+} from './connect-hint.js';
+import { TrainSupervisor } from '../stations/supervisor.js';
+import {
+  makeEmit,
+  startWebhookServer,
+  trainEventToMetroEvent,
+} from '../routes/http.js';
+import { agentsDir, fileSource } from '../agents/files.js';
+import { stopMcpServer, watchMcpServer } from '../mcp-server/link.js';
+import { refreshConnectorTools, watchConnectorTools } from '../mcp-server/connector-tools.js';
+import { setAnnouncedFile } from '../mcp-server/announced.js';
+import { holdServerApproval } from '../mcp/server-approvals.js';
+import { removeConnectorLeftovers } from '../connectors/leftovers.js';
+import { runningAsRoot } from '../metro-user/privilege.js';
+import { prepareAgentRunner, provisionAgentUser } from '../agent-user/provision.js';
+import { applyVault } from '../vault/index.js';
+import { blockImds } from '../metro-user/imds.js';
+import { followRelease } from '../metro-user/root-follow.js';
+import { unwatchSession, watchSession } from '../claude/session.js';
+import { liveEvents, memoryRoutine, tryClaudeSetup } from '../claude/setup.js';
+import { tryMemoryJob } from '../claude/memory-routine.js';
+import { githubSkills } from '../claude/github-skills.js';
+import { applyLocalOwner } from './local-owner.js';
+import { installBearerSessions } from '../routes/bearer.js';
+import { ensureLocalAgent, localOwner } from '../agents/file-admin.js';
+import { ensureStationDeps } from '../stations/runtime-deps.js';
+import { localSessionApis } from '../routes/local-mode.js';
+import type { SessionApis } from '../routes/session-apis.js';
+import { createMetroMcp } from '../mcp/index.js';
+import { startPromptExpiry } from '../approvals/pending.js';
+import { setOwnerLineFile } from '../approvals/owner-line.js';
+import { watchPolicySnapshot } from '../mcp/policy-snapshot.js';
+import { gatherAccountsForAgents } from '../mcp/accounts.js';
+import { stationToolGroups } from '../mcp/tool-catalog.js';
+import {
+  accountStationCapabilities,
+  forgetOrphans,
+  stationByName,
+} from '../stations/registry.js';
+import { prepareAccount } from '../stations/attach.js';
+import { knownAccounts } from '../agents/map.js';
+import { materializeFrom, reloadFrom } from '../stations/materialize.js';
+import type { StationName } from '@metro-labs/core/station-names';
+import { startUploadReaper } from '../files/upload-store.js';
+import { startAttachReaper } from '../files/attach-reaper.js';
+import { startCloudWatchPublisher } from '../server/cloudwatch.js';
+import { watchFallbackUsage } from '../gateway/usage-refresh.js';
+import { startOrgModels, stopOrgModels } from '../gateway/org-models.js';
+import { effectiveSetup, watchModelChanges } from '../gateway/effective.js';
+import { readClaudeLogins, retireV2ModelFile } from '../gateway/claude-store.js';
+import { removeModelLeftovers } from '../gateway/model-leftovers.js';
+import { readAgentKey } from '../connectors/agent-key.js';
+import { METRO_API } from '../connectors/metro-api.js';
+import { isCallEvent, leaveCallsForShutdown, onCallEvent, sweepLeftoverCalls } from '../voice/calls.js';
+
+installCrashGuard();
+acquireLock(join(STATE_DIR, '.tail-lock'));
+setOwnerLineFile(join(STATE_DIR, 'approval-line.json'));
+setAnnouncedFile(join(agentsDir(), 'mcp-approvals.json'));
+
+log.info({ self: userSelf() }, 'user identity');
+
+process.stdout.on('error', (err) => {
+  if ((err as NodeJS.ErrnoException).code !== 'EPIPE')
+    log.warn({ err: errMsg(err) }, 'stdout error');
+});
+
+const supervisor = new TrainSupervisor();
+const emit = makeEmit();
+
+supervisor.onTrainEvent((env, train) => {
+  if (isCallEvent(env)) {
+    onCallEvent(env, train);
+    return;
+  }
+  const entry = trainEventToMetroEvent(env, train);
+  if (entry) emit(entry);
+});
+
+let webhookServer: Server | null = null;
+const syncGmailHost = (): void => { setManagedHost(publicBaseUrl()); };
+const tunnel = tunnelWanted() ? new Tunnel(funnelDriver(webhookPort()), announcePublic, undefined, syncGmailHost) : null;
+
+function announcePublic(url: string): void {
+  process.stderr.write(`\n${publicConnectHint(url, localOwner())}`);
+}
+
+setTrainCallBackend((train, action, args) =>
+  supervisor.call(train, action, args),
+);
+
+function announceLocalEndpoint(): void {
+  process.stderr.write(
+    `\n${tunnel === null ? localConnectHint(webhookPort(), localOwner()) : tunnelPendingHint()}`,
+  );
+}
+
+async function syncStations(station: StationName): Promise<void> {
+  const { removed } = await reloadFrom(fileSource);
+  if (stationByName(station)?.hasTrain === false) return;
+  if (removed.includes(station)) await supervisor.stopTrain(station);
+  else {
+    ensureStationDeps(station);
+    supervisor.requestReload(station);
+  }
+}
+
+function sessionApis(setLiveEvents: (on: boolean) => void): SessionApis {
+  return localSessionApis({
+      syncStations,
+      reloadAgents: async () => {
+        await reloadFrom(fileSource);
+      },
+      restart: () => {
+        exitCode = RESTART_EXIT;
+        onShutdown();
+      },
+      stop: () => {
+        exitCode = HOLD_EXIT;
+        onShutdown();
+      },
+      gatherAccounts: gatherAccountsForAgents,
+      capabilities: accountStationCapabilities,
+      toolGroups: stationToolGroups,
+      prepareAccount,
+      liveEvents: setLiveEvents,
+    });
+}
+
+
+async function main(): Promise<void> {
+  removeConnectorLeftovers();
+  removeModelLeftovers();
+  retireV2ModelFile();
+  applyLocalOwner();
+installBearerSessions(agentsDir(), localOwner);
+  watchPolicySnapshot();
+  log.info({ agent: await ensureLocalAgent() }, 'local daemon: agent');
+  await materializeFrom(fileSource);
+  ensureStationDeps();
+  forgetOrphans(knownAccounts());
+  syncGmailHost();
+  supervisor.start();
+  sweepLeftoverCalls();
+  const models = startOrgModels({ owner: localOwner, key: () => readAgentKey(), api: METRO_API });
+  const metroMcp = await createMetroMcp({ liveEvents: liveEvents() });
+  watchModelChanges(models, metroMcp.switchModel);
+  webhookServer = await startWebhookServer(
+    emit,
+    sessionApis(metroMcp.setLiveEvents),
+    metroMcp.httpHandler,
+    true,
+  );
+  metroMcp.startInbound();
+  startPromptExpiry();
+  startUploadReaper();
+  startAttachReaper();
+  watchMcpServer({
+    owner: localOwner,
+    hold: (approval, answer) => {
+      holdServerApproval(approval, answer, emit);
+    },
+    registered: () => {
+      refreshConnectorTools().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'mcp-server: the connector tools could not be read after the token was registered');
+      });
+    },
+  });
+  watchConnectorTools();
+  startCloudWatchPublisher();
+  watchFallbackUsage(() => effectiveSetup(), () => readClaudeLogins());
+  announceLocalEndpoint();
+  tunnel?.start();
+  log.info(
+    { tunnel: !!tunnel, trainsDir: trainsDir(), mcp: '/', version: METRO_VERSION },
+    'dispatcher ready',
+  );
+  markDaemonReady();
+  startClaude().catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'claude: could not start the Claude Code side');
+  });
+}
+
+async function startClaude(): Promise<void> {
+  if (runningAsRoot()) {
+    log.error('claude: Metro runs as root, so Claude Code never starts here; reinstall Metro as the metro user');
+    return;
+  }
+  const agentUser = provisionAgentUser();
+  if (agentUser !== 'off') log.info({ agentUser }, 'agent-user: Claude Code runs as its own user');
+  if (agentUser === 'failed') return;
+  if (agentUser === 'ready') {
+    blockImds();
+    followRelease();
+    const vault = (await applyVault()).status;
+    if (vault.enabled) log.info({ running: vault.running, problem: vault.problem }, 'vault: the agent reaches the internet through the vault');
+  }
+  tryClaudeSetup();
+  try { githubSkills().watch(); } catch { log.warn('github-skills: saved source could not be loaded'); }
+  tryMemoryJob(memoryRoutine());
+  if (agentUser === 'ready') await prepareAgentRunner();
+  watchSession();
+}
+
+const SHUTDOWN_TIMEOUT_MS = 3_000;
+const RESTART_EXIT = 75;
+const HOLD_EXIT = 76;
+let exitCode = 0;
+let shuttingDown = false;
+async function shutdown(): Promise<void> {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log.info('dispatcher shutting down');
+  stopMcpServer().catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'mcp-server: could not stop the approval relay');
+  });
+  const leaving = leaveCallsForShutdown();
+  stopOrgModels();
+  unwatchSession();
+  tunnel?.stop();
+  if (webhookServer) {
+    const server = webhookServer;
+    await Promise.race([
+      new Promise<void>((r) => {
+        server.close(() => {
+          r();
+        });
+      }),
+      new Promise<void>((r) => {
+        setTimeout(r, SHUTDOWN_TIMEOUT_MS).unref();
+      }),
+    ]);
+  }
+  await leaving;
+  await supervisor.stop();
+  process.exit(exitCode);
+}
+const onShutdown = (): void => {
+  shutdown().catch((err: unknown) => {
+    log.error({ err: errMsg(err) }, 'dispatcher: shutdown failed');
+    process.exit(1);
+  });
+};
+for (const sig of ['SIGINT', 'SIGTERM'] as const) process.on(sig, onShutdown);
+
+await main().catch((err: unknown) => {
+  logFatalSync({ err: errMsg(err) }, 'dispatcher failed to start');
+  process.exit(1);
+});

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

@@ -0,0 +1,36 @@
+import { hostname } from 'node:os';
+
+const connectLink = (base: string): string => `https://metro.box/#/${new URL(base).host}`;
+
+const ownerLine = (owner: string | null): string =>
+  owner === null
+    ? 'No owner is set, so nobody can sign in. Restart with:  metro serve --owner <organization id>'
+    : `Only members of the organization ${owner} can sign in.`;
+
+export function localConnectHint(port: number, owner: string | null): string {
+  const here = `http://127.0.0.1:${String(port)}`;
+  const forward = `ssh -L ${String(port)}:127.0.0.1:${String(port)} ${hostname()}`;
+  return [
+    'Manage this machine from the web UI:',
+    '',
+    `  ${connectLink(here)}`,
+    '',
+    `From another computer, forward the port first:  ${forward}`,
+    ownerLine(owner),
+    '',
+  ].join('\n');
+}
+
+export function publicConnectHint(url: string, owner: string | null): string {
+  return [
+    'Manage this machine from the web UI, from anywhere:',
+    '',
+    `  ${connectLink(url)}`,
+    '',
+    ownerLine(owner),
+    '',
+  ].join('\n');
+}
+
+export const tunnelPendingHint = (): string =>
+  'Publishing this daemon through Tailscale Funnel… (if Tailscale asks to enable Funnel, its link is in the log)\n';

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

@@ -1,4 +1,4 @@
-import { errMsg, log, logFatalSync } from './log.js';
+import { errMsg, log, logFatalSync } from '@metro-labs/core/log';
 
 export type CrashKind = 'unhandledRejection' | 'uncaughtException';
 

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

@@ -0,0 +1,21 @@
+import { localOwner, setLocalOwner } from '../agents/file-admin.js';
+import { isOrganizationId } from '@metro-labs/http/workos-token';
+import { log } from '@metro-labs/core/log';
+
+export function applyLocalOwner(): string | null {
+  const wanted = process.env.METRO_OWNER?.trim() ?? '';
+  const stored = localOwner();
+  if (stored !== null) {
+    if (wanted !== '' && wanted !== stored)
+      log.info({ owner: stored, ignored: wanted }, 'local daemon: this machine already belongs to an organization, so --owner is ignored');
+    return stored;
+  }
+  if (isOrganizationId(wanted)) {
+    const owner = setLocalOwner(wanted);
+    log.info({ owner }, 'local daemon: owner set from METRO_OWNER');
+    return owner;
+  }
+  if (wanted !== '') log.info({ ignored: wanted }, 'local daemon: --owner is not an organization id, so it is ignored');
+  log.warn('local daemon: no organization owns this machine, so nobody can sign in; restart with metro serve --owner <organization id>');
+  return null;
+}

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

@@ -1,8 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import {
   closeSync,
-  existsSync,
-  mkdirSync,
   openSync,
   readFileSync,
   unlinkSync,
@@ -10,45 +8,19 @@ import {
 } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { log } from './log.js';
+import { fileURLToPath } from 'node:url';
+import { log } from '@metro-labs/core/log';
+import { ensureSecureDir } from '@metro-labs/core/secure-fs';
 
 export const STATE_DIR =
   process.env.METRO_STATE_DIR ?? join(homedir(), '.cache', 'metro');
-mkdirSync(STATE_DIR, { recursive: true });
+ensureSecureDir(STATE_DIR);
 
-export const CONFIG_DIR =
-  process.env.METRO_CONFIG_DIR ??
-  join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), 'metro');
-export const CONFIG_ENV_FILE = join(CONFIG_DIR, '.env');
 
-export const TRAINS_ENV_FILE = join(homedir(), '.metro', '.env');
-
-export const envSources = (): readonly string[] => [
-  join(process.cwd(), '.env'),
-  TRAINS_ENV_FILE,
-  CONFIG_ENV_FILE,
-];
-
-const LINE_RE = /^\s*([A-Za-z_]\w*)\s*=\s*(.*?)\s*$/;
-const QUOTED_RE = /^(['"])(.*)\1$/;
-
-export function readDotenv(path: string): Record<string, string> {
-  if (!existsSync(path)) return {};
-  const out: Record<string, string> = {};
-  for (const line of readFileSync(path, 'utf8').split('\n')) {
-    const m = LINE_RE.exec(line);
-    if (m?.[1] !== undefined && m[2] !== undefined)
-      out[m[1]] = m[2].replace(QUOTED_RE, '$2');
-  }
-  return out;
-}
-
-export function loadMetroEnv(): void {
-  for (const path of envSources()) {
-    for (const [k, v] of Object.entries(readDotenv(path))) {
-      process.env[k] ??= v;
-    }
-  }
+export function trainsDir(): string {
+  const env = process.env.METRO_TRAINS_DIR?.trim();
+  if (env !== undefined && env !== '') return env;
+  return fileURLToPath(new URL('../../trains', import.meta.url));
 }
 
 function readLockPid(lockFile: string): number {

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

@@ -0,0 +1,26 @@
+import { str } from '@metro-labs/core/str';
+
+export type Addressed = 'direct' | 'mention' | 'reply';
+
+interface AddressFacts {
+  isPrivate?: unknown;
+  mentionsSelf?: unknown;
+  replyToSelf?: unknown;
+}
+
+export function addressedBy(facts: AddressFacts, replyTo: string, sent: ReadonlySet<string>): Addressed | undefined {
+  if (facts.isPrivate === true) return 'direct';
+  if (facts.mentionsSelf === true) return 'mention';
+  if (facts.replyToSelf === true || (replyTo !== '' && sent.has(replyTo))) return 'reply';
+  return undefined;
+}
+
+export function replyMeta(ev: Record<string, unknown>, sent: ReadonlySet<string>): Record<string, string> {
+  const replyTo = str(ev.replyTo);
+  const addressed = addressedBy(ev, replyTo, sent);
+  return {
+    ...(replyTo ? { reply_to: replyTo } : {}),
+    ...(addressed === undefined ? {} : { addressed }),
+    ...(typeof ev.senderVerified === 'boolean' ? { sender_verified: String(ev.senderVerified) } : {}),
+  };
+}