@stage-labs/metro 0.1.0-beta.201 → 0.1.0-beta.202

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

@@ -58,12 +58,12 @@ async function turnOn(user: AgentUser, dir: string): Promise<Record<string, stri
   trustSystem(ca);
   memory.browsers = trustBrowsers(user);
   await runProxy(bin, configFile(dir));
-  applyFirewall(user.uid);
+  applyFirewall();
   return proxyEnvFor(TRUSTED_CA, SYSTEM_BUNDLE, secrets);
 }
 
-function turnOff(user: AgentUser): void {
-  removeFirewall(user.uid);
+function turnOff(): void {
+  removeFirewall();
   stopProxy();
   untrustSystem();
 }
@@ -72,7 +72,7 @@ export async function applyVault(user: AgentUser | null = agentUser(), dir = vau
   if (user === null) return { status: vaultStatus(null, dir), envChanged: false };
   const enabled = readVault(dir).enabled;
   try {
-    const env = enabled ? await turnOn(user, dir) : (turnOff(user), {});
+    const env = enabled ? await turnOn(user, dir) : (turnOff(), {});
     memory.problem = null;
     const envChanged = setEnv(env);
     if (envChanged || enabled) exportForJobs(user, env);

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

@@ -1,4 +1,5 @@
 import { spawn, type ChildProcess } from 'node:child_process';
+import { stringOf } from '@metro-labs/http/api-http';
 import { randomBytes } from 'node:crypto';
 import { basename } from 'node:path';
 import { createInterface } from 'node:readline';
@@ -30,8 +31,6 @@ const state: { child: ChildProcess | null; wanted: { bin: string; config: string
   startedAt: 0,
 };
 
-const text = (v: unknown): string => (typeof v === 'string' ? v : '');
-
 function swappedIds(transforms: unknown): string[] {
   if (!Array.isArray(transforms)) return [];
   return transforms.flatMap((t) => {
@@ -51,12 +50,12 @@ export function requestOf(line: string): ProxyRequest | null {
   const audit = parsed.audit;
   if (audit.method === 'CONNECT') return null;
   return {
-    at: text(parsed.time),
-    method: text(audit.method),
-    host: text(audit.host),
-    path: text(audit.path),
+    at: stringOf(parsed.time),
+    method: stringOf(audit.method),
+    host: stringOf(audit.host),
+    path: stringOf(audit.path),
     status: typeof audit.status_code === 'number' ? audit.status_code : null,
-    action: text(audit.action),
+    action: stringOf(audit.action),
     swapped: swappedIds(parsed.request_transforms),
   };
 }

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

@@ -1,4 +1,5 @@
 import { existsSync, rmSync } from 'node:fs';
+import { stringOf } from '@metro-labs/http/api-http';
 import { ApiError } from '@metro-labs/http/api-error';
 import { isRecord } from '@metro-labs/core/is-record';
 import { newId } from '@metro-labs/core/ids';
@@ -34,12 +35,10 @@ const MAX_SECRETS = 100;
 const MAX_HOSTS = 20;
 const MAX_VALUE = 16 * 1024;
 
-const str = (v: unknown): string => (typeof v === 'string' ? v : '');
-
 function secretOf(raw: unknown): VaultSecret | null {
-  if (!isRecord(raw) || typeof raw.id !== 'string' || !ENV_RE.test(str(raw.env))) return null;
+  if (!isRecord(raw) || typeof raw.id !== 'string' || !ENV_RE.test(stringOf(raw.env))) return null;
   const hosts = Array.isArray(raw.hosts) ? raw.hosts.filter((h): h is string => typeof h === 'string' && HOST_RE.test(h)) : [];
-  return { id: raw.id, name: str(raw.name) || str(raw.env), env: str(raw.env), hosts, createdAt: str(raw.createdAt), updatedAt: str(raw.updatedAt) };
+  return { id: raw.id, name: stringOf(raw.name) || stringOf(raw.env), env: stringOf(raw.env), hosts, createdAt: stringOf(raw.createdAt), updatedAt: stringOf(raw.updatedAt) };
 }
 
 export function readVault(dir = vaultDir()): VaultState {
@@ -49,35 +48,35 @@ export function readVault(dir = vaultDir()): VaultState {
   return { version: 1, enabled: raw.enabled === true, secrets };
 }
 
-export function writeVault(state: VaultState, dir = vaultDir()): void {
+function writeVault(state: VaultState, dir = vaultDir()): void {
   ensureSecureDir(dir);
   writeSecure(stateFile(dir), `${JSON.stringify(state, null, 2)}\n`);
 }
 
-export function normalizeName(raw: unknown): string {
-  const name = str(raw).trim();
+function normalizeName(raw: unknown): string {
+  const name = stringOf(raw).trim();
   if (name === '' || name.length > 80) throw new ApiError('a name of 1 to 80 characters is required', 400);
   return name;
 }
 
-export function normalizeEnv(raw: unknown): string {
-  const env = str(raw).trim();
+function normalizeEnv(raw: unknown): string {
+  const env = stringOf(raw).trim();
   if (!ENV_RE.test(env) || RESERVED_ENV.has(env))
     throw new ApiError('the variable name must be capital letters, digits and _, 3 to 64 long, like OPENAI_API_KEY', 400);
   return env;
 }
 
-export function normalizeHosts(raw: unknown): string[] {
+function normalizeHosts(raw: unknown): string[] {
   if (!Array.isArray(raw)) throw new ApiError('hosts must be a list of websites, like api.openai.com', 400);
-  const hosts = [...new Set(raw.map((h) => str(h).trim().toLowerCase().replace(/^https?:\/\//, '').replace(/\/.*$/, '')).filter((h) => h !== ''))];
+  const hosts = [...new Set(raw.map((h) => stringOf(h).trim().toLowerCase().replace(/^https?:\/\//, '').replace(/\/.*$/, '')).filter((h) => h !== ''))];
   if (hosts.length === 0 || hosts.length > MAX_HOSTS) throw new ApiError(`a secret needs 1 to ${String(MAX_HOSTS)} websites`, 400);
   const bad = hosts.find((h) => !HOST_RE.test(h));
   if (bad !== undefined) throw new ApiError(`'${bad}' is not a website name; write it as api.example.com or *.example.com`, 400);
   return hosts;
 }
 
-export function normalizeValue(raw: unknown): string {
-  const value = str(raw).trim();
+function normalizeValue(raw: unknown): string {
+  const value = stringOf(raw).trim();
   if (value === '' || value.length > MAX_VALUE) throw new ApiError('a value of 1 to 16384 characters is required', 400);
   return value;
 }

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

@@ -1,33 +1,19 @@
 import { spawnSync } from 'node:child_process';
-import { copyFileSync, chmodSync, existsSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { errMsg, log } from '@metro-labs/core/log';
 import { asUser, type AgentUser } from '../agent-user/user.js';
 import { TRUSTED_CA } from './paths.js';
-import { mustHelper, rootHelper, runningAsMetro } from '../metro-user/privilege.js';
+import { mustHelper, rootHelper } from '../metro-user/privilege.js';
 
 const has = (bin: string): boolean => spawnSync('sh', ['-c', `command -v ${bin}`], { stdio: 'ignore' }).status === 0;
 
 export function trustSystem(caFile: string): void {
   const same = existsSync(TRUSTED_CA) && readFileSync(TRUSTED_CA, 'utf8') === readFileSync(caFile, 'utf8');
-  if (same) return;
-  if (runningAsMetro()) {
-    mustHelper(['trust-ca']);
-    return;
-  }
-  copyFileSync(caFile, TRUSTED_CA);
-  chmodSync(TRUSTED_CA, 0o644);
-  const run = spawnSync('update-ca-certificates', [], { encoding: 'utf8' });
-  if (run.status !== 0) throw new Error(`update-ca-certificates failed: ${run.stderr.trim()}`);
+  if (!same) mustHelper(['trust-ca']);
 }
 
 export function untrustSystem(): void {
-  if (!existsSync(TRUSTED_CA)) return;
-  if (runningAsMetro()) {
-    mustHelper(['untrust-ca']);
-    return;
-  }
-  rmSync(TRUSTED_CA, { force: true });
-  spawnSync('update-ca-certificates', ['--fresh'], { stdio: 'ignore' });
+  if (existsSync(TRUSTED_CA)) mustHelper(['untrust-ca']);
 }
 
 const NSS_SCRIPT = [
@@ -41,10 +27,7 @@ const NSS_SCRIPT = [
 
 function ensureCertutil(): boolean {
   if (has('certutil')) return true;
-  if (runningAsMetro()) return rootHelper(['install-nss-tools']).status === 0 && has('certutil');
-  if (!has('apt-get')) return false;
-  const run = spawnSync('apt-get', ['install', '-y', '-q', 'libnss3-tools'], { stdio: 'ignore', timeout: 180_000, env: { ...process.env, DEBIAN_FRONTEND: 'noninteractive' } });
-  return run.status === 0 && has('certutil');
+  return rootHelper(['install-nss-tools']).status === 0 && has('certutil');
 }
 
 export function trustBrowsers(user: AgentUser): string | null {

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

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

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

@@ -6,18 +6,13 @@ import {
   routeOf,
 } from './accounts.js';
 import { emitOutbound, emitOutboundEdit, emitOutboundReact } from './format.js';
-import { respond } from './wire.js';
-import { normalizeDiscord } from '@metro-labs/core/stations/messaging-normalize';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 import {
   appendFiles,
   outgoingFiles,
   type OutgoingFile,
 } from './send-files.js';
-import {
-  makeStation,
-  type CallMsg,
-  type StationHandler,
-} from '@metro-labs/core/stations/station-runtime';
+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 {
@@ -57,40 +52,17 @@ async function sendMessage(
 export type { CallMsg };
 
 async function send(id: string, args: Record<string, unknown>): Promise<void> {
-  const {
-    line,
-    text,
-    replyTo,
-    embeds,
-    stickerIds,
-    images,
-    files,
-    account,
-    attachmentKinds,
-    attachmentNames,
-  } = args as {
+  const { line, text, replyTo, account } = args as {
     line: string;
     text?: string;
     replyTo?: string;
-    embeds?: unknown[];
-    stickerIds?: string[];
-    images?: string[];
-    files?: string[];
     account?: string;
-    attachmentKinds?: string[];
-    attachmentNames?: string[];
   };
   const { accountId, channelId } = routeOf(line, account);
   const body: Record<string, unknown> = { flags: 4 };
   if (text !== undefined) body.content = text;
   if (replyTo) body.message_reference = { message_id: replyTo };
-  if (embeds) body.embeds = embeds;
-  if (stickerIds) body.sticker_ids = stickerIds;
-  const outgoing = outgoingFiles(
-    [...(images ?? []), ...(files ?? [])],
-    attachmentNames,
-    attachmentKinds,
-  );
+  const outgoing = outgoingFiles(args.attachments);
   const res = await sendMessage(accountId, channelId, body, outgoing);
   emitOutbound(accountId, line, res.id, text ?? '', replyTo);
   respond(id, {
@@ -175,7 +147,7 @@ async function remove(
   respond(id, { result: { ok: true, account: accountId } });
 }
 
-async function fetchMessages(
+async function read(
   id: string,
   args: Record<string, unknown>,
 ): Promise<void> {
@@ -228,7 +200,7 @@ const HANDLERS: Record<string, StationHandler> = {
   react,
   edit,
   delete: remove,
-  fetch: fetchMessages,
+  read,
   listMembers,
   set_profile: setProfile,
   profile: readProfile,
@@ -236,5 +208,5 @@ const HANDLERS: Record<string, StationHandler> = {
 
 export const handleCall = makeStation({
   handlers: HANDLERS,
-  normalize: normalizeDiscord,
+  normalize: messagingAliases(),
 });

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

@@ -1,7 +1,7 @@
 import { MessageFlags, type Message, type MessageReaction, type User } from 'discord.js';
 import { reportAttachment, selfUri } from '@metro-labs/core/stations/train-events';
 import { accounts, lineOf } from './accounts.js';
-import { emit, mintId } from './wire.js';
+import { emit, mintId } from '@metro-labs/core/stations/station-runtime';
 import { saveDiscordAttachment } from './attachments.js';
 
 const AV_TAG: Record<string, string> = { audio: 'audio', video: 'video' };
@@ -63,7 +63,6 @@ export function messageEnvelope(
     );
   });
   return {
-    kind: 'inbound',
     id: envId,
     ts: new Date(m.createdTimestamp).toISOString(),
     station: 'discord-bot',
@@ -90,7 +89,6 @@ export function reactionEnvelope(
 ): Record<string, unknown> | null {
   if (u.bot) return null;
   return {
-    kind: 'react',
     id: mintId(),
     ts: new Date().toISOString(),
     station: 'discord-bot',
@@ -116,23 +114,20 @@ export function reactionEnvelope(
 }
 
 function outbound(
-  kind: string,
   accountId: string,
   line: string,
   messageId: string,
   extra: object,
 ): void {
   emit({
-    kind,
     id: mintId(),
     ts: new Date().toISOString(),
     station: 'discord-bot',
     line,
-    from: selfUri('discord-bot', accountId),
+    from: selfUri(),
     to: line,
     message_id: messageId,
     ...extra,
-    account: accountId,
     payload: { account: accountId },
   });
 }
@@ -144,7 +139,7 @@ export function emitOutbound(
   text: string,
   replyTo?: string,
 ): void {
-  outbound('outbound', accountId, line, messageId, {
+  outbound(accountId, line, messageId, {
     text,
     reply_to: replyTo,
     ...(replyTo ? { event: { type: 'reply', replyTo } } : {}),
@@ -156,7 +151,7 @@ export function emitOutboundReact(
   messageId: string,
   emoji: string,
 ): void {
-  outbound('react', accountId, line, messageId, {
+  outbound(accountId, line, messageId, {
     emoji,
     event: { type: 'react', emoji, targetId: messageId },
   });
@@ -167,7 +162,7 @@ export function emitOutboundEdit(
   messageId: string,
   text: string,
 ): void {
-  outbound('edit', accountId, line, messageId, {
+  outbound(accountId, line, messageId, {
     text,
     event: { type: 'edit', targetId: messageId },
   });

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

@@ -1,5 +1,5 @@
 import { routeOf, rest } from './accounts.js';
-import { respond } from './wire.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
 import {
   groupAddMembers,
   groupCreate,

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

@@ -16,7 +16,7 @@ import {
 } from './accounts.js';
 import { emitInbound } from '@metro-labs/core/stations/train-events';
 import { messageEnvelope, reactionEnvelope } from './format.js';
-import { mintId } from './wire.js';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
 import { readCalls } from '@metro-labs/core/trains/protocol';
 import { announceAccounts } from '@metro-labs/core/stations/train-boot';
 import { handleCall } from './actions.js';
@@ -45,7 +45,6 @@ function makeClient(): Client {
 function onEdit(accountId: string, m: Message): void {
   if (m.author.bot) return;
   emitInbound(accountId, {
-    kind: 'edit',
     id: mintId(),
     ts: new Date(m.editedTimestamp ?? Date.now()).toISOString(),
     station: 'discord-bot',

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

@@ -10,7 +10,7 @@ import {
 } from '@metro-labs/core/stations/profile';
 import type { SenderProfile } from '@metro-labs/core/stations/sender-profile';
 import { accountFor, accounts } from './accounts.js';
-import { respond } from './wire.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
 
 export async function applyProfile(
   client: Client,

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

@@ -1,4 +1,5 @@
 import { appendFile } from '@metro-labs/core/stations/attachments';
+import type { CanonicalAttachment } from '@metro-labs/core/stations/types';
 
 export interface OutgoingFile {
   path: string;
@@ -6,25 +7,23 @@ export interface OutgoingFile {
   kind: string;
 }
 
+type WireAttachment = CanonicalAttachment & { kind?: string };
+
 const basenameOf = (path: string, index: number): string =>
   path.split('/').pop() ?? `file-${index}`;
 
-export function outgoingFiles(
-  paths: string[],
-  names: string[] | undefined,
-  kinds: string[] | undefined,
-): OutgoingFile[] {
+export function outgoingFiles(attachments: unknown): OutgoingFile[] {
+  if (!Array.isArray(attachments)) return [];
   const out: OutgoingFile[] = [];
-  for (let i = 0; i < paths.length; i++) {
-    const path = paths[i];
-    if (path === undefined || path === '') continue;
-    const given = names?.[i];
+  (attachments as WireAttachment[]).forEach((a, i) => {
+    const path = a.path;
+    if (path === undefined || path === '') return;
     out.push({
       path,
-      name: given !== undefined && given !== '' ? given : basenameOf(path, i),
-      kind: kinds?.[i] ?? 'file',
+      name: a.name !== undefined && a.name !== '' ? a.name : basenameOf(path, i),
+      kind: a.kind ?? 'file',
     });
-  }
+  });
   return out;
 }
 

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

@@ -52,11 +52,6 @@ export function apiSession(req: IncomingMessage): Promise<ApiSession | null> {
   return bearerSessions === null ? Promise.resolve(null) : bearerSessions(req);
 }
 
-export interface AgentIdentity {
-  subject: string;
-  agentId: string;
-}
-
 export async function readJsonBody(req: IncomingMessage, max = BODY_MAX): Promise<unknown> {
   const chunks: Buffer[] = [];
   let total = 0;
@@ -136,3 +131,5 @@ export function bodyField(body: unknown, key: string): unknown {
     ? (body as Record<string, unknown>)[key]
     : undefined;
 }
+
+export const stringOf = (value: unknown): string => (typeof value === 'string' ? value : '');

package/runtime/node_modules/@metro-labs/http/src/mode-api.ts

@@ -8,7 +8,6 @@ export type DaemonMode = 'hosted' | 'local';
 export interface ModeInfo {
   mode: DaemonMode;
   owner: string | null;
-  project: string | null;
   version: string;
 }
 

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

@@ -1,13 +1,9 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import { makeAccountStore, resolveAccountId, type Die } from '@metro-labs/core/stations/account-store';
 import { TrainError } from '@metro-labs/core/train-error';
 import { refreshTokens, type FetchLike } from './auth.js';
 import { conversationOfLine } from './format.js';
 import { loadState, saveState, type AccountState } from './state.js';
 
-const ACCOUNTS_FILE = process.env.OUTLOOK_ACCOUNTS_FILE ?? join(homedir(), '.metro', 'outlook-accounts.json');
-
 const RENEW_BEFORE_MS = 5 * 60_000;
 
 export interface AccountConfig {
@@ -16,27 +12,18 @@ export interface AccountConfig {
   refreshToken: string;
   accessToken?: string;
   expiresAt?: number;
-  tenantId?: string | null;
-  deltaLink?: string | null;
   includeAutomated?: boolean;
 }
 
 function checkAccount(a: AccountConfig, die: Die): void {
-  if (!a.id) die('account missing id');
   if (typeof a.accountEmail !== 'string' || !a.accountEmail.includes('@')) die(`account '${a.id}' has no mailbox address`);
   if (typeof a.refreshToken !== 'string' || a.refreshToken === '') die(`account '${a.id}' has no refresh token`);
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
   prefix: 'outlook',
-  file: ACCOUNTS_FILE,
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) {
-      checkAccount(a, die);
-      if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-      seen.add(a.id);
-    }
+    for (const a of raw) checkAccount(a, die);
   },
 });
 
@@ -54,7 +41,6 @@ export class Account {
       refreshToken: cfg.refreshToken,
       accessToken: cfg.accessToken ?? '',
       expiresAt: cfg.expiresAt ?? 0,
-      deltaLink: cfg.deltaLink ?? null,
     });
   }
 

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

@@ -1,20 +1,14 @@
 import { makeStation, respond } from '@metro-labs/core/stations/station-runtime';
-import type { Normalized } from '@metro-labs/core/stations/messaging-normalize';
 import { accounts } from './accounts.js';
 import { MAILBOX_URL } from './config.js';
 import { reply, send } from './outbound.js';
 import { read } from './query.js';
 
-type Args = Record<string, unknown>;
-
 function listAccounts(id: string): void {
   const list = [...accounts.values()].map((a) => ({ id: a.id, handle: a.email, url: MAILBOX_URL, email: a.email }));
   respond(id, { result: { accounts: list } });
 }
 
-const normalizeOutlook = (action: string, args: Args): Normalized => ({ action, args });
-
 export const handleCall = makeStation({
   handlers: { accounts: listAccounts, send, reply, read },
-  normalize: normalizeOutlook,
 });

package/runtime/node_modules/@metro-labs/outlook/src/format.ts

@@ -86,7 +86,6 @@ export function inboundEnvelope(accountId: string, self: string, m: GraphMessage
   const from = addressOf(m.from);
   const title = titleOf(m);
   return {
-    kind: 'inbound',
     id: mintId(),
     ts: m.receivedDateTime ?? new Date().toISOString(),
     station: 'outlook',

package/runtime/node_modules/@metro-labs/outlook/src/state.ts

@@ -27,7 +27,7 @@ export function loadState(accountId: string, seed: Partial<AccountState>): Accou
     refreshToken,
     accessToken: fromFile ? text(saved.accessToken) : text(seed.accessToken),
     expiresAt: fromFile ? Number(saved.expiresAt) || 0 : Number(seed.expiresAt) || 0,
-    deltaLink: nullable(saved.deltaLink) ?? seed.deltaLink ?? null,
+    deltaLink: nullable(saved.deltaLink),
     syncedAt: nullable(saved.syncedAt),
     seen: Array.isArray(saved.seen) ? saved.seen.filter((s): s is string => typeof s === 'string') : [],
   };

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

@@ -1,5 +1,3 @@
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import {
   makeAccountStore,
   resolveAccountId,
@@ -7,31 +5,22 @@ import {
 } from '@metro-labs/core/stations/account-store';
 import type { UserAccount } from './types.js';
 
-const ACCOUNTS_FILE =
-  process.env.TELEGRAM_ACCOUNTS_FILE ??
-  join(homedir(), '.metro', 'telegram-accounts.json');
-
 const isSignedInt = (s: string): boolean => /^-?\d+$/.test(s);
 const isTopic = (s: string): boolean => /^\d+$/.test(s);
 
-function validateAccount(a: UserAccount, seen: Set<string>, die: Die): void {
-  if (!a.id) die('account missing id');
+function validateAccount(a: UserAccount, die: Die): void {
   if (!a.session || typeof a.session !== 'string')
     die(`account '${a.id}' missing session`);
   if (!Number.isInteger(a.apiId) || (a.apiId ?? 0) <= 0)
     die(`account '${a.id}' missing apiId`);
   if (!a.apiHash || typeof a.apiHash !== 'string')
     die(`account '${a.id}' missing apiHash`);
-  if (seen.has(a.id)) die(`duplicate account id '${a.id}'`);
-  seen.add(a.id);
 }
 
 export const { loadAccounts } = makeAccountStore<UserAccount>({
   prefix: 'telegram',
-  file: ACCOUNTS_FILE,
   validate(raw, die) {
-    const seen = new Set<string>();
-    for (const a of raw) validateAccount(a, seen, die);
+    for (const a of raw) validateAccount(a, die);
   },
 });
 
@@ -56,20 +45,13 @@ interface Target {
   topicId?: number;
 }
 
-function splitScoped(path: string[]): { accountId: string; rest: string[] } {
-  const first = path[0];
-  if (path.length >= 2 && first !== undefined && !isSignedInt(first))
-    return { accountId: first, rest: path.slice(1) };
-  return { accountId: 'default', rest: path };
-}
-
 export function targetOf(line: string): Target | undefined {
   const prefix = 'metro://telegram/';
   if (!line.startsWith(prefix)) return undefined;
   const path = line.slice(prefix.length).split('/').filter(Boolean);
-  const { accountId, rest } = splitScoped(path);
+  const [accountId, ...rest] = path;
   const [chatId, topicId] = rest;
-  if (rest.length < 1 || rest.length > 2 || chatId === undefined) return undefined;
+  if (accountId === undefined || chatId === undefined || rest.length > 2) return undefined;
   if (!isSignedInt(chatId)) return undefined;
   if (topicId !== undefined && !isTopic(topicId)) return undefined;
   return {